1 /* 2 * linux/drivers/block/loop.c 3 * 4 * Written by Theodore Ts'o, 3/29/93 5 * 6 * Copyright 1993 by Theodore Ts'o. Redistribution of this file is 7 * permitted under the GNU General Public License. 8 * 9 * DES encryption plus some minor changes by Werner Almesberger, 30-MAY-1993 10 * more DES encryption plus IDEA encryption by Nicholas J. Leon, June 20, 1996 11 * 12 * Modularized and updated for 1.1.16 kernel - Mitch Dsouza 28th May 1994 13 * Adapted for 1.3.59 kernel - Andries Brouwer, 1 Feb 1996 14 * 15 * Fixed do_loop_request() re-entrancy - Vincent.Renardias@waw.com Mar 20, 1997 16 * 17 * Added devfs support - Richard Gooch <rgooch@atnf.csiro.au> 16-Jan-1998 18 * 19 * Handle sparse backing files correctly - Kenn Humborg, Jun 28, 1998 20 * 21 * Loadable modules and other fixes by AK, 1998 22 * 23 * Make real block number available to downstream transfer functions, enables 24 * CBC (and relatives) mode encryption requiring unique IVs per data block. 25 * Reed H. Petty, rhp@draper.net 26 * 27 * Maximum number of loop devices now dynamic via max_loop module parameter. 28 * Russell Kroll <rkroll@exploits.org> 19990701 29 * 30 * Maximum number of loop devices when compiled-in now selectable by passing 31 * max_loop=<1-255> to the kernel on boot. 32 * Erik I. Bols�, <eriki@himolde.no>, Oct 31, 1999 33 * 34 * Completely rewrite request handling to be make_request_fn style and 35 * non blocking, pushing work to a helper thread. Lots of fixes from 36 * Al Viro too. 37 * Jens Axboe <axboe@suse.de>, Nov 2000 38 * 39 * Support up to 256 loop devices 40 * Heinz Mauelshagen <mge@sistina.com>, Feb 2002 41 * 42 * Support for falling back on the write file operation when the address space 43 * operations prepare_write and/or commit_write are not available on the 44 * backing filesystem. 45 * Anton Altaparmakov, 16 Feb 2005 46 * 47 * Still To Fix: 48 * - Advisory locking is ignored here. 49 * - Should use an own CAP_* category instead of CAP_SYS_ADMIN 50 * 51 */ 52 53 #include <linux/module.h> 54 #include <linux/moduleparam.h> 55 #include <linux/sched.h> 56 #include <linux/fs.h> 57 #include <linux/file.h> 58 #include <linux/stat.h> 59 #include <linux/errno.h> 60 #include <linux/major.h> 61 #include <linux/wait.h> 62 #include <linux/blkdev.h> 63 #include <linux/blkpg.h> 64 #include <linux/init.h> 65 #include <linux/smp_lock.h> 66 #include <linux/swap.h> 67 #include <linux/slab.h> 68 #include <linux/loop.h> 69 #include <linux/compat.h> 70 #include <linux/suspend.h> 71 #include <linux/writeback.h> 72 #include <linux/buffer_head.h> /* for invalidate_bdev() */ 73 #include <linux/completion.h> 74 #include <linux/highmem.h> 75 #include <linux/gfp.h> 76 #include <linux/kthread.h> 77 78 #include <asm/uaccess.h> 79 80 static LIST_HEAD(loop_devices); 81 static DEFINE_MUTEX(loop_devices_mutex); 82 83 /* 84 * Transfer functions 85 */ 86 static int transfer_none(struct loop_device *lo, int cmd, 87 struct page *raw_page, unsigned raw_off, 88 struct page *loop_page, unsigned loop_off, 89 int size, sector_t real_block) 90 { 91 char *raw_buf = kmap_atomic(raw_page, KM_USER0) + raw_off; 92 char *loop_buf = kmap_atomic(loop_page, KM_USER1) + loop_off; 93 94 if (cmd == READ) 95 memcpy(loop_buf, raw_buf, size); 96 else 97 memcpy(raw_buf, loop_buf, size); 98 99 kunmap_atomic(raw_buf, KM_USER0); 100 kunmap_atomic(loop_buf, KM_USER1); 101 cond_resched(); 102 return 0; 103 } 104 105 static int transfer_xor(struct loop_device *lo, int cmd, 106 struct page *raw_page, unsigned raw_off, 107 struct page *loop_page, unsigned loop_off, 108 int size, sector_t real_block) 109 { 110 char *raw_buf = kmap_atomic(raw_page, KM_USER0) + raw_off; 111 char *loop_buf = kmap_atomic(loop_page, KM_USER1) + loop_off; 112 char *in, *out, *key; 113 int i, keysize; 114 115 if (cmd == READ) { 116 in = raw_buf; 117 out = loop_buf; 118 } else { 119 in = loop_buf; 120 out = raw_buf; 121 } 122 123 key = lo->lo_encrypt_key; 124 keysize = lo->lo_encrypt_key_size; 125 for (i = 0; i < size; i++) 126 *out++ = *in++ ^ key[(i & 511) % keysize]; 127 128 kunmap_atomic(raw_buf, KM_USER0); 129 kunmap_atomic(loop_buf, KM_USER1); 130 cond_resched(); 131 return 0; 132 } 133 134 static int xor_init(struct loop_device *lo, const struct loop_info64 *info) 135 { 136 if (unlikely(info->lo_encrypt_key_size <= 0)) 137 return -EINVAL; 138 return 0; 139 } 140 141 static struct loop_func_table none_funcs = { 142 .number = LO_CRYPT_NONE, 143 .transfer = transfer_none, 144 }; 145 146 static struct loop_func_table xor_funcs = { 147 .number = LO_CRYPT_XOR, 148 .transfer = transfer_xor, 149 .init = xor_init 150 }; 151 152 /* xfer_funcs[0] is special - its release function is never called */ 153 static struct loop_func_table *xfer_funcs[MAX_LO_CRYPT] = { 154 &none_funcs, 155 &xor_funcs 156 }; 157 158 static loff_t get_loop_size(struct loop_device *lo, struct file *file) 159 { 160 loff_t size, offset, loopsize; 161 162 /* Compute loopsize in bytes */ 163 size = i_size_read(file->f_mapping->host); 164 offset = lo->lo_offset; 165 loopsize = size - offset; 166 if (lo->lo_sizelimit > 0 && lo->lo_sizelimit < loopsize) 167 loopsize = lo->lo_sizelimit; 168 169 /* 170 * Unfortunately, if we want to do I/O on the device, 171 * the number of 512-byte sectors has to fit into a sector_t. 172 */ 173 return loopsize >> 9; 174 } 175 176 static int 177 figure_loop_size(struct loop_device *lo) 178 { 179 loff_t size = get_loop_size(lo, lo->lo_backing_file); 180 sector_t x = (sector_t)size; 181 182 if (unlikely((loff_t)x != size)) 183 return -EFBIG; 184 185 set_capacity(lo->lo_disk, x); 186 return 0; 187 } 188 189 static inline int 190 lo_do_transfer(struct loop_device *lo, int cmd, 191 struct page *rpage, unsigned roffs, 192 struct page *lpage, unsigned loffs, 193 int size, sector_t rblock) 194 { 195 if (unlikely(!lo->transfer)) 196 return 0; 197 198 return lo->transfer(lo, cmd, rpage, roffs, lpage, loffs, size, rblock); 199 } 200 201 /** 202 * do_lo_send_aops - helper for writing data to a loop device 203 * 204 * This is the fast version for backing filesystems which implement the address 205 * space operations prepare_write and commit_write. 206 */ 207 static int do_lo_send_aops(struct loop_device *lo, struct bio_vec *bvec, 208 int bsize, loff_t pos, struct page *page) 209 { 210 struct file *file = lo->lo_backing_file; /* kudos to NFsckingS */ 211 struct address_space *mapping = file->f_mapping; 212 const struct address_space_operations *aops = mapping->a_ops; 213 pgoff_t index; 214 unsigned offset, bv_offs; 215 int len, ret; 216 217 mutex_lock(&mapping->host->i_mutex); 218 index = pos >> PAGE_CACHE_SHIFT; 219 offset = pos & ((pgoff_t)PAGE_CACHE_SIZE - 1); 220 bv_offs = bvec->bv_offset; 221 len = bvec->bv_len; 222 while (len > 0) { 223 sector_t IV; 224 unsigned size; 225 int transfer_result; 226 227 IV = ((sector_t)index << (PAGE_CACHE_SHIFT - 9))+(offset >> 9); 228 size = PAGE_CACHE_SIZE - offset; 229 if (size > len) 230 size = len; 231 page = grab_cache_page(mapping, index); 232 if (unlikely(!page)) 233 goto fail; 234 ret = aops->prepare_write(file, page, offset, 235 offset + size); 236 if (unlikely(ret)) { 237 if (ret == AOP_TRUNCATED_PAGE) { 238 page_cache_release(page); 239 continue; 240 } 241 goto unlock; 242 } 243 transfer_result = lo_do_transfer(lo, WRITE, page, offset, 244 bvec->bv_page, bv_offs, size, IV); 245 if (unlikely(transfer_result)) { 246 /* 247 * The transfer failed, but we still write the data to 248 * keep prepare/commit calls balanced. 249 */ 250 printk(KERN_ERR "loop: transfer error block %llu\n", 251 (unsigned long long)index); 252 zero_user_page(page, offset, size, KM_USER0); 253 } 254 flush_dcache_page(page); 255 ret = aops->commit_write(file, page, offset, 256 offset + size); 257 if (unlikely(ret)) { 258 if (ret == AOP_TRUNCATED_PAGE) { 259 page_cache_release(page); 260 continue; 261 } 262 goto unlock; 263 } 264 if (unlikely(transfer_result)) 265 goto unlock; 266 bv_offs += size; 267 len -= size; 268 offset = 0; 269 index++; 270 pos += size; 271 unlock_page(page); 272 page_cache_release(page); 273 } 274 ret = 0; 275 out: 276 mutex_unlock(&mapping->host->i_mutex); 277 return ret; 278 unlock: 279 unlock_page(page); 280 page_cache_release(page); 281 fail: 282 ret = -1; 283 goto out; 284 } 285 286 /** 287 * __do_lo_send_write - helper for writing data to a loop device 288 * 289 * This helper just factors out common code between do_lo_send_direct_write() 290 * and do_lo_send_write(). 291 */ 292 static int __do_lo_send_write(struct file *file, 293 u8 *buf, const int len, loff_t pos) 294 { 295 ssize_t bw; 296 mm_segment_t old_fs = get_fs(); 297 298 set_fs(get_ds()); 299 bw = file->f_op->write(file, buf, len, &pos); 300 set_fs(old_fs); 301 if (likely(bw == len)) 302 return 0; 303 printk(KERN_ERR "loop: Write error at byte offset %llu, length %i.\n", 304 (unsigned long long)pos, len); 305 if (bw >= 0) 306 bw = -EIO; 307 return bw; 308 } 309 310 /** 311 * do_lo_send_direct_write - helper for writing data to a loop device 312 * 313 * This is the fast, non-transforming version for backing filesystems which do 314 * not implement the address space operations prepare_write and commit_write. 315 * It uses the write file operation which should be present on all writeable 316 * filesystems. 317 */ 318 static int do_lo_send_direct_write(struct loop_device *lo, 319 struct bio_vec *bvec, int bsize, loff_t pos, struct page *page) 320 { 321 ssize_t bw = __do_lo_send_write(lo->lo_backing_file, 322 kmap(bvec->bv_page) + bvec->bv_offset, 323 bvec->bv_len, pos); 324 kunmap(bvec->bv_page); 325 cond_resched(); 326 return bw; 327 } 328 329 /** 330 * do_lo_send_write - helper for writing data to a loop device 331 * 332 * This is the slow, transforming version for filesystems which do not 333 * implement the address space operations prepare_write and commit_write. It 334 * uses the write file operation which should be present on all writeable 335 * filesystems. 336 * 337 * Using fops->write is slower than using aops->{prepare,commit}_write in the 338 * transforming case because we need to double buffer the data as we cannot do 339 * the transformations in place as we do not have direct access to the 340 * destination pages of the backing file. 341 */ 342 static int do_lo_send_write(struct loop_device *lo, struct bio_vec *bvec, 343 int bsize, loff_t pos, struct page *page) 344 { 345 int ret = lo_do_transfer(lo, WRITE, page, 0, bvec->bv_page, 346 bvec->bv_offset, bvec->bv_len, pos >> 9); 347 if (likely(!ret)) 348 return __do_lo_send_write(lo->lo_backing_file, 349 page_address(page), bvec->bv_len, 350 pos); 351 printk(KERN_ERR "loop: Transfer error at byte offset %llu, " 352 "length %i.\n", (unsigned long long)pos, bvec->bv_len); 353 if (ret > 0) 354 ret = -EIO; 355 return ret; 356 } 357 358 static int lo_send(struct loop_device *lo, struct bio *bio, int bsize, 359 loff_t pos) 360 { 361 int (*do_lo_send)(struct loop_device *, struct bio_vec *, int, loff_t, 362 struct page *page); 363 struct bio_vec *bvec; 364 struct page *page = NULL; 365 int i, ret = 0; 366 367 do_lo_send = do_lo_send_aops; 368 if (!(lo->lo_flags & LO_FLAGS_USE_AOPS)) { 369 do_lo_send = do_lo_send_direct_write; 370 if (lo->transfer != transfer_none) { 371 page = alloc_page(GFP_NOIO | __GFP_HIGHMEM); 372 if (unlikely(!page)) 373 goto fail; 374 kmap(page); 375 do_lo_send = do_lo_send_write; 376 } 377 } 378 bio_for_each_segment(bvec, bio, i) { 379 ret = do_lo_send(lo, bvec, bsize, pos, page); 380 if (ret < 0) 381 break; 382 pos += bvec->bv_len; 383 } 384 if (page) { 385 kunmap(page); 386 __free_page(page); 387 } 388 out: 389 return ret; 390 fail: 391 printk(KERN_ERR "loop: Failed to allocate temporary page for write.\n"); 392 ret = -ENOMEM; 393 goto out; 394 } 395 396 struct lo_read_data { 397 struct loop_device *lo; 398 struct page *page; 399 unsigned offset; 400 int bsize; 401 }; 402 403 static int 404 lo_read_actor(read_descriptor_t *desc, struct page *page, 405 unsigned long offset, unsigned long size) 406 { 407 unsigned long count = desc->count; 408 struct lo_read_data *p = desc->arg.data; 409 struct loop_device *lo = p->lo; 410 sector_t IV; 411 412 IV = ((sector_t) page->index << (PAGE_CACHE_SHIFT - 9))+(offset >> 9); 413 414 if (size > count) 415 size = count; 416 417 if (lo_do_transfer(lo, READ, page, offset, p->page, p->offset, size, IV)) { 418 size = 0; 419 printk(KERN_ERR "loop: transfer error block %ld\n", 420 page->index); 421 desc->error = -EINVAL; 422 } 423 424 flush_dcache_page(p->page); 425 426 desc->count = count - size; 427 desc->written += size; 428 p->offset += size; 429 return size; 430 } 431 432 static int 433 do_lo_receive(struct loop_device *lo, 434 struct bio_vec *bvec, int bsize, loff_t pos) 435 { 436 struct lo_read_data cookie; 437 struct file *file; 438 int retval; 439 440 cookie.lo = lo; 441 cookie.page = bvec->bv_page; 442 cookie.offset = bvec->bv_offset; 443 cookie.bsize = bsize; 444 file = lo->lo_backing_file; 445 retval = file->f_op->sendfile(file, &pos, bvec->bv_len, 446 lo_read_actor, &cookie); 447 return (retval < 0)? retval: 0; 448 } 449 450 static int 451 lo_receive(struct loop_device *lo, struct bio *bio, int bsize, loff_t pos) 452 { 453 struct bio_vec *bvec; 454 int i, ret = 0; 455 456 bio_for_each_segment(bvec, bio, i) { 457 ret = do_lo_receive(lo, bvec, bsize, pos); 458 if (ret < 0) 459 break; 460 pos += bvec->bv_len; 461 } 462 return ret; 463 } 464 465 static int do_bio_filebacked(struct loop_device *lo, struct bio *bio) 466 { 467 loff_t pos; 468 int ret; 469 470 pos = ((loff_t) bio->bi_sector << 9) + lo->lo_offset; 471 if (bio_rw(bio) == WRITE) 472 ret = lo_send(lo, bio, lo->lo_blocksize, pos); 473 else 474 ret = lo_receive(lo, bio, lo->lo_blocksize, pos); 475 return ret; 476 } 477 478 /* 479 * Add bio to back of pending list 480 */ 481 static void loop_add_bio(struct loop_device *lo, struct bio *bio) 482 { 483 if (lo->lo_biotail) { 484 lo->lo_biotail->bi_next = bio; 485 lo->lo_biotail = bio; 486 } else 487 lo->lo_bio = lo->lo_biotail = bio; 488 } 489 490 /* 491 * Grab first pending buffer 492 */ 493 static struct bio *loop_get_bio(struct loop_device *lo) 494 { 495 struct bio *bio; 496 497 if ((bio = lo->lo_bio)) { 498 if (bio == lo->lo_biotail) 499 lo->lo_biotail = NULL; 500 lo->lo_bio = bio->bi_next; 501 bio->bi_next = NULL; 502 } 503 504 return bio; 505 } 506 507 static int loop_make_request(request_queue_t *q, struct bio *old_bio) 508 { 509 struct loop_device *lo = q->queuedata; 510 int rw = bio_rw(old_bio); 511 512 if (rw == READA) 513 rw = READ; 514 515 BUG_ON(!lo || (rw != READ && rw != WRITE)); 516 517 spin_lock_irq(&lo->lo_lock); 518 if (lo->lo_state != Lo_bound) 519 goto out; 520 if (unlikely(rw == WRITE && (lo->lo_flags & LO_FLAGS_READ_ONLY))) 521 goto out; 522 loop_add_bio(lo, old_bio); 523 wake_up(&lo->lo_event); 524 spin_unlock_irq(&lo->lo_lock); 525 return 0; 526 527 out: 528 spin_unlock_irq(&lo->lo_lock); 529 bio_io_error(old_bio, old_bio->bi_size); 530 return 0; 531 } 532 533 /* 534 * kick off io on the underlying address space 535 */ 536 static void loop_unplug(request_queue_t *q) 537 { 538 struct loop_device *lo = q->queuedata; 539 540 clear_bit(QUEUE_FLAG_PLUGGED, &q->queue_flags); 541 blk_run_address_space(lo->lo_backing_file->f_mapping); 542 } 543 544 struct switch_request { 545 struct file *file; 546 struct completion wait; 547 }; 548 549 static void do_loop_switch(struct loop_device *, struct switch_request *); 550 551 static inline void loop_handle_bio(struct loop_device *lo, struct bio *bio) 552 { 553 if (unlikely(!bio->bi_bdev)) { 554 do_loop_switch(lo, bio->bi_private); 555 bio_put(bio); 556 } else { 557 int ret = do_bio_filebacked(lo, bio); 558 bio_endio(bio, bio->bi_size, ret); 559 } 560 } 561 562 /* 563 * worker thread that handles reads/writes to file backed loop devices, 564 * to avoid blocking in our make_request_fn. it also does loop decrypting 565 * on reads for block backed loop, as that is too heavy to do from 566 * b_end_io context where irqs may be disabled. 567 * 568 * Loop explanation: loop_clr_fd() sets lo_state to Lo_rundown before 569 * calling kthread_stop(). Therefore once kthread_should_stop() is 570 * true, make_request will not place any more requests. Therefore 571 * once kthread_should_stop() is true and lo_bio is NULL, we are 572 * done with the loop. 573 */ 574 static int loop_thread(void *data) 575 { 576 struct loop_device *lo = data; 577 struct bio *bio; 578 579 /* 580 * loop can be used in an encrypted device, 581 * hence, it mustn't be stopped at all 582 * because it could be indirectly used during suspension 583 */ 584 current->flags |= PF_NOFREEZE; 585 586 set_user_nice(current, -20); 587 588 while (!kthread_should_stop() || lo->lo_bio) { 589 590 wait_event_interruptible(lo->lo_event, 591 lo->lo_bio || kthread_should_stop()); 592 593 if (!lo->lo_bio) 594 continue; 595 spin_lock_irq(&lo->lo_lock); 596 bio = loop_get_bio(lo); 597 spin_unlock_irq(&lo->lo_lock); 598 599 BUG_ON(!bio); 600 loop_handle_bio(lo, bio); 601 } 602 603 return 0; 604 } 605 606 /* 607 * loop_switch performs the hard work of switching a backing store. 608 * First it needs to flush existing IO, it does this by sending a magic 609 * BIO down the pipe. The completion of this BIO does the actual switch. 610 */ 611 static int loop_switch(struct loop_device *lo, struct file *file) 612 { 613 struct switch_request w; 614 struct bio *bio = bio_alloc(GFP_KERNEL, 1); 615 if (!bio) 616 return -ENOMEM; 617 init_completion(&w.wait); 618 w.file = file; 619 bio->bi_private = &w; 620 bio->bi_bdev = NULL; 621 loop_make_request(lo->lo_queue, bio); 622 wait_for_completion(&w.wait); 623 return 0; 624 } 625 626 /* 627 * Do the actual switch; called from the BIO completion routine 628 */ 629 static void do_loop_switch(struct loop_device *lo, struct switch_request *p) 630 { 631 struct file *file = p->file; 632 struct file *old_file = lo->lo_backing_file; 633 struct address_space *mapping = file->f_mapping; 634 635 mapping_set_gfp_mask(old_file->f_mapping, lo->old_gfp_mask); 636 lo->lo_backing_file = file; 637 lo->lo_blocksize = S_ISBLK(mapping->host->i_mode) ? 638 mapping->host->i_bdev->bd_block_size : PAGE_SIZE; 639 lo->old_gfp_mask = mapping_gfp_mask(mapping); 640 mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS)); 641 complete(&p->wait); 642 } 643 644 645 /* 646 * loop_change_fd switched the backing store of a loopback device to 647 * a new file. This is useful for operating system installers to free up 648 * the original file and in High Availability environments to switch to 649 * an alternative location for the content in case of server meltdown. 650 * This can only work if the loop device is used read-only, and if the 651 * new backing store is the same size and type as the old backing store. 652 */ 653 static int loop_change_fd(struct loop_device *lo, struct file *lo_file, 654 struct block_device *bdev, unsigned int arg) 655 { 656 struct file *file, *old_file; 657 struct inode *inode; 658 int error; 659 660 error = -ENXIO; 661 if (lo->lo_state != Lo_bound) 662 goto out; 663 664 /* the loop device has to be read-only */ 665 error = -EINVAL; 666 if (!(lo->lo_flags & LO_FLAGS_READ_ONLY)) 667 goto out; 668 669 error = -EBADF; 670 file = fget(arg); 671 if (!file) 672 goto out; 673 674 inode = file->f_mapping->host; 675 old_file = lo->lo_backing_file; 676 677 error = -EINVAL; 678 679 if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode)) 680 goto out_putf; 681 682 /* new backing store needs to support loop (eg sendfile) */ 683 if (!inode->i_fop->sendfile) 684 goto out_putf; 685 686 /* size of the new backing store needs to be the same */ 687 if (get_loop_size(lo, file) != get_loop_size(lo, old_file)) 688 goto out_putf; 689 690 /* and ... switch */ 691 error = loop_switch(lo, file); 692 if (error) 693 goto out_putf; 694 695 fput(old_file); 696 return 0; 697 698 out_putf: 699 fput(file); 700 out: 701 return error; 702 } 703 704 static inline int is_loop_device(struct file *file) 705 { 706 struct inode *i = file->f_mapping->host; 707 708 return i && S_ISBLK(i->i_mode) && MAJOR(i->i_rdev) == LOOP_MAJOR; 709 } 710 711 static int loop_set_fd(struct loop_device *lo, struct file *lo_file, 712 struct block_device *bdev, unsigned int arg) 713 { 714 struct file *file, *f; 715 struct inode *inode; 716 struct address_space *mapping; 717 unsigned lo_blocksize; 718 int lo_flags = 0; 719 int error; 720 loff_t size; 721 722 /* This is safe, since we have a reference from open(). */ 723 __module_get(THIS_MODULE); 724 725 error = -EBADF; 726 file = fget(arg); 727 if (!file) 728 goto out; 729 730 error = -EBUSY; 731 if (lo->lo_state != Lo_unbound) 732 goto out_putf; 733 734 /* Avoid recursion */ 735 f = file; 736 while (is_loop_device(f)) { 737 struct loop_device *l; 738 739 if (f->f_mapping->host->i_rdev == lo_file->f_mapping->host->i_rdev) 740 goto out_putf; 741 742 l = f->f_mapping->host->i_bdev->bd_disk->private_data; 743 if (l->lo_state == Lo_unbound) { 744 error = -EINVAL; 745 goto out_putf; 746 } 747 f = l->lo_backing_file; 748 } 749 750 mapping = file->f_mapping; 751 inode = mapping->host; 752 753 if (!(file->f_mode & FMODE_WRITE)) 754 lo_flags |= LO_FLAGS_READ_ONLY; 755 756 error = -EINVAL; 757 if (S_ISREG(inode->i_mode) || S_ISBLK(inode->i_mode)) { 758 const struct address_space_operations *aops = mapping->a_ops; 759 /* 760 * If we can't read - sorry. If we only can't write - well, 761 * it's going to be read-only. 762 */ 763 if (!file->f_op->sendfile) 764 goto out_putf; 765 if (aops->prepare_write && aops->commit_write) 766 lo_flags |= LO_FLAGS_USE_AOPS; 767 if (!(lo_flags & LO_FLAGS_USE_AOPS) && !file->f_op->write) 768 lo_flags |= LO_FLAGS_READ_ONLY; 769 770 lo_blocksize = S_ISBLK(inode->i_mode) ? 771 inode->i_bdev->bd_block_size : PAGE_SIZE; 772 773 error = 0; 774 } else { 775 goto out_putf; 776 } 777 778 size = get_loop_size(lo, file); 779 780 if ((loff_t)(sector_t)size != size) { 781 error = -EFBIG; 782 goto out_putf; 783 } 784 785 if (!(lo_file->f_mode & FMODE_WRITE)) 786 lo_flags |= LO_FLAGS_READ_ONLY; 787 788 set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0); 789 790 lo->lo_blocksize = lo_blocksize; 791 lo->lo_device = bdev; 792 lo->lo_flags = lo_flags; 793 lo->lo_backing_file = file; 794 lo->transfer = transfer_none; 795 lo->ioctl = NULL; 796 lo->lo_sizelimit = 0; 797 lo->old_gfp_mask = mapping_gfp_mask(mapping); 798 mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS)); 799 800 lo->lo_bio = lo->lo_biotail = NULL; 801 802 /* 803 * set queue make_request_fn, and add limits based on lower level 804 * device 805 */ 806 blk_queue_make_request(lo->lo_queue, loop_make_request); 807 lo->lo_queue->queuedata = lo; 808 lo->lo_queue->unplug_fn = loop_unplug; 809 810 set_capacity(lo->lo_disk, size); 811 bd_set_size(bdev, size << 9); 812 813 set_blocksize(bdev, lo_blocksize); 814 815 lo->lo_thread = kthread_create(loop_thread, lo, "loop%d", 816 lo->lo_number); 817 if (IS_ERR(lo->lo_thread)) { 818 error = PTR_ERR(lo->lo_thread); 819 goto out_clr; 820 } 821 lo->lo_state = Lo_bound; 822 wake_up_process(lo->lo_thread); 823 return 0; 824 825 out_clr: 826 lo->lo_thread = NULL; 827 lo->lo_device = NULL; 828 lo->lo_backing_file = NULL; 829 lo->lo_flags = 0; 830 set_capacity(lo->lo_disk, 0); 831 invalidate_bdev(bdev); 832 bd_set_size(bdev, 0); 833 mapping_set_gfp_mask(mapping, lo->old_gfp_mask); 834 lo->lo_state = Lo_unbound; 835 out_putf: 836 fput(file); 837 out: 838 /* This is safe: open() is still holding a reference. */ 839 module_put(THIS_MODULE); 840 return error; 841 } 842 843 static int 844 loop_release_xfer(struct loop_device *lo) 845 { 846 int err = 0; 847 struct loop_func_table *xfer = lo->lo_encryption; 848 849 if (xfer) { 850 if (xfer->release) 851 err = xfer->release(lo); 852 lo->transfer = NULL; 853 lo->lo_encryption = NULL; 854 module_put(xfer->owner); 855 } 856 return err; 857 } 858 859 static int 860 loop_init_xfer(struct loop_device *lo, struct loop_func_table *xfer, 861 const struct loop_info64 *i) 862 { 863 int err = 0; 864 865 if (xfer) { 866 struct module *owner = xfer->owner; 867 868 if (!try_module_get(owner)) 869 return -EINVAL; 870 if (xfer->init) 871 err = xfer->init(lo, i); 872 if (err) 873 module_put(owner); 874 else 875 lo->lo_encryption = xfer; 876 } 877 return err; 878 } 879 880 static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev) 881 { 882 struct file *filp = lo->lo_backing_file; 883 gfp_t gfp = lo->old_gfp_mask; 884 885 if (lo->lo_state != Lo_bound) 886 return -ENXIO; 887 888 if (lo->lo_refcnt > 1) /* we needed one fd for the ioctl */ 889 return -EBUSY; 890 891 if (filp == NULL) 892 return -EINVAL; 893 894 spin_lock_irq(&lo->lo_lock); 895 lo->lo_state = Lo_rundown; 896 spin_unlock_irq(&lo->lo_lock); 897 898 kthread_stop(lo->lo_thread); 899 900 lo->lo_backing_file = NULL; 901 902 loop_release_xfer(lo); 903 lo->transfer = NULL; 904 lo->ioctl = NULL; 905 lo->lo_device = NULL; 906 lo->lo_encryption = NULL; 907 lo->lo_offset = 0; 908 lo->lo_sizelimit = 0; 909 lo->lo_encrypt_key_size = 0; 910 lo->lo_flags = 0; 911 lo->lo_thread = NULL; 912 memset(lo->lo_encrypt_key, 0, LO_KEY_SIZE); 913 memset(lo->lo_crypt_name, 0, LO_NAME_SIZE); 914 memset(lo->lo_file_name, 0, LO_NAME_SIZE); 915 invalidate_bdev(bdev); 916 set_capacity(lo->lo_disk, 0); 917 bd_set_size(bdev, 0); 918 mapping_set_gfp_mask(filp->f_mapping, gfp); 919 lo->lo_state = Lo_unbound; 920 fput(filp); 921 /* This is safe: open() is still holding a reference. */ 922 module_put(THIS_MODULE); 923 return 0; 924 } 925 926 static int 927 loop_set_status(struct loop_device *lo, const struct loop_info64 *info) 928 { 929 int err; 930 struct loop_func_table *xfer; 931 932 if (lo->lo_encrypt_key_size && lo->lo_key_owner != current->uid && 933 !capable(CAP_SYS_ADMIN)) 934 return -EPERM; 935 if (lo->lo_state != Lo_bound) 936 return -ENXIO; 937 if ((unsigned int) info->lo_encrypt_key_size > LO_KEY_SIZE) 938 return -EINVAL; 939 940 err = loop_release_xfer(lo); 941 if (err) 942 return err; 943 944 if (info->lo_encrypt_type) { 945 unsigned int type = info->lo_encrypt_type; 946 947 if (type >= MAX_LO_CRYPT) 948 return -EINVAL; 949 xfer = xfer_funcs[type]; 950 if (xfer == NULL) 951 return -EINVAL; 952 } else 953 xfer = NULL; 954 955 err = loop_init_xfer(lo, xfer, info); 956 if (err) 957 return err; 958 959 if (lo->lo_offset != info->lo_offset || 960 lo->lo_sizelimit != info->lo_sizelimit) { 961 lo->lo_offset = info->lo_offset; 962 lo->lo_sizelimit = info->lo_sizelimit; 963 if (figure_loop_size(lo)) 964 return -EFBIG; 965 } 966 967 memcpy(lo->lo_file_name, info->lo_file_name, LO_NAME_SIZE); 968 memcpy(lo->lo_crypt_name, info->lo_crypt_name, LO_NAME_SIZE); 969 lo->lo_file_name[LO_NAME_SIZE-1] = 0; 970 lo->lo_crypt_name[LO_NAME_SIZE-1] = 0; 971 972 if (!xfer) 973 xfer = &none_funcs; 974 lo->transfer = xfer->transfer; 975 lo->ioctl = xfer->ioctl; 976 977 lo->lo_encrypt_key_size = info->lo_encrypt_key_size; 978 lo->lo_init[0] = info->lo_init[0]; 979 lo->lo_init[1] = info->lo_init[1]; 980 if (info->lo_encrypt_key_size) { 981 memcpy(lo->lo_encrypt_key, info->lo_encrypt_key, 982 info->lo_encrypt_key_size); 983 lo->lo_key_owner = current->uid; 984 } 985 986 return 0; 987 } 988 989 static int 990 loop_get_status(struct loop_device *lo, struct loop_info64 *info) 991 { 992 struct file *file = lo->lo_backing_file; 993 struct kstat stat; 994 int error; 995 996 if (lo->lo_state != Lo_bound) 997 return -ENXIO; 998 error = vfs_getattr(file->f_path.mnt, file->f_path.dentry, &stat); 999 if (error) 1000 return error; 1001 memset(info, 0, sizeof(*info)); 1002 info->lo_number = lo->lo_number; 1003 info->lo_device = huge_encode_dev(stat.dev); 1004 info->lo_inode = stat.ino; 1005 info->lo_rdevice = huge_encode_dev(lo->lo_device ? stat.rdev : stat.dev); 1006 info->lo_offset = lo->lo_offset; 1007 info->lo_sizelimit = lo->lo_sizelimit; 1008 info->lo_flags = lo->lo_flags; 1009 memcpy(info->lo_file_name, lo->lo_file_name, LO_NAME_SIZE); 1010 memcpy(info->lo_crypt_name, lo->lo_crypt_name, LO_NAME_SIZE); 1011 info->lo_encrypt_type = 1012 lo->lo_encryption ? lo->lo_encryption->number : 0; 1013 if (lo->lo_encrypt_key_size && capable(CAP_SYS_ADMIN)) { 1014 info->lo_encrypt_key_size = lo->lo_encrypt_key_size; 1015 memcpy(info->lo_encrypt_key, lo->lo_encrypt_key, 1016 lo->lo_encrypt_key_size); 1017 } 1018 return 0; 1019 } 1020 1021 static void 1022 loop_info64_from_old(const struct loop_info *info, struct loop_info64 *info64) 1023 { 1024 memset(info64, 0, sizeof(*info64)); 1025 info64->lo_number = info->lo_number; 1026 info64->lo_device = info->lo_device; 1027 info64->lo_inode = info->lo_inode; 1028 info64->lo_rdevice = info->lo_rdevice; 1029 info64->lo_offset = info->lo_offset; 1030 info64->lo_sizelimit = 0; 1031 info64->lo_encrypt_type = info->lo_encrypt_type; 1032 info64->lo_encrypt_key_size = info->lo_encrypt_key_size; 1033 info64->lo_flags = info->lo_flags; 1034 info64->lo_init[0] = info->lo_init[0]; 1035 info64->lo_init[1] = info->lo_init[1]; 1036 if (info->lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 1037 memcpy(info64->lo_crypt_name, info->lo_name, LO_NAME_SIZE); 1038 else 1039 memcpy(info64->lo_file_name, info->lo_name, LO_NAME_SIZE); 1040 memcpy(info64->lo_encrypt_key, info->lo_encrypt_key, LO_KEY_SIZE); 1041 } 1042 1043 static int 1044 loop_info64_to_old(const struct loop_info64 *info64, struct loop_info *info) 1045 { 1046 memset(info, 0, sizeof(*info)); 1047 info->lo_number = info64->lo_number; 1048 info->lo_device = info64->lo_device; 1049 info->lo_inode = info64->lo_inode; 1050 info->lo_rdevice = info64->lo_rdevice; 1051 info->lo_offset = info64->lo_offset; 1052 info->lo_encrypt_type = info64->lo_encrypt_type; 1053 info->lo_encrypt_key_size = info64->lo_encrypt_key_size; 1054 info->lo_flags = info64->lo_flags; 1055 info->lo_init[0] = info64->lo_init[0]; 1056 info->lo_init[1] = info64->lo_init[1]; 1057 if (info->lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 1058 memcpy(info->lo_name, info64->lo_crypt_name, LO_NAME_SIZE); 1059 else 1060 memcpy(info->lo_name, info64->lo_file_name, LO_NAME_SIZE); 1061 memcpy(info->lo_encrypt_key, info64->lo_encrypt_key, LO_KEY_SIZE); 1062 1063 /* error in case values were truncated */ 1064 if (info->lo_device != info64->lo_device || 1065 info->lo_rdevice != info64->lo_rdevice || 1066 info->lo_inode != info64->lo_inode || 1067 info->lo_offset != info64->lo_offset) 1068 return -EOVERFLOW; 1069 1070 return 0; 1071 } 1072 1073 static int 1074 loop_set_status_old(struct loop_device *lo, const struct loop_info __user *arg) 1075 { 1076 struct loop_info info; 1077 struct loop_info64 info64; 1078 1079 if (copy_from_user(&info, arg, sizeof (struct loop_info))) 1080 return -EFAULT; 1081 loop_info64_from_old(&info, &info64); 1082 return loop_set_status(lo, &info64); 1083 } 1084 1085 static int 1086 loop_set_status64(struct loop_device *lo, const struct loop_info64 __user *arg) 1087 { 1088 struct loop_info64 info64; 1089 1090 if (copy_from_user(&info64, arg, sizeof (struct loop_info64))) 1091 return -EFAULT; 1092 return loop_set_status(lo, &info64); 1093 } 1094 1095 static int 1096 loop_get_status_old(struct loop_device *lo, struct loop_info __user *arg) { 1097 struct loop_info info; 1098 struct loop_info64 info64; 1099 int err = 0; 1100 1101 if (!arg) 1102 err = -EINVAL; 1103 if (!err) 1104 err = loop_get_status(lo, &info64); 1105 if (!err) 1106 err = loop_info64_to_old(&info64, &info); 1107 if (!err && copy_to_user(arg, &info, sizeof(info))) 1108 err = -EFAULT; 1109 1110 return err; 1111 } 1112 1113 static int 1114 loop_get_status64(struct loop_device *lo, struct loop_info64 __user *arg) { 1115 struct loop_info64 info64; 1116 int err = 0; 1117 1118 if (!arg) 1119 err = -EINVAL; 1120 if (!err) 1121 err = loop_get_status(lo, &info64); 1122 if (!err && copy_to_user(arg, &info64, sizeof(info64))) 1123 err = -EFAULT; 1124 1125 return err; 1126 } 1127 1128 static int lo_ioctl(struct inode * inode, struct file * file, 1129 unsigned int cmd, unsigned long arg) 1130 { 1131 struct loop_device *lo = inode->i_bdev->bd_disk->private_data; 1132 int err; 1133 1134 mutex_lock(&lo->lo_ctl_mutex); 1135 switch (cmd) { 1136 case LOOP_SET_FD: 1137 err = loop_set_fd(lo, file, inode->i_bdev, arg); 1138 break; 1139 case LOOP_CHANGE_FD: 1140 err = loop_change_fd(lo, file, inode->i_bdev, arg); 1141 break; 1142 case LOOP_CLR_FD: 1143 err = loop_clr_fd(lo, inode->i_bdev); 1144 break; 1145 case LOOP_SET_STATUS: 1146 err = loop_set_status_old(lo, (struct loop_info __user *) arg); 1147 break; 1148 case LOOP_GET_STATUS: 1149 err = loop_get_status_old(lo, (struct loop_info __user *) arg); 1150 break; 1151 case LOOP_SET_STATUS64: 1152 err = loop_set_status64(lo, (struct loop_info64 __user *) arg); 1153 break; 1154 case LOOP_GET_STATUS64: 1155 err = loop_get_status64(lo, (struct loop_info64 __user *) arg); 1156 break; 1157 default: 1158 err = lo->ioctl ? lo->ioctl(lo, cmd, arg) : -EINVAL; 1159 } 1160 mutex_unlock(&lo->lo_ctl_mutex); 1161 return err; 1162 } 1163 1164 #ifdef CONFIG_COMPAT 1165 struct compat_loop_info { 1166 compat_int_t lo_number; /* ioctl r/o */ 1167 compat_dev_t lo_device; /* ioctl r/o */ 1168 compat_ulong_t lo_inode; /* ioctl r/o */ 1169 compat_dev_t lo_rdevice; /* ioctl r/o */ 1170 compat_int_t lo_offset; 1171 compat_int_t lo_encrypt_type; 1172 compat_int_t lo_encrypt_key_size; /* ioctl w/o */ 1173 compat_int_t lo_flags; /* ioctl r/o */ 1174 char lo_name[LO_NAME_SIZE]; 1175 unsigned char lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */ 1176 compat_ulong_t lo_init[2]; 1177 char reserved[4]; 1178 }; 1179 1180 /* 1181 * Transfer 32-bit compatibility structure in userspace to 64-bit loop info 1182 * - noinlined to reduce stack space usage in main part of driver 1183 */ 1184 static noinline int 1185 loop_info64_from_compat(const struct compat_loop_info __user *arg, 1186 struct loop_info64 *info64) 1187 { 1188 struct compat_loop_info info; 1189 1190 if (copy_from_user(&info, arg, sizeof(info))) 1191 return -EFAULT; 1192 1193 memset(info64, 0, sizeof(*info64)); 1194 info64->lo_number = info.lo_number; 1195 info64->lo_device = info.lo_device; 1196 info64->lo_inode = info.lo_inode; 1197 info64->lo_rdevice = info.lo_rdevice; 1198 info64->lo_offset = info.lo_offset; 1199 info64->lo_sizelimit = 0; 1200 info64->lo_encrypt_type = info.lo_encrypt_type; 1201 info64->lo_encrypt_key_size = info.lo_encrypt_key_size; 1202 info64->lo_flags = info.lo_flags; 1203 info64->lo_init[0] = info.lo_init[0]; 1204 info64->lo_init[1] = info.lo_init[1]; 1205 if (info.lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 1206 memcpy(info64->lo_crypt_name, info.lo_name, LO_NAME_SIZE); 1207 else 1208 memcpy(info64->lo_file_name, info.lo_name, LO_NAME_SIZE); 1209 memcpy(info64->lo_encrypt_key, info.lo_encrypt_key, LO_KEY_SIZE); 1210 return 0; 1211 } 1212 1213 /* 1214 * Transfer 64-bit loop info to 32-bit compatibility structure in userspace 1215 * - noinlined to reduce stack space usage in main part of driver 1216 */ 1217 static noinline int 1218 loop_info64_to_compat(const struct loop_info64 *info64, 1219 struct compat_loop_info __user *arg) 1220 { 1221 struct compat_loop_info info; 1222 1223 memset(&info, 0, sizeof(info)); 1224 info.lo_number = info64->lo_number; 1225 info.lo_device = info64->lo_device; 1226 info.lo_inode = info64->lo_inode; 1227 info.lo_rdevice = info64->lo_rdevice; 1228 info.lo_offset = info64->lo_offset; 1229 info.lo_encrypt_type = info64->lo_encrypt_type; 1230 info.lo_encrypt_key_size = info64->lo_encrypt_key_size; 1231 info.lo_flags = info64->lo_flags; 1232 info.lo_init[0] = info64->lo_init[0]; 1233 info.lo_init[1] = info64->lo_init[1]; 1234 if (info.lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 1235 memcpy(info.lo_name, info64->lo_crypt_name, LO_NAME_SIZE); 1236 else 1237 memcpy(info.lo_name, info64->lo_file_name, LO_NAME_SIZE); 1238 memcpy(info.lo_encrypt_key, info64->lo_encrypt_key, LO_KEY_SIZE); 1239 1240 /* error in case values were truncated */ 1241 if (info.lo_device != info64->lo_device || 1242 info.lo_rdevice != info64->lo_rdevice || 1243 info.lo_inode != info64->lo_inode || 1244 info.lo_offset != info64->lo_offset || 1245 info.lo_init[0] != info64->lo_init[0] || 1246 info.lo_init[1] != info64->lo_init[1]) 1247 return -EOVERFLOW; 1248 1249 if (copy_to_user(arg, &info, sizeof(info))) 1250 return -EFAULT; 1251 return 0; 1252 } 1253 1254 static int 1255 loop_set_status_compat(struct loop_device *lo, 1256 const struct compat_loop_info __user *arg) 1257 { 1258 struct loop_info64 info64; 1259 int ret; 1260 1261 ret = loop_info64_from_compat(arg, &info64); 1262 if (ret < 0) 1263 return ret; 1264 return loop_set_status(lo, &info64); 1265 } 1266 1267 static int 1268 loop_get_status_compat(struct loop_device *lo, 1269 struct compat_loop_info __user *arg) 1270 { 1271 struct loop_info64 info64; 1272 int err = 0; 1273 1274 if (!arg) 1275 err = -EINVAL; 1276 if (!err) 1277 err = loop_get_status(lo, &info64); 1278 if (!err) 1279 err = loop_info64_to_compat(&info64, arg); 1280 return err; 1281 } 1282 1283 static long lo_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 1284 { 1285 struct inode *inode = file->f_path.dentry->d_inode; 1286 struct loop_device *lo = inode->i_bdev->bd_disk->private_data; 1287 int err; 1288 1289 lock_kernel(); 1290 switch(cmd) { 1291 case LOOP_SET_STATUS: 1292 mutex_lock(&lo->lo_ctl_mutex); 1293 err = loop_set_status_compat( 1294 lo, (const struct compat_loop_info __user *) arg); 1295 mutex_unlock(&lo->lo_ctl_mutex); 1296 break; 1297 case LOOP_GET_STATUS: 1298 mutex_lock(&lo->lo_ctl_mutex); 1299 err = loop_get_status_compat( 1300 lo, (struct compat_loop_info __user *) arg); 1301 mutex_unlock(&lo->lo_ctl_mutex); 1302 break; 1303 case LOOP_CLR_FD: 1304 case LOOP_GET_STATUS64: 1305 case LOOP_SET_STATUS64: 1306 arg = (unsigned long) compat_ptr(arg); 1307 case LOOP_SET_FD: 1308 case LOOP_CHANGE_FD: 1309 err = lo_ioctl(inode, file, cmd, arg); 1310 break; 1311 default: 1312 err = -ENOIOCTLCMD; 1313 break; 1314 } 1315 unlock_kernel(); 1316 return err; 1317 } 1318 #endif 1319 1320 static int lo_open(struct inode *inode, struct file *file) 1321 { 1322 struct loop_device *lo = inode->i_bdev->bd_disk->private_data; 1323 1324 mutex_lock(&lo->lo_ctl_mutex); 1325 lo->lo_refcnt++; 1326 mutex_unlock(&lo->lo_ctl_mutex); 1327 1328 return 0; 1329 } 1330 1331 static int lo_release(struct inode *inode, struct file *file) 1332 { 1333 struct loop_device *lo = inode->i_bdev->bd_disk->private_data; 1334 1335 mutex_lock(&lo->lo_ctl_mutex); 1336 --lo->lo_refcnt; 1337 mutex_unlock(&lo->lo_ctl_mutex); 1338 1339 return 0; 1340 } 1341 1342 static struct block_device_operations lo_fops = { 1343 .owner = THIS_MODULE, 1344 .open = lo_open, 1345 .release = lo_release, 1346 .ioctl = lo_ioctl, 1347 #ifdef CONFIG_COMPAT 1348 .compat_ioctl = lo_compat_ioctl, 1349 #endif 1350 }; 1351 1352 /* 1353 * And now the modules code and kernel interface. 1354 */ 1355 static int max_loop; 1356 module_param(max_loop, int, 0); 1357 MODULE_PARM_DESC(max_loop, "obsolete, loop device is created on-demand"); 1358 MODULE_LICENSE("GPL"); 1359 MODULE_ALIAS_BLOCKDEV_MAJOR(LOOP_MAJOR); 1360 1361 int loop_register_transfer(struct loop_func_table *funcs) 1362 { 1363 unsigned int n = funcs->number; 1364 1365 if (n >= MAX_LO_CRYPT || xfer_funcs[n]) 1366 return -EINVAL; 1367 xfer_funcs[n] = funcs; 1368 return 0; 1369 } 1370 1371 int loop_unregister_transfer(int number) 1372 { 1373 unsigned int n = number; 1374 struct loop_device *lo; 1375 struct loop_func_table *xfer; 1376 1377 if (n == 0 || n >= MAX_LO_CRYPT || (xfer = xfer_funcs[n]) == NULL) 1378 return -EINVAL; 1379 1380 xfer_funcs[n] = NULL; 1381 1382 list_for_each_entry(lo, &loop_devices, lo_list) { 1383 mutex_lock(&lo->lo_ctl_mutex); 1384 1385 if (lo->lo_encryption == xfer) 1386 loop_release_xfer(lo); 1387 1388 mutex_unlock(&lo->lo_ctl_mutex); 1389 } 1390 1391 return 0; 1392 } 1393 1394 EXPORT_SYMBOL(loop_register_transfer); 1395 EXPORT_SYMBOL(loop_unregister_transfer); 1396 1397 static struct loop_device *loop_init_one(int i) 1398 { 1399 struct loop_device *lo; 1400 struct gendisk *disk; 1401 1402 list_for_each_entry(lo, &loop_devices, lo_list) { 1403 if (lo->lo_number == i) 1404 return lo; 1405 } 1406 1407 lo = kzalloc(sizeof(*lo), GFP_KERNEL); 1408 if (!lo) 1409 goto out; 1410 1411 lo->lo_queue = blk_alloc_queue(GFP_KERNEL); 1412 if (!lo->lo_queue) 1413 goto out_free_dev; 1414 1415 disk = lo->lo_disk = alloc_disk(1); 1416 if (!disk) 1417 goto out_free_queue; 1418 1419 mutex_init(&lo->lo_ctl_mutex); 1420 lo->lo_number = i; 1421 lo->lo_thread = NULL; 1422 init_waitqueue_head(&lo->lo_event); 1423 spin_lock_init(&lo->lo_lock); 1424 disk->major = LOOP_MAJOR; 1425 disk->first_minor = i; 1426 disk->fops = &lo_fops; 1427 disk->private_data = lo; 1428 disk->queue = lo->lo_queue; 1429 sprintf(disk->disk_name, "loop%d", i); 1430 add_disk(disk); 1431 list_add_tail(&lo->lo_list, &loop_devices); 1432 return lo; 1433 1434 out_free_queue: 1435 blk_cleanup_queue(lo->lo_queue); 1436 out_free_dev: 1437 kfree(lo); 1438 out: 1439 return NULL; 1440 } 1441 1442 static void loop_del_one(struct loop_device *lo) 1443 { 1444 del_gendisk(lo->lo_disk); 1445 blk_cleanup_queue(lo->lo_queue); 1446 put_disk(lo->lo_disk); 1447 list_del(&lo->lo_list); 1448 kfree(lo); 1449 } 1450 1451 static struct kobject *loop_probe(dev_t dev, int *part, void *data) 1452 { 1453 struct loop_device *lo; 1454 struct kobject *kobj; 1455 1456 mutex_lock(&loop_devices_mutex); 1457 lo = loop_init_one(dev & MINORMASK); 1458 kobj = lo ? get_disk(lo->lo_disk) : ERR_PTR(-ENOMEM); 1459 mutex_unlock(&loop_devices_mutex); 1460 1461 *part = 0; 1462 return kobj; 1463 } 1464 1465 static int __init loop_init(void) 1466 { 1467 if (register_blkdev(LOOP_MAJOR, "loop")) 1468 return -EIO; 1469 blk_register_region(MKDEV(LOOP_MAJOR, 0), 1UL << MINORBITS, 1470 THIS_MODULE, loop_probe, NULL, NULL); 1471 1472 if (max_loop) { 1473 printk(KERN_INFO "loop: the max_loop option is obsolete " 1474 "and will be removed in March 2008\n"); 1475 1476 } 1477 printk(KERN_INFO "loop: module loaded\n"); 1478 return 0; 1479 } 1480 1481 static void __exit loop_exit(void) 1482 { 1483 struct loop_device *lo, *next; 1484 1485 list_for_each_entry_safe(lo, next, &loop_devices, lo_list) 1486 loop_del_one(lo); 1487 1488 blk_unregister_region(MKDEV(LOOP_MAJOR, 0), 1UL << MINORBITS); 1489 if (unregister_blkdev(LOOP_MAJOR, "loop")) 1490 printk(KERN_WARNING "loop: cannot unregister blkdev\n"); 1491 } 1492 1493 module_init(loop_init); 1494 module_exit(loop_exit); 1495 1496 #ifndef MODULE 1497 static int __init max_loop_setup(char *str) 1498 { 1499 max_loop = simple_strtol(str, NULL, 0); 1500 return 1; 1501 } 1502 1503 __setup("max_loop=", max_loop_setup); 1504 #endif 1505