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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
nbd.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：13k
源码类别：

嵌入式Linux

开发平台：

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.  *
  28.  * possible FIXME: make set_sock / set_blksize / set_size / do_it one syscall
  29.  * why not: would need verify_area and friends, would share yet another 
  30.  *          structure with userland
  31.  */
  33. #define PARANOIA
  34. #include <linux/major.h>
  36. #include <linux/module.h>
  37. #include <linux/init.h>
  38. #include <linux/sched.h>
  39. #include <linux/fs.h>
  40. #include <linux/stat.h>
  41. #include <linux/errno.h>
  42. #include <linux/file.h>
  43. #include <linux/ioctl.h>
  44. #include <net/sock.h>
  46. #include <linux/devfs_fs_kernel.h>
  48. #include <asm/uaccess.h>
  49. #include <asm/types.h>
  51. #define MAJOR_NR NBD_MAJOR
  52. #include <linux/nbd.h>
  54. #define LO_MAGIC 0x68797548
  56. static int nbd_blksizes[MAX_NBD];
  57. static int nbd_blksize_bits[MAX_NBD];
  58. static int nbd_sizes[MAX_NBD];
  59. static u64 nbd_bytesizes[MAX_NBD];
  61. static struct nbd_device nbd_dev[MAX_NBD];
  62. static devfs_handle_t devfs_handle;
  64. #define DEBUG( s )
  65. /* #define DEBUG( s ) printk( s ) 
  66.  */
  68. #ifdef PARANOIA
  69. static int requests_in;
  70. static int requests_out;
  71. #endif
  73. static int nbd_open(struct inode *inode, struct file *file)
  74. {
  75. int dev;
  77. if (!inode)
  78. return -EINVAL;
  79. dev = MINOR(inode->i_rdev);
  80. if (dev >= MAX_NBD)
  81. return -ENODEV;
  83. nbd_dev[dev].refcnt++;
  84. return 0;
  85. }
  87. /*
  88.  *  Send or receive packet.
  89.  */
  90. static int nbd_xmit(int send, struct socket *sock, char *buf, int size, int msg_flags)
  91. {
  92. mm_segment_t oldfs;
  93. int result;
  94. struct msghdr msg;
  95. struct iovec iov;
  96. unsigned long flags;
  97. sigset_t oldset;
  99. oldfs = get_fs();
  100. set_fs(get_ds());
  102. spin_lock_irqsave(&current->sigmask_lock, flags);
  103. oldset = current->blocked;
  104. sigfillset(&current->blocked);
  105. recalc_sigpending(current);
  106. spin_unlock_irqrestore(&current->sigmask_lock, flags);
  109. do {
  110. sock->sk->allocation = GFP_NOIO;
  111. iov.iov_base = buf;
  112. iov.iov_len = size;
  113. msg.msg_name = NULL;
  114. msg.msg_namelen = 0;
  115. msg.msg_iov = &iov;
  116. msg.msg_iovlen = 1;
  117. msg.msg_control = NULL;
  118. msg.msg_controllen = 0;
  119. msg.msg_namelen = 0;
  120. msg.msg_flags = msg_flags | MSG_NOSIGNAL;
  122. if (send)
  123. result = sock_sendmsg(sock, &msg, size);
  124. else
  125. result = sock_recvmsg(sock, &msg, size, 0);
  127. if (result <= 0) {
  128. #ifdef PARANOIA
  129. printk(KERN_ERR "NBD: %s - sock=%ld at buf=%ld, size=%d returned %d.n",
  130.        send ? "send" : "receive", (long) sock, (long) buf, size, result);
  131. #endif
  132. break;
  133. }
  134. size -= result;
  135. buf += result;
  136. } while (size > 0);
  138. spin_lock_irqsave(&current->sigmask_lock, flags);
  139. current->blocked = oldset;
  140. recalc_sigpending(current);
  141. spin_unlock_irqrestore(&current->sigmask_lock, flags);
  143. set_fs(oldfs);
  144. return result;
  145. }
  147. #define FAIL( s ) { printk( KERN_ERR "NBD: " s "(result %d)n", result ); goto error_out; }
  149. void nbd_send_req(struct socket *sock, struct request *req)
  150. {
  151. int result;
  152. struct nbd_request request;
  153. unsigned long size = req->nr_sectors << 9;
  155. DEBUG("NBD: sending control, ");
  156. request.magic = htonl(NBD_REQUEST_MAGIC);
  157. request.type = htonl(req->cmd);
  158. request.from = cpu_to_be64( (u64) req->sector << 9);
  159. request.len = htonl(size);
  160. memcpy(request.handle, &req, sizeof(req));
  162. result = nbd_xmit(1, sock, (char *) &request, sizeof(request), req->cmd == WRITE ? MSG_MORE : 0);
  163. if (result <= 0)
  164. FAIL("Sendmsg failed for control.");
  166. if (req->cmd == WRITE) {
  167. struct buffer_head *bh = req->bh;
  168. DEBUG("data, ");
  169. do {
  170. result = nbd_xmit(1, sock, bh->b_data, bh->b_size, bh->b_reqnext == NULL ? 0 : MSG_MORE);
  171. if (result <= 0)
  172. FAIL("Send data failed.");
  173. bh = bh->b_reqnext;
  174. } while(bh);
  175. }
  176. return;
  178.       error_out:
  179. req->errors++;
  180. }
  182. #define HARDFAIL( s ) { printk( KERN_ERR "NBD: " s "(result %d)n", result ); lo->harderror = result; return NULL; }
  183. struct request *nbd_read_stat(struct nbd_device *lo)
  184. /* NULL returned = something went wrong, inform userspace       */ 
  185. {
  186. int result;
  187. struct nbd_reply reply;
  188. struct request *xreq, *req;
  190. DEBUG("reading control, ");
  191. reply.magic = 0;
  192. result = nbd_xmit(0, lo->sock, (char *) &reply, sizeof(reply), MSG_WAITALL);
  193. if (result <= 0)
  194. HARDFAIL("Recv control failed.");
  195. memcpy(&xreq, reply.handle, sizeof(xreq));
  196. req = blkdev_entry_prev_request(&lo->queue_head);
  198. if (xreq != req)
  199. FAIL("Unexpected handle received.n");
  201. DEBUG("ok, ");
  202. if (ntohl(reply.magic) != NBD_REPLY_MAGIC)
  203. HARDFAIL("Not enough magic.");
  204. if (ntohl(reply.error))
  205. FAIL("Other side returned error.");
  206. if (req->cmd == READ) {
  207. struct buffer_head *bh = req->bh;
  208. DEBUG("data, ");
  209. do {
  210. result = nbd_xmit(0, lo->sock, bh->b_data, bh->b_size, MSG_WAITALL);
  211. if (result <= 0)
  212. HARDFAIL("Recv data failed.");
  213. bh = bh->b_reqnext;
  214. } while(bh);
  215. }
  216. DEBUG("done.n");
  217. return req;
  219. /* Can we get here? Yes, if other side returns error */
  220.       error_out:
  221. req->errors++;
  222. return req;
  223. }
  225. void nbd_do_it(struct nbd_device *lo)
  226. {
  227. struct request *req;
  229. down (&lo->queue_lock);
  230. while (1) {
  231. up (&lo->queue_lock);
  232. req = nbd_read_stat(lo);
  233. down (&lo->queue_lock);
  235. if (!req) {
  236. printk(KERN_ALERT "req should never be nulln" );
  237. goto out;
  238. }
  239. #ifdef PARANOIA
  240. if (req != blkdev_entry_prev_request(&lo->queue_head)) {
  241. printk(KERN_ALERT "NBD: I have problem...n");
  242. }
  243. if (lo != &nbd_dev[MINOR(req->rq_dev)]) {
  244. printk(KERN_ALERT "NBD: request corrupted!n");
  245. continue;
  246. }
  247. if (lo->magic != LO_MAGIC) {
  248. printk(KERN_ALERT "NBD: nbd_dev[] corrupted: Not enough magicn");
  249. goto out;
  250. }
  251. #endif
  252. list_del(&req->queue);
  253. up (&lo->queue_lock);
  255. nbd_end_request(req);
  257. down (&lo->queue_lock);
  258. }
  259.  out:
  260. up (&lo->queue_lock);
  261. }
  263. void nbd_clear_que(struct nbd_device *lo)
  264. {
  265. struct request *req;
  267. #ifdef PARANOIA
  268. if (lo->magic != LO_MAGIC) {
  269. printk(KERN_ERR "NBD: nbd_dev[] corrupted: Not enough magic when clearing!n");
  270. return;
  271. }
  272. #endif
  274. while (!list_empty(&lo->queue_head)) {
  275. req = blkdev_entry_prev_request(&lo->queue_head);
  276. #ifdef PARANOIA
  277. if (!req) {
  278. printk( KERN_ALERT "NBD: panic, panic, panicn" );
  279. break;
  280. }
  281. if (lo != &nbd_dev[MINOR(req->rq_dev)]) {
  282. printk(KERN_ALERT "NBD: request corrupted when clearing!n");
  283. continue;
  284. }
  285. #endif
  286. req->errors++;
  287. list_del(&req->queue);
  288. up(&lo->queue_lock);
  290. nbd_end_request(req);
  292. down(&lo->queue_lock);
  293. }
  294. }
  296. /*
  297.  * We always wait for result of write, for now. It would be nice to make it optional
  298.  * in future
  299.  * if ((req->cmd == WRITE) && (lo->flags & NBD_WRITE_NOCHK)) 
  300.  *   { printk( "Warning: Ignoring result!n"); nbd_end_request( req ); }
  301.  */
  303. #undef FAIL
  304. #define FAIL( s ) { printk( KERN_ERR "NBD, minor %d: " s "n", dev ); goto error_out; }
  306. static void do_nbd_request(request_queue_t * q)
  307. {
  308. struct request *req;
  309. int dev = 0;
  310. struct nbd_device *lo;
  312. while (!QUEUE_EMPTY) {
  313. req = CURRENT;
  314. #ifdef PARANOIA
  315. if (!req)
  316. FAIL("que not empty but no request?");
  317. #endif
  318. dev = MINOR(req->rq_dev);
  319. #ifdef PARANOIA
  320. if (dev >= MAX_NBD)
  321. FAIL("Minor too big."); /* Probably can not happen */
  322. #endif
  323. lo = &nbd_dev[dev];
  324. if (!lo->file)
  325. FAIL("Request when not-ready.");
  326. if ((req->cmd == WRITE) && (lo->flags & NBD_READ_ONLY))
  327. FAIL("Write on read-only");
  328. #ifdef PARANOIA
  329. if (lo->magic != LO_MAGIC)
  330. FAIL("nbd[] is not magical!");
  331. requests_in++;
  332. #endif
  333. req->errors = 0;
  334. blkdev_dequeue_request(req);
  335. spin_unlock_irq(&io_request_lock);
  337. down (&lo->queue_lock);
  338. list_add(&req->queue, &lo->queue_head);
  339. nbd_send_req(lo->sock, req); /* Why does this block?         */
  340. up (&lo->queue_lock);
  342. spin_lock_irq(&io_request_lock);
  343. continue;
  345.       error_out:
  346. req->errors++;
  347. blkdev_dequeue_request(req);
  348. spin_unlock(&io_request_lock);
  349. nbd_end_request(req);
  350. spin_lock(&io_request_lock);
  351. }
  352. return;
  353. }
  355. static int nbd_ioctl(struct inode *inode, struct file *file,
  356.      unsigned int cmd, unsigned long arg)
  357. {
  358. struct nbd_device *lo;
  359. int dev, error, temp;
  360. struct request sreq ;
  362. /* Anyone capable of this syscall can do *real bad* things */
  364. if (!capable(CAP_SYS_ADMIN))
  365. return -EPERM;
  366. if (!inode)
  367. return -EINVAL;
  368. dev = MINOR(inode->i_rdev);
  369. if (dev >= MAX_NBD)
  370. return -ENODEV;
  372. lo = &nbd_dev[dev];
  373. switch (cmd) {
  374. case NBD_DISCONNECT:
  375.         printk("NBD_DISCONNECTn") ;
  376.                 sreq.cmd=2 ; /* shutdown command */
  377.                 if (!lo->sock) return -EINVAL ;
  378.                 nbd_send_req(lo->sock,&sreq) ;
  379.                 return 0 ;
  380.  
  381. case NBD_CLEAR_SOCK:
  382. down(&lo->queue_lock);
  383. nbd_clear_que(lo);
  384. if (!list_empty(&lo->queue_head)) {
  385. up(&lo->queue_lock);
  386. printk(KERN_ERR "nbd: Some requests are in progress -> can not turn off.n");
  387. return -EBUSY;
  388. }
  389. up(&lo->queue_lock);
  390. file = lo->file;
  391. if (!file)
  392. return -EINVAL;
  393. lo->file = NULL;
  394. lo->sock = NULL;
  395. fput(file);
  396. return 0;
  397. case NBD_SET_SOCK:
  398. if (lo->file)
  399. return -EBUSY;
  400. error = -EINVAL;
  401. file = fget(arg);
  402. if (file) {
  403. inode = file->f_dentry->d_inode;
  404. /* N.B. Should verify that it's a socket */
  405. lo->file = file;
  406. lo->sock = &inode->u.socket_i;
  407. error = 0;
  408. }
  409. return error;
  410. case NBD_SET_BLKSIZE:
  411. if ((arg & (arg-1)) || (arg < 512) || (arg > PAGE_SIZE))
  412. return -EINVAL;
  413. nbd_blksizes[dev] = arg;
  414. temp = arg >> 9;
  415. nbd_blksize_bits[dev] = 9;
  416. while (temp > 1) {
  417. nbd_blksize_bits[dev]++;
  418. temp >>= 1;
  419. }
  420. nbd_bytesizes[dev] &= ~(nbd_blksizes[dev]-1); 
  421. nbd_sizes[dev] = nbd_bytesizes[dev] >> BLOCK_SIZE_BITS;
  422. return 0;
  423. case NBD_SET_SIZE:
  424. nbd_bytesizes[dev] = arg & ~(nbd_blksizes[dev]-1); 
  425. nbd_sizes[dev] = nbd_bytesizes[dev] >> BLOCK_SIZE_BITS;
  426. return 0;
  427. case NBD_SET_SIZE_BLOCKS:
  428. nbd_bytesizes[dev] = ((u64) arg) << nbd_blksize_bits[dev]; 
  429. nbd_sizes[dev] = nbd_bytesizes[dev] >> BLOCK_SIZE_BITS;
  430. return 0;
  431. case NBD_DO_IT:
  432. if (!lo->file)
  433. return -EINVAL;
  434. nbd_do_it(lo);
  435. return lo->harderror;
  436. case NBD_CLEAR_QUE:
  437. nbd_clear_que(lo);
  438. return 0;
  439. #ifdef PARANOIA
  440. case NBD_PRINT_DEBUG:
  441. printk(KERN_INFO "NBD device %d: next = %p, prev = %p. Global: in %d, out %dn",
  442.        dev, lo->queue_head.next, lo->queue_head.prev, requests_in, requests_out);
  443. return 0;
  444. #endif
  445. case BLKGETSIZE:
  446. return put_user(nbd_bytesizes[dev] >> 9, (unsigned long *) arg);
  447. case BLKGETSIZE64:
  448. return put_user((u64)nbd_bytesizes[dev], (u64 *) arg);
  449. }
  450. return -EINVAL;
  451. }
  453. static int nbd_release(struct inode *inode, struct file *file)
  454. {
  455. struct nbd_device *lo;
  456. int dev;
  458. if (!inode)
  459. return -ENODEV;
  460. dev = MINOR(inode->i_rdev);
  461. if (dev >= MAX_NBD)
  462. return -ENODEV;
  463. lo = &nbd_dev[dev];
  464. if (lo->refcnt <= 0)
  465. printk(KERN_ALERT "nbd_release: refcount(%d) <= 0n", lo->refcnt);
  466. lo->refcnt--;
  467. /* N.B. Doesn't lo->file need an fput?? */
  468. return 0;
  469. }
  471. static struct block_device_operations nbd_fops =
  472. {
  473. owner: THIS_MODULE,
  474. open: nbd_open,
  475. release: nbd_release,
  476. ioctl: nbd_ioctl,
  477. };
  479. /*
  480.  * And here should be modules and kernel interface 
  481.  *  (Just smiley confuses emacs :-)
  482.  */
  484. static int __init nbd_init(void)
  485. {
  486. int i;
  488. if (sizeof(struct nbd_request) != 28) {
  489. printk(KERN_CRIT "Sizeof nbd_request needs to be 28 in order to work!n" );
  490. return -EIO;
  491. }
  493. if (register_blkdev(MAJOR_NR, "nbd", &nbd_fops)) {
  494. printk("Unable to get major number %d for NBDn",
  495.        MAJOR_NR);
  496. return -EIO;
  497. }
  498. #ifdef MODULE
  499. printk("nbd: registered device at major %dn", MAJOR_NR);
  500. #endif
  501. blksize_size[MAJOR_NR] = nbd_blksizes;
  502. blk_size[MAJOR_NR] = nbd_sizes;
  503. blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_nbd_request);
  504. blk_queue_headactive(BLK_DEFAULT_QUEUE(MAJOR_NR), 0);
  505. for (i = 0; i < MAX_NBD; i++) {
  506. nbd_dev[i].refcnt = 0;
  507. nbd_dev[i].file = NULL;
  508. nbd_dev[i].magic = LO_MAGIC;
  509. nbd_dev[i].flags = 0;
  510. INIT_LIST_HEAD(&nbd_dev[i].queue_head);
  511. init_MUTEX(&nbd_dev[i].queue_lock);
  512. nbd_blksizes[i] = 1024;
  513. nbd_blksize_bits[i] = 10;
  514. nbd_bytesizes[i] = 0x7ffffc00; /* 2GB */
  515. nbd_sizes[i] = nbd_bytesizes[i] >> BLOCK_SIZE_BITS;
  516. register_disk(NULL, MKDEV(MAJOR_NR,i), 1, &nbd_fops,
  517. nbd_bytesizes[i]>>9);
  518. }
  519. devfs_handle = devfs_mk_dir (NULL, "nbd", NULL);
  520. devfs_register_series (devfs_handle, "%u", MAX_NBD,
  521.        DEVFS_FL_DEFAULT, MAJOR_NR, 0,
  522.        S_IFBLK | S_IRUSR | S_IWUSR,
  523.        &nbd_fops, NULL);
  525. return 0;
  526. }
  528. static void __exit nbd_cleanup(void)
  529. {
  530. devfs_unregister (devfs_handle);
  531. blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
  533. if (unregister_blkdev(MAJOR_NR, "nbd") != 0)
  534. printk("nbd: cleanup_module failedn");
  535. else
  536. printk("nbd: module cleaned up.n");
  537. }
  539. module_init(nbd_init);
  540. module_exit(nbd_cleanup);
  542. MODULE_DESCRIPTION("Network Block Device");
  543. MODULE_LICENSE("GPL");