开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
nbd.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：13k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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