← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-linaro-mx51/quantal

« back to all changes in this revision

Viewing changes to ubuntu/iscsitarget/config.c

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-3o58a3c1bj7x00rs
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
ubuntu/iscsitarget/config.c
1
 
/*
2
 
 * (C) 2004 - 2005 FUJITA Tomonori <tomof@acm.org>
3
 
 *
4
 
 * This code is licenced under the GPL.
5
 
 */
6
 
 
7
 
#include <linux/proc_fs.h>
8
 
 
9
 
#include "iscsi.h"
10
 
#include "iscsi_dbg.h"
11
 
 
12
 
static DEFINE_SEMAPHORE(ioctl_sem);
13
 
 
14
 
struct proc_entries {
15
 
        const char *name;
16
 
        struct file_operations *fops;
17
 
};
18
 
 
19
 
static struct proc_entries iet_proc_entries[] =
20
 
{
21
 
        {"volume", &volume_seq_fops},
22
 
        {"session", &session_seq_fops},
23
 
};
24
 
 
25
 
static struct proc_dir_entry *proc_iet_dir;
26
 
 
27
 
void iet_procfs_exit(void)
28
 
{
29
 
        int i;
30
 
 
31
 
        if (!proc_iet_dir)
32
 
                return;
33
 
 
34
 
        for (i = 0; i < ARRAY_SIZE(iet_proc_entries); i++)
35
 
                remove_proc_entry(iet_proc_entries[i].name, proc_iet_dir);
36
 
 
37
 
        remove_proc_entry(proc_iet_dir->name, proc_iet_dir->parent);
38
 
}
39
 
 
40
 
int iet_procfs_init(void)
41
 
{
42
 
        int i;
43
 
        struct proc_dir_entry *ent;
44
 
 
45
 
        if (!(proc_iet_dir = proc_mkdir("iet", init_net.proc_net)))
46
 
                goto err;
47
 
 
48
 
        for (i = 0; i < ARRAY_SIZE(iet_proc_entries); i++) {
49
 
                ent = create_proc_entry(iet_proc_entries[i].name, 0, proc_iet_dir);
50
 
                if (ent)
51
 
                        ent->proc_fops = iet_proc_entries[i].fops;
52
 
                else
53
 
                        goto err;
54
 
        }
55
 
 
56
 
        return 0;
57
 
 
58
 
err:
59
 
        if (proc_iet_dir)
60
 
                iet_procfs_exit();
61
 
 
62
 
        return -ENOMEM;
63
 
}
64
 
 
65
 
static int get_module_info(unsigned long ptr)
66
 
{
67
 
        struct module_info info;
68
 
        int err;
69
 
 
70
 
        snprintf(info.version, sizeof(info.version), "%s", IET_VERSION_STRING);
71
 
 
72
 
        err = copy_to_user((void *) ptr, &info, sizeof(info));
73
 
        if (err)
74
 
                return -EFAULT;
75
 
 
76
 
        return 0;
77
 
}
78
 
 
79
 
static int get_conn_info(struct iscsi_target *target, unsigned long ptr)
80
 
{
81
 
        struct iscsi_session *session;
82
 
        struct iscsi_conn *conn;
83
 
        struct conn_info info;
84
 
        int err;
85
 
 
86
 
        err = copy_from_user(&info, (void *) ptr, sizeof(info));
87
 
        if (err)
88
 
                return -EFAULT;
89
 
 
90
 
        session = session_lookup(target, info.sid);
91
 
        if (!session)
92
 
                return -ENOENT;
93
 
 
94
 
        conn = conn_lookup(session, info.cid);
95
 
        if (!conn)
96
 
                return -ENOENT;
97
 
 
98
 
        info.cid = conn->cid;
99
 
        info.stat_sn = conn->stat_sn;
100
 
        info.exp_stat_sn = conn->exp_stat_sn;
101
 
 
102
 
        err = copy_to_user((void *) ptr, &info, sizeof(info));
103
 
        if (err)
104
 
                return -EFAULT;
105
 
 
106
 
        return 0;
107
 
}
108
 
 
109
 
static int add_conn(struct iscsi_target *target, unsigned long ptr)
110
 
{
111
 
        struct iscsi_session *session;
112
 
        struct conn_info info;
113
 
        int err;
114
 
 
115
 
        err = copy_from_user(&info, (void *) ptr, sizeof(info));
116
 
        if (err)
117
 
                return -EFAULT;
118
 
 
119
 
        session = session_lookup(target, info.sid);
120
 
        if (!session)
121
 
                return -ENOENT;
122
 
 
123
 
        return conn_add(session, &info);
124
 
}
125
 
 
126
 
static int del_conn(struct iscsi_target *target, unsigned long ptr)
127
 
{
128
 
        struct iscsi_session *session;
129
 
        struct conn_info info;
130
 
        int err;
131
 
 
132
 
        err = copy_from_user(&info, (void *) ptr, sizeof(info));
133
 
        if (err)
134
 
                return -EFAULT;
135
 
 
136
 
        session = session_lookup(target, info.sid);
137
 
        if (!session)
138
 
                return -ENOENT;
139
 
 
140
 
        return conn_del(session, &info);
141
 
}
142
 
 
143
 
static int get_session_info(struct iscsi_target *target, unsigned long ptr)
144
 
{
145
 
        struct iscsi_session *session;
146
 
        struct session_info info;
147
 
        int err;
148
 
 
149
 
        err = copy_from_user(&info, (void *) ptr, sizeof(info));
150
 
        if (err)
151
 
                return -EFAULT;
152
 
 
153
 
        session = session_lookup(target, info.sid);
154
 
        if (!session)
155
 
                return -ENOENT;
156
 
 
157
 
        info.exp_cmd_sn = session->exp_cmd_sn;
158
 
        info.max_cmd_sn = session->max_cmd_sn;
159
 
 
160
 
        err = copy_to_user((void *) ptr, &info, sizeof(info));
161
 
        if (err)
162
 
                return -EFAULT;
163
 
 
164
 
        return 0;
165
 
}
166
 
 
167
 
static int add_session(struct iscsi_target *target, unsigned long ptr)
168
 
{
169
 
        struct session_info info;
170
 
        int err;
171
 
 
172
 
        err = copy_from_user(&info, (void *) ptr, sizeof(info));
173
 
        if (err)
174
 
                return -EFAULT;
175
 
 
176
 
        return session_add(target, &info);
177
 
}
178
 
 
179
 
static int del_session(struct iscsi_target *target, unsigned long ptr)
180
 
{
181
 
        struct session_info info;
182
 
        int err;
183
 
 
184
 
        err = copy_from_user(&info, (void *) ptr, sizeof(info));
185
 
        if (err)
186
 
                return -EFAULT;
187
 
 
188
 
        return session_del(target, info.sid);
189
 
}
190
 
 
191
 
static int add_volume(struct iscsi_target *target, unsigned long ptr)
192
 
{
193
 
        struct volume_info info;
194
 
        int err;
195
 
 
196
 
        err = copy_from_user(&info, (void *) ptr, sizeof(info));
197
 
        if (err)
198
 
                return -EFAULT;
199
 
 
200
 
        return volume_add(target, &info);
201
 
}
202
 
 
203
 
static int del_volume(struct iscsi_target *target, unsigned long ptr)
204
 
{
205
 
        struct volume_info info;
206
 
        int err;
207
 
 
208
 
        err = copy_from_user(&info, (void *) ptr, sizeof(info));
209
 
        if (err)
210
 
                return -EFAULT;
211
 
 
212
 
        return iscsi_volume_del(target, &info);
213
 
}
214
 
 
215
 
static int iscsi_param_config(struct iscsi_target *target, unsigned long ptr, int set)
216
 
{
217
 
        struct iscsi_param_info info;
218
 
        int err;
219
 
 
220
 
        err = copy_from_user(&info, (void *) ptr, sizeof(info));
221
 
        if (err)
222
 
                return -EFAULT;
223
 
 
224
 
        err = iscsi_param_set(target, &info, set);
225
 
        if (err < 0 || set)
226
 
                return err;
227
 
 
228
 
        err = copy_to_user((void *) ptr, &info, sizeof(info));
229
 
        if (err)
230
 
                return -EFAULT;
231
 
 
232
 
        return 0;
233
 
}
234
 
 
235
 
static int add_target(unsigned long ptr)
236
 
{
237
 
        struct target_info info;
238
 
        int err;
239
 
 
240
 
        err = copy_from_user(&info, (void *) ptr, sizeof(info));
241
 
        if (err)
242
 
                return -EFAULT;
243
 
 
244
 
        err = target_add(&info);
245
 
        if (err < 0)
246
 
                return err;
247
 
 
248
 
        err = copy_to_user((void *) ptr, &info, sizeof(info));
249
 
        if (err)
250
 
                return -EFAULT;
251
 
 
252
 
        return 0;
253
 
}
254
 
 
255
 
static long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
256
 
{
257
 
        struct iscsi_target *target = NULL;
258
 
        long err;
259
 
        u32 id;
260
 
 
261
 
        err = down_interruptible(&ioctl_sem);
262
 
        if (err < 0)
263
 
                return err;
264
 
 
265
 
        if (cmd == GET_MODULE_INFO) {
266
 
                err = get_module_info(arg);
267
 
                goto done;
268
 
        }
269
 
 
270
 
        if (cmd == ADD_TARGET) {
271
 
                err = add_target(arg);
272
 
                goto done;
273
 
        }
274
 
 
275
 
        err = get_user(id, (u32 *) arg);
276
 
        if (err < 0)
277
 
                goto done;
278
 
 
279
 
        /* locking handled in target_del */
280
 
        if (cmd == DEL_TARGET) {
281
 
                err = target_del(id);
282
 
                goto done;
283
 
        }
284
 
 
285
 
        target = target_lookup_by_id(id);
286
 
        if (!target) {
287
 
                err = -ENOENT;
288
 
                goto done;
289
 
        }
290
 
 
291
 
        err = target_lock(target, 1);
292
 
        if (err < 0)
293
 
                goto done;
294
 
 
295
 
        switch (cmd) {
296
 
        case ADD_VOLUME:
297
 
                err = add_volume(target, arg);
298
 
                break;
299
 
 
300
 
        case DEL_VOLUME:
301
 
                err = del_volume(target, arg);
302
 
                break;
303
 
 
304
 
        case ADD_SESSION:
305
 
                err = add_session(target, arg);
306
 
                break;
307
 
 
308
 
        case DEL_SESSION:
309
 
                err = del_session(target, arg);
310
 
                break;
311
 
 
312
 
        case GET_SESSION_INFO:
313
 
                err = get_session_info(target, arg);
314
 
                break;
315
 
 
316
 
        case ISCSI_PARAM_SET:
317
 
                err = iscsi_param_config(target, arg, 1);
318
 
                break;
319
 
 
320
 
        case ISCSI_PARAM_GET:
321
 
                err = iscsi_param_config(target, arg, 0);
322
 
                break;
323
 
 
324
 
        case ADD_CONN:
325
 
                err = add_conn(target, arg);
326
 
                break;
327
 
 
328
 
        case DEL_CONN:
329
 
                err = del_conn(target, arg);
330
 
                break;
331
 
 
332
 
        case GET_CONN_INFO:
333
 
                err = get_conn_info(target, arg);
334
 
                break;
335
 
        default:
336
 
                eprintk("invalid ioctl cmd %x\n", cmd);
337
 
                err = -EINVAL;
338
 
        }
339
 
 
340
 
        target_unlock(target);
341
 
done:
342
 
        up(&ioctl_sem);
343
 
 
344
 
        return err;
345
 
}
346
 
 
347
 
static int release(struct inode *i __attribute__((unused)),
348
 
                   struct file *f __attribute__((unused)))
349
 
{
350
 
        down(&ioctl_sem);
351
 
        target_del_all();
352
 
        up(&ioctl_sem);
353
 
 
354
 
        return 0;
355
 
}
356
 
 
357
 
struct file_operations ctr_fops = {
358
 
        .owner          = THIS_MODULE,
359
 
        .unlocked_ioctl = ioctl,
360
 
        .compat_ioctl   = ioctl,
361
 
        .release        = release
362
 
};