1 /*
2 * Network block device - make block devices work over TCP
3 *
4 * Note that you can not swap over this thing, yet. Seems to work but
5 * deadlocks sometimes - you can not swap over TCP in general.
6 *
7 * Copyright 1997-2000 Pavel Machek <pavel@ucw.cz>
8 *
9 * (part of code stolen from loop.c)
10 *
11 * 97-3-25 compiled 0-th version, not yet tested it
12 * (it did not work, BTW) (later that day) HEY! it works!
13 * (bit later) hmm, not that much... 2:00am next day:
14 * yes, it works, but it gives something like 50kB/sec
15 * 97-4-01 complete rewrite to make it possible for many requests at
16 * once to be processed
17 * 97-4-11 Making protocol independent of endianity etc.
18 * 97-9-13 Cosmetic changes
19 * 98-5-13 Attempt to make 64-bit-clean on 64-bit machines
20 * 99-1-11 Attempt to make 64-bit-clean on 32-bit machines <ankry@mif.pg.gda.pl>
21 *
22 * possible FIXME: make set_sock / set_blksize / set_size / do_it one syscall
23 * why not: would need verify_area and friends, would share yet another
24 * structure with userland
25 */
26
27 #undef NBD_PLUGGABLE
28 #define PARANOIA
29 #include <linux/major.h>
30
31 #include <linux/module.h>
32
33 #include <linux/sched.h>
34 #include <linux/fs.h>
35 #include <linux/stat.h>
36 #include <linux/errno.h>
37 #include <linux/file.h>
38 #include <linux/ioctl.h>
39 #include <net/sock.h>
40
41 #include <linux/devfs_fs_kernel.h>
42
43 #include <asm/segment.h>
44 #include <asm/uaccess.h>
45 #include <asm/types.h>
46
47 #define MAJOR_NR NBD_MAJOR
48 #include <linux/nbd.h>
49
50 #define LO_MAGIC 0x68797548
51
52 static int nbd_blksizes[MAX_NBD];
53 static int nbd_blksize_bits[MAX_NBD];
54 static int nbd_sizes[MAX_NBD];
55 static u64 nbd_bytesizes[MAX_NBD];
56
57 static struct nbd_device nbd_dev[MAX_NBD];
58 static devfs_handle_t devfs_handle;
59
60 #define DEBUG( s )
61 /* #define DEBUG( s ) printk( s )
62 */
63
64 #ifdef PARANOIA
65 static int requests_in;
66 static int requests_out;
67 #endif
68
69 static void nbd_plug_device(request_queue_t *q, kdev_t dev) { }
70
71 static int nbd_open(struct inode *inode, struct file *file)
72 {
73 int dev;
74
75 if (!inode)
76 return -EINVAL;
77 dev = MINOR(inode->i_rdev);
78 if (dev >= MAX_NBD)
79 return -ENODEV;
80
81 nbd_dev[dev].refcnt++;
82 MOD_INC_USE_COUNT;
83 return 0;
84 }
85
86 /*
87 * Send or receive packet.
88 */
89 static int nbd_xmit(int send, struct socket *sock, char *buf, int size)
90 {
91 mm_segment_t oldfs;
92 int result;
93 struct msghdr msg;
94 struct iovec iov;
95 unsigned long flags;
96 sigset_t oldset;
97
98 oldfs = get_fs();
99 set_fs(get_ds());
100
101 spin_lock_irqsave(¤t->sigmask_lock, flags);
102 oldset = current->blocked;
103 sigfillset(¤t->blocked);
104 recalc_sigpending(current);
105 spin_unlock_irqrestore(¤t->sigmask_lock, flags);
106
107
108 do {
109 sock->sk->allocation = GFP_BUFFER;
110 iov.iov_base = buf;
111 iov.iov_len = size;
112 msg.msg_name = NULL;
113 msg.msg_namelen = 0;
114 msg.msg_iov = &iov;
115 msg.msg_iovlen = 1;
116 msg.msg_control = NULL;
117 msg.msg_controllen = 0;
118 msg.msg_namelen = 0;
119 msg.msg_flags = 0;
120
121 if (send)
122 result = sock_sendmsg(sock, &msg, size);
123 else
124 result = sock_recvmsg(sock, &msg, size, 0);
125
126 if (result <= 0) {
127 #ifdef PARANOIA
128 printk(KERN_ERR "NBD: %s - sock=%ld at buf=%ld, size=%d returned %d.\n",
129 send ? "send" : "receive", (long) sock, (long) buf, size, result);
130 #endif
131 break;
132 }
133 size -= result;
134 buf += result;
135 } while (size > 0);
136
137 spin_lock_irqsave(¤t->sigmask_lock, flags);
138 current->blocked = oldset;
139 recalc_sigpending(current);
140 spin_unlock_irqrestore(¤t->sigmask_lock, flags);
141
142 set_fs(oldfs);
143 return result;
144 }
145
146 #define FAIL( s ) { printk( KERN_ERR "NBD: " s "(result %d)\n", result ); goto error_out; }
147
148 void nbd_send_req(struct socket *sock, struct request *req)
149 {
150 int result;
151 struct nbd_request request;
152
153 DEBUG("NBD: sending control, ");
154 request.magic = htonl(NBD_REQUEST_MAGIC);
155 request.type = htonl(req->cmd);
156 request.from = cpu_to_be64( (u64) req->sector << 9);
157 request.len = htonl(req->current_nr_sectors << 9);
158 memcpy(request.handle, &req, sizeof(req));
159
160 result = nbd_xmit(1, sock, (char *) &request, sizeof(request));
161 if (result <= 0)
162 FAIL("Sendmsg failed for control.");
163
164 if (req->cmd == WRITE) {
165 DEBUG("data, ");
166 result = nbd_xmit(1, sock, req->buffer, req->current_nr_sectors << 9);
167 if (result <= 0)
168 FAIL("Send data failed.");
169 }
170 return;
171
172 error_out:
173 req->errors++;
174 }
175
176 #define HARDFAIL( s ) { printk( KERN_ERR "NBD: " s "(result %d)\n", result ); lo->harderror = result; return NULL; }
177 struct request *nbd_read_stat(struct nbd_device *lo)
178 /* NULL returned = something went wrong, inform userspace */
179 {
180 int result;
181 struct nbd_reply reply;
182 struct request *xreq, *req;
183
184 DEBUG("reading control, ");
185 reply.magic = 0;
186 result = nbd_xmit(0, lo->sock, (char *) &reply, sizeof(reply));
187 if (result <= 0)
188 HARDFAIL("Recv control failed.");
189 memcpy(&xreq, reply.handle, sizeof(xreq));
190 req = blkdev_entry_prev_request(&lo->queue_head);
191
192 if (xreq != req)
193 FAIL("Unexpected handle received.\n");
194
195 DEBUG("ok, ");
196 if (ntohl(reply.magic) != NBD_REPLY_MAGIC)
197 HARDFAIL("Not enough magic.");
198 if (ntohl(reply.error))
199 FAIL("Other side returned error.");
200 if (req->cmd == READ) {
201 DEBUG("data, ");
202 result = nbd_xmit(0, lo->sock, req->buffer, req->current_nr_sectors << 9);
203 if (result <= 0)
204 HARDFAIL("Recv data failed.");
205 }
206 DEBUG("done.\n");
207 return req;
208
209 /* Can we get here? Yes, if other side returns error */
210 error_out:
211 req->errors++;
212 return req;
213 }
214
215 void nbd_do_it(struct nbd_device *lo)
216 {
217 struct request *req;
218 int dequeued;
219
220 down (&lo->queue_lock);
221 while (1) {
222 up (&lo->queue_lock);
223 req = nbd_read_stat(lo);
224 down (&lo->queue_lock);
225
226 if (!req) {
227 printk(KERN_ALERT "req should never be null\n" );
228 goto out;
229 }
230 #ifdef PARANOIA
231 if (req != blkdev_entry_prev_request(&lo->queue_head)) {
232 printk(KERN_ALERT "NBD: I have problem...\n");
233 }
234 if (lo != &nbd_dev[MINOR(req->rq_dev)]) {
235 printk(KERN_ALERT "NBD: request corrupted!\n");
236 continue;
237 }
238 if (lo->magic != LO_MAGIC) {
239 printk(KERN_ALERT "NBD: nbd_dev[] corrupted: Not enough magic\n");
240 goto out;
241 }
242 #endif
243 list_del(&req->queue);
244 up (&lo->queue_lock);
245
246 dequeued = nbd_end_request(req);
247
248 down (&lo->queue_lock);
249 if (!dequeued)
250 list_add(&req->queue, &lo->queue_head);
251 }
252 out:
253 up (&lo->queue_lock);
254 }
255
256 void nbd_clear_que(struct nbd_device *lo)
257 {
258 struct request *req;
259 int dequeued;
260
261 #ifdef PARANOIA
262 if (lo->magic != LO_MAGIC) {
263 printk(KERN_ERR "NBD: nbd_dev[] corrupted: Not enough magic when clearing!\n");
264 return;
265 }
266 #endif
267
268 while (!list_empty(&lo->queue_head)) {
269 req = blkdev_entry_prev_request(&lo->queue_head);
270 #ifdef PARANOIA
271 if (!req) {
272 printk( KERN_ALERT "NBD: panic, panic, panic\n" );
273 break;
274 }
275 if (lo != &nbd_dev[MINOR(req->rq_dev)]) {
276 printk(KERN_ALERT "NBD: request corrupted when clearing!\n");
277 continue;
278 }
279 #endif
280 req->errors++;
281 list_del(&req->queue);
282 up(&lo->queue_lock);
283
284 dequeued = nbd_end_request(req);
285
286 down(&lo->queue_lock);
287 if (!dequeued)
288 list_add(&req->queue, &lo->queue_head);
289 }
290 }
291
292 /*
293 * We always wait for result of write, for now. It would be nice to make it optional
294 * in future
295 * if ((req->cmd == WRITE) && (lo->flags & NBD_WRITE_NOCHK))
296 * { printk( "Warning: Ignoring result!\n"); nbd_end_request( req ); }
297 */
298
299 #undef FAIL
300 #define FAIL( s ) { printk( KERN_ERR "NBD, minor %d: " s "\n", dev ); goto error_out; }
301
302 static void do_nbd_request(request_queue_t * q)
303 {
304 struct request *req;
305 int dev = 0;
306 struct nbd_device *lo;
307
308 while (!QUEUE_EMPTY) {
309 req = CURRENT;
310 #ifdef PARANOIA
311 if (!req)
312 FAIL("que not empty but no request?");
313 #endif
314 dev = MINOR(req->rq_dev);
315 #ifdef PARANOIA
316 if (dev >= MAX_NBD)
317 FAIL("Minor too big."); /* Probably can not happen */
318 #endif
319 lo = &nbd_dev[dev];
320 if (!lo->file)
321 FAIL("Request when not-ready.");
322 if ((req->cmd == WRITE) && (lo->flags & NBD_READ_ONLY))
323 FAIL("Write on read-only");
324 #ifdef PARANOIA
325 if (lo->magic != LO_MAGIC)
326 FAIL("nbd[] is not magical!");
327 requests_in++;
328 #endif
329 req->errors = 0;
330 blkdev_dequeue_request(req);
331 spin_unlock_irq(&io_request_lock);
332
333 down (&lo->queue_lock);
334 list_add(&req->queue, &lo->queue_head);
335 nbd_send_req(lo->sock, req); /* Why does this block? */
336 up (&lo->queue_lock);
337
338 spin_lock_irq(&io_request_lock);
339 continue;
340
341 error_out:
342 req->errors++;
343 blkdev_dequeue_request(req);
344 spin_unlock(&io_request_lock);
345 nbd_end_request(req);
346 spin_lock(&io_request_lock);
347 }
348 return;
349 }
350
351 static int nbd_ioctl(struct inode *inode, struct file *file,
352 unsigned int cmd, unsigned long arg)
353 {
354 struct nbd_device *lo;
355 int dev, error, temp;
356 struct request sreq ;
357
358 /* Anyone capable of this syscall can do *real bad* things */
359
360 if (!capable(CAP_SYS_ADMIN))
361 return -EPERM;
362 if (!inode)
363 return -EINVAL;
364 dev = MINOR(inode->i_rdev);
365 if (dev >= MAX_NBD)
366 return -ENODEV;
367
368 lo = &nbd_dev[dev];
369 switch (cmd) {
370 case NBD_DISCONNECT:
371 printk("NBD_DISCONNECT\n") ;
372 sreq.cmd=2 ; /* shutdown command */
373 if (!lo->sock) return -EINVAL ;
374 nbd_send_req(lo->sock,&sreq) ;
375 return 0 ;
376
377 case NBD_CLEAR_SOCK:
378 down(&lo->queue_lock);
379 nbd_clear_que(lo);
380 if (!list_empty(&lo->queue_head)) {
381 up(&lo->queue_lock);
382 printk(KERN_ERR "nbd: Some requests are in progress -> can not turn off.\n");
383 return -EBUSY;
384 }
385 up(&lo->queue_lock);
386 file = lo->file;
387 if (!file)
388 return -EINVAL;
389 lo->file = NULL;
390 lo->sock = NULL;
391 fput(file);
392 return 0;
393 case NBD_SET_SOCK:
394 if (lo->file)
395 return -EBUSY;
396 error = -EINVAL;
397 file = fget(arg);
398 if (file) {
399 inode = file->f_dentry->d_inode;
400 /* N.B. Should verify that it's a socket */
401 lo->file = file;
402 lo->sock = &inode->u.socket_i;
403 error = 0;
404 }
405 return error;
406 case NBD_SET_BLKSIZE:
407 if ((arg & (arg-1)) || (arg < 512) || (arg > PAGE_SIZE))
408 return -EINVAL;
409 nbd_blksizes[dev] = arg;
410 temp = arg >> 9;
411 nbd_blksize_bits[dev] = 9;
412 while (temp > 1) {
413 nbd_blksize_bits[dev]++;
414 temp >>= 1;
415 }
416 nbd_sizes[dev] = nbd_bytesizes[dev] >> nbd_blksize_bits[dev];
417 nbd_bytesizes[dev] = nbd_sizes[dev] << nbd_blksize_bits[dev];
418 return 0;
419 case NBD_SET_SIZE:
420 nbd_sizes[dev] = arg >> nbd_blksize_bits[dev];
421 nbd_bytesizes[dev] = nbd_sizes[dev] << nbd_blksize_bits[dev];
422 return 0;
423 case NBD_SET_SIZE_BLOCKS:
424 nbd_sizes[dev] = arg;
425 nbd_bytesizes[dev] = ((u64) arg) << nbd_blksize_bits[dev];
426 return 0;
427 case NBD_DO_IT:
428 if (!lo->file)
429 return -EINVAL;
430 nbd_do_it(lo);
431 return lo->harderror;
432 case NBD_CLEAR_QUE:
433 nbd_clear_que(lo);
434 return 0;
435 #ifdef PARANOIA
436 case NBD_PRINT_DEBUG:
437 printk(KERN_INFO "NBD device %d: next = %p, prev = %p. Global: in %d, out %d\n",
438 dev, lo->queue_head.next, lo->queue_head.prev, requests_in, requests_out);
439 return 0;
440 #endif
441 case BLKGETSIZE:
442 return put_user(nbd_bytesizes[dev] >> 9, (long *) arg);
443 }
444 return -EINVAL;
445 }
446
447 static int nbd_release(struct inode *inode, struct file *file)
448 {
449 struct nbd_device *lo;
450 int dev;
451
452 if (!inode)
453 return -ENODEV;
454 dev = MINOR(inode->i_rdev);
455 if (dev >= MAX_NBD)
456 return -ENODEV;
457 lo = &nbd_dev[dev];
458 if (lo->refcnt <= 0)
459 printk(KERN_ALERT "nbd_release: refcount(%d) <= 0\n", lo->refcnt);
460 lo->refcnt--;
461 /* N.B. Doesn't lo->file need an fput?? */
462 MOD_DEC_USE_COUNT;
463 return 0;
464 }
465
466 static struct block_device_operations nbd_fops =
467 {
468 open: nbd_open,
469 release: nbd_release,
470 ioctl: nbd_ioctl,
471 };
472
473 /*
474 * And here should be modules and kernel interface
475 * (Just smiley confuses emacs :-)
476 */
477
478 #ifdef MODULE
479 #define nbd_init init_module
480 #endif
481
482 int nbd_init(void)
483 {
484 int i;
485
486 if (sizeof(struct nbd_request) != 28) {
487 printk(KERN_CRIT "Sizeof nbd_request needs to be 28 in order to work!\n" );
488 return -EIO;
489 }
490
491 if (register_blkdev(MAJOR_NR, "nbd", &nbd_fops)) {
492 printk("Unable to get major number %d for NBD\n",
493 MAJOR_NR);
494 return -EIO;
495 }
496 #ifdef MODULE
497 printk("nbd: registered device at major %d\n", MAJOR_NR);
498 #endif
499 blksize_size[MAJOR_NR] = nbd_blksizes;
500 blk_size[MAJOR_NR] = nbd_sizes;
501 blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_nbd_request);
502 #ifndef NBD_PLUGGABLE
503 blk_queue_pluggable(BLK_DEFAULT_QUEUE(MAJOR_NR), nbd_plug_device);
504 #endif
505 blk_queue_headactive(BLK_DEFAULT_QUEUE(MAJOR_NR), 0);
506 for (i = 0; i < MAX_NBD; i++) {
507 nbd_dev[i].refcnt = 0;
508 nbd_dev[i].file = NULL;
509 nbd_dev[i].magic = LO_MAGIC;
510 nbd_dev[i].flags = 0;
511 INIT_LIST_HEAD(&nbd_dev[i].queue_head);
512 init_MUTEX(&nbd_dev[i].queue_lock);
513 nbd_blksizes[i] = 1024;
514 nbd_blksize_bits[i] = 10;
515 nbd_bytesizes[i] = 0x7ffffc00; /* 2GB */
516 nbd_sizes[i] = nbd_bytesizes[i] >> nbd_blksize_bits[i];
517 register_disk(NULL, MKDEV(MAJOR_NR,i), 1, &nbd_fops,
518 nbd_bytesizes[i]>>9);
519 }
520 devfs_handle = devfs_mk_dir (NULL, "nbd", NULL);
521 devfs_register_series (devfs_handle, "%u", MAX_NBD,
522 DEVFS_FL_DEFAULT, MAJOR_NR, 0,
523 S_IFBLK | S_IRUSR | S_IWUSR,
524 &nbd_fops, NULL);
525
526 return 0;
527 }
528
529 #ifdef MODULE
530 void cleanup_module(void)
531 {
532 devfs_unregister (devfs_handle);
533 blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
534
535 if (unregister_blkdev(MAJOR_NR, "nbd") != 0)
536 printk("nbd: cleanup_module failed\n");
537 else
538 printk("nbd: module cleaned up.\n");
539 }
540 #endif
541
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.