2 * linux/drivers/block/loop.c
4 * Written by Theodore Ts'o, 3/29/93
6 * Copyright 1993 by Theodore Ts'o. Redistribution of this file is
7 * permitted under the GNU General Public License.
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
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
15 * Fixed do_loop_request() re-entrancy - Vincent.Renardias@waw.com Mar 20, 1997
17 * Added devfs support - Richard Gooch <rgooch@atnf.csiro.au> 16-Jan-1998
19 * Handle sparse backing files correctly - Kenn Humborg, Jun 28, 1998
21 * Loadable modules and other fixes by AK, 1998
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
27 * Maximum number of loop devices now dynamic via max_loop module parameter.
28 * Russell Kroll <rkroll@exploits.org> 19990701
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
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
37 * Jens Axboe <axboe@suse.de>, Nov 2000
39 * Support up to 256 loop devices
40 * Heinz Mauelshagen <mge@sistina.com>, Feb 2002
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
45 * Anton Altaparmakov, 16 Feb 2005
48 * - Advisory locking is ignored here.
49 * - Should use an own CAP_* category instead of CAP_SYS_ADMIN
53 #include <linux/module.h>
54 #include <linux/moduleparam.h>
55 #include <linux/sched.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>
78 #include <asm/uaccess.h>
80 static LIST_HEAD(loop_devices
);
81 static DEFINE_MUTEX(loop_devices_mutex
);
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
)
91 char *raw_buf
= kmap_atomic(raw_page
, KM_USER0
) + raw_off
;
92 char *loop_buf
= kmap_atomic(loop_page
, KM_USER1
) + loop_off
;
95 memcpy(loop_buf
, raw_buf
, size
);
97 memcpy(raw_buf
, loop_buf
, size
);
99 kunmap_atomic(raw_buf
, KM_USER0
);
100 kunmap_atomic(loop_buf
, KM_USER1
);
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
)
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
;
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
];
128 kunmap_atomic(raw_buf
, KM_USER0
);
129 kunmap_atomic(loop_buf
, KM_USER1
);
134 static int xor_init(struct loop_device
*lo
, const struct loop_info64
*info
)
136 if (unlikely(info
->lo_encrypt_key_size
<= 0))
141 static struct loop_func_table none_funcs
= {
142 .number
= LO_CRYPT_NONE
,
143 .transfer
= transfer_none
,
146 static struct loop_func_table xor_funcs
= {
147 .number
= LO_CRYPT_XOR
,
148 .transfer
= transfer_xor
,
152 /* xfer_funcs[0] is special - its release function is never called */
153 static struct loop_func_table
*xfer_funcs
[MAX_LO_CRYPT
] = {
158 static loff_t
get_loop_size(struct loop_device
*lo
, struct file
*file
)
160 loff_t size
, offset
, loopsize
;
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
;
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.
173 return loopsize
>> 9;
177 figure_loop_size(struct loop_device
*lo
)
179 loff_t size
= get_loop_size(lo
, lo
->lo_backing_file
);
180 sector_t x
= (sector_t
)size
;
182 if (unlikely((loff_t
)x
!= size
))
185 set_capacity(lo
->lo_disk
, x
);
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
)
195 if (unlikely(!lo
->transfer
))
198 return lo
->transfer(lo
, cmd
, rpage
, roffs
, lpage
, loffs
, size
, rblock
);
202 * do_lo_send_aops - helper for writing data to a loop device
204 * This is the fast version for backing filesystems which implement the address
205 * space operations prepare_write and commit_write.
207 static int do_lo_send_aops(struct loop_device
*lo
, struct bio_vec
*bvec
,
208 int bsize
, loff_t pos
, struct page
*page
)
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
;
214 unsigned offset
, bv_offs
;
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
;
227 IV
= ((sector_t
)index
<< (PAGE_CACHE_SHIFT
- 9))+(offset
>> 9);
228 size
= PAGE_CACHE_SIZE
- offset
;
231 page
= grab_cache_page(mapping
, index
);
234 ret
= aops
->prepare_write(file
, page
, offset
,
237 if (ret
== AOP_TRUNCATED_PAGE
) {
238 page_cache_release(page
);
243 transfer_result
= lo_do_transfer(lo
, WRITE
, page
, offset
,
244 bvec
->bv_page
, bv_offs
, size
, IV
);
245 if (unlikely(transfer_result
)) {
249 * The transfer failed, but we still write the data to
250 * keep prepare/commit calls balanced.
252 printk(KERN_ERR
"loop: transfer error block %llu\n",
253 (unsigned long long)index
);
254 kaddr
= kmap_atomic(page
, KM_USER0
);
255 memset(kaddr
+ offset
, 0, size
);
256 kunmap_atomic(kaddr
, KM_USER0
);
258 flush_dcache_page(page
);
259 ret
= aops
->commit_write(file
, page
, offset
,
262 if (ret
== AOP_TRUNCATED_PAGE
) {
263 page_cache_release(page
);
268 if (unlikely(transfer_result
))
276 page_cache_release(page
);
280 mutex_unlock(&mapping
->host
->i_mutex
);
284 page_cache_release(page
);
291 * __do_lo_send_write - helper for writing data to a loop device
293 * This helper just factors out common code between do_lo_send_direct_write()
294 * and do_lo_send_write().
296 static int __do_lo_send_write(struct file
*file
,
297 u8
*buf
, const int len
, loff_t pos
)
300 mm_segment_t old_fs
= get_fs();
303 bw
= file
->f_op
->write(file
, buf
, len
, &pos
);
305 if (likely(bw
== len
))
307 printk(KERN_ERR
"loop: Write error at byte offset %llu, length %i.\n",
308 (unsigned long long)pos
, len
);
315 * do_lo_send_direct_write - helper for writing data to a loop device
317 * This is the fast, non-transforming version for backing filesystems which do
318 * not implement the address space operations prepare_write and commit_write.
319 * It uses the write file operation which should be present on all writeable
322 static int do_lo_send_direct_write(struct loop_device
*lo
,
323 struct bio_vec
*bvec
, int bsize
, loff_t pos
, struct page
*page
)
325 ssize_t bw
= __do_lo_send_write(lo
->lo_backing_file
,
326 kmap(bvec
->bv_page
) + bvec
->bv_offset
,
328 kunmap(bvec
->bv_page
);
334 * do_lo_send_write - helper for writing data to a loop device
336 * This is the slow, transforming version for filesystems which do not
337 * implement the address space operations prepare_write and commit_write. It
338 * uses the write file operation which should be present on all writeable
341 * Using fops->write is slower than using aops->{prepare,commit}_write in the
342 * transforming case because we need to double buffer the data as we cannot do
343 * the transformations in place as we do not have direct access to the
344 * destination pages of the backing file.
346 static int do_lo_send_write(struct loop_device
*lo
, struct bio_vec
*bvec
,
347 int bsize
, loff_t pos
, struct page
*page
)
349 int ret
= lo_do_transfer(lo
, WRITE
, page
, 0, bvec
->bv_page
,
350 bvec
->bv_offset
, bvec
->bv_len
, pos
>> 9);
352 return __do_lo_send_write(lo
->lo_backing_file
,
353 page_address(page
), bvec
->bv_len
,
355 printk(KERN_ERR
"loop: Transfer error at byte offset %llu, "
356 "length %i.\n", (unsigned long long)pos
, bvec
->bv_len
);
362 static int lo_send(struct loop_device
*lo
, struct bio
*bio
, int bsize
,
365 int (*do_lo_send
)(struct loop_device
*, struct bio_vec
*, int, loff_t
,
367 struct bio_vec
*bvec
;
368 struct page
*page
= NULL
;
371 do_lo_send
= do_lo_send_aops
;
372 if (!(lo
->lo_flags
& LO_FLAGS_USE_AOPS
)) {
373 do_lo_send
= do_lo_send_direct_write
;
374 if (lo
->transfer
!= transfer_none
) {
375 page
= alloc_page(GFP_NOIO
| __GFP_HIGHMEM
);
379 do_lo_send
= do_lo_send_write
;
382 bio_for_each_segment(bvec
, bio
, i
) {
383 ret
= do_lo_send(lo
, bvec
, bsize
, pos
, page
);
395 printk(KERN_ERR
"loop: Failed to allocate temporary page for write.\n");
400 struct lo_read_data
{
401 struct loop_device
*lo
;
408 lo_read_actor(read_descriptor_t
*desc
, struct page
*page
,
409 unsigned long offset
, unsigned long size
)
411 unsigned long count
= desc
->count
;
412 struct lo_read_data
*p
= desc
->arg
.data
;
413 struct loop_device
*lo
= p
->lo
;
416 IV
= ((sector_t
) page
->index
<< (PAGE_CACHE_SHIFT
- 9))+(offset
>> 9);
421 if (lo_do_transfer(lo
, READ
, page
, offset
, p
->page
, p
->offset
, size
, IV
)) {
423 printk(KERN_ERR
"loop: transfer error block %ld\n",
425 desc
->error
= -EINVAL
;
428 flush_dcache_page(p
->page
);
430 desc
->count
= count
- size
;
431 desc
->written
+= size
;
437 do_lo_receive(struct loop_device
*lo
,
438 struct bio_vec
*bvec
, int bsize
, loff_t pos
)
440 struct lo_read_data cookie
;
445 cookie
.page
= bvec
->bv_page
;
446 cookie
.offset
= bvec
->bv_offset
;
447 cookie
.bsize
= bsize
;
448 file
= lo
->lo_backing_file
;
449 retval
= file
->f_op
->sendfile(file
, &pos
, bvec
->bv_len
,
450 lo_read_actor
, &cookie
);
451 return (retval
< 0)? retval
: 0;
455 lo_receive(struct loop_device
*lo
, struct bio
*bio
, int bsize
, loff_t pos
)
457 struct bio_vec
*bvec
;
460 bio_for_each_segment(bvec
, bio
, i
) {
461 ret
= do_lo_receive(lo
, bvec
, bsize
, pos
);
469 static int do_bio_filebacked(struct loop_device
*lo
, struct bio
*bio
)
474 pos
= ((loff_t
) bio
->bi_sector
<< 9) + lo
->lo_offset
;
475 if (bio_rw(bio
) == WRITE
)
476 ret
= lo_send(lo
, bio
, lo
->lo_blocksize
, pos
);
478 ret
= lo_receive(lo
, bio
, lo
->lo_blocksize
, pos
);
483 * Add bio to back of pending list
485 static void loop_add_bio(struct loop_device
*lo
, struct bio
*bio
)
487 if (lo
->lo_biotail
) {
488 lo
->lo_biotail
->bi_next
= bio
;
489 lo
->lo_biotail
= bio
;
491 lo
->lo_bio
= lo
->lo_biotail
= bio
;
495 * Grab first pending buffer
497 static struct bio
*loop_get_bio(struct loop_device
*lo
)
501 if ((bio
= lo
->lo_bio
)) {
502 if (bio
== lo
->lo_biotail
)
503 lo
->lo_biotail
= NULL
;
504 lo
->lo_bio
= bio
->bi_next
;
511 static int loop_make_request(request_queue_t
*q
, struct bio
*old_bio
)
513 struct loop_device
*lo
= q
->queuedata
;
514 int rw
= bio_rw(old_bio
);
519 BUG_ON(!lo
|| (rw
!= READ
&& rw
!= WRITE
));
521 spin_lock_irq(&lo
->lo_lock
);
522 if (lo
->lo_state
!= Lo_bound
)
524 if (unlikely(rw
== WRITE
&& (lo
->lo_flags
& LO_FLAGS_READ_ONLY
)))
526 loop_add_bio(lo
, old_bio
);
527 wake_up(&lo
->lo_event
);
528 spin_unlock_irq(&lo
->lo_lock
);
532 spin_unlock_irq(&lo
->lo_lock
);
533 bio_io_error(old_bio
, old_bio
->bi_size
);
538 * kick off io on the underlying address space
540 static void loop_unplug(request_queue_t
*q
)
542 struct loop_device
*lo
= q
->queuedata
;
544 clear_bit(QUEUE_FLAG_PLUGGED
, &q
->queue_flags
);
545 blk_run_address_space(lo
->lo_backing_file
->f_mapping
);
548 struct switch_request
{
550 struct completion wait
;
553 static void do_loop_switch(struct loop_device
*, struct switch_request
*);
555 static inline void loop_handle_bio(struct loop_device
*lo
, struct bio
*bio
)
557 if (unlikely(!bio
->bi_bdev
)) {
558 do_loop_switch(lo
, bio
->bi_private
);
561 int ret
= do_bio_filebacked(lo
, bio
);
562 bio_endio(bio
, bio
->bi_size
, ret
);
567 * worker thread that handles reads/writes to file backed loop devices,
568 * to avoid blocking in our make_request_fn. it also does loop decrypting
569 * on reads for block backed loop, as that is too heavy to do from
570 * b_end_io context where irqs may be disabled.
572 * Loop explanation: loop_clr_fd() sets lo_state to Lo_rundown before
573 * calling kthread_stop(). Therefore once kthread_should_stop() is
574 * true, make_request will not place any more requests. Therefore
575 * once kthread_should_stop() is true and lo_bio is NULL, we are
576 * done with the loop.
578 static int loop_thread(void *data
)
580 struct loop_device
*lo
= data
;
584 * loop can be used in an encrypted device,
585 * hence, it mustn't be stopped at all
586 * because it could be indirectly used during suspension
588 current
->flags
|= PF_NOFREEZE
;
590 set_user_nice(current
, -20);
592 while (!kthread_should_stop() || lo
->lo_bio
) {
594 wait_event_interruptible(lo
->lo_event
,
595 lo
->lo_bio
|| kthread_should_stop());
599 spin_lock_irq(&lo
->lo_lock
);
600 bio
= loop_get_bio(lo
);
601 spin_unlock_irq(&lo
->lo_lock
);
604 loop_handle_bio(lo
, bio
);
611 * loop_switch performs the hard work of switching a backing store.
612 * First it needs to flush existing IO, it does this by sending a magic
613 * BIO down the pipe. The completion of this BIO does the actual switch.
615 static int loop_switch(struct loop_device
*lo
, struct file
*file
)
617 struct switch_request w
;
618 struct bio
*bio
= bio_alloc(GFP_KERNEL
, 1);
621 init_completion(&w
.wait
);
623 bio
->bi_private
= &w
;
625 loop_make_request(lo
->lo_queue
, bio
);
626 wait_for_completion(&w
.wait
);
631 * Do the actual switch; called from the BIO completion routine
633 static void do_loop_switch(struct loop_device
*lo
, struct switch_request
*p
)
635 struct file
*file
= p
->file
;
636 struct file
*old_file
= lo
->lo_backing_file
;
637 struct address_space
*mapping
= file
->f_mapping
;
639 mapping_set_gfp_mask(old_file
->f_mapping
, lo
->old_gfp_mask
);
640 lo
->lo_backing_file
= file
;
641 lo
->lo_blocksize
= S_ISBLK(mapping
->host
->i_mode
) ?
642 mapping
->host
->i_bdev
->bd_block_size
: PAGE_SIZE
;
643 lo
->old_gfp_mask
= mapping_gfp_mask(mapping
);
644 mapping_set_gfp_mask(mapping
, lo
->old_gfp_mask
& ~(__GFP_IO
|__GFP_FS
));
650 * loop_change_fd switched the backing store of a loopback device to
651 * a new file. This is useful for operating system installers to free up
652 * the original file and in High Availability environments to switch to
653 * an alternative location for the content in case of server meltdown.
654 * This can only work if the loop device is used read-only, and if the
655 * new backing store is the same size and type as the old backing store.
657 static int loop_change_fd(struct loop_device
*lo
, struct file
*lo_file
,
658 struct block_device
*bdev
, unsigned int arg
)
660 struct file
*file
, *old_file
;
665 if (lo
->lo_state
!= Lo_bound
)
668 /* the loop device has to be read-only */
670 if (!(lo
->lo_flags
& LO_FLAGS_READ_ONLY
))
678 inode
= file
->f_mapping
->host
;
679 old_file
= lo
->lo_backing_file
;
683 if (!S_ISREG(inode
->i_mode
) && !S_ISBLK(inode
->i_mode
))
686 /* new backing store needs to support loop (eg sendfile) */
687 if (!inode
->i_fop
->sendfile
)
690 /* size of the new backing store needs to be the same */
691 if (get_loop_size(lo
, file
) != get_loop_size(lo
, old_file
))
695 error
= loop_switch(lo
, file
);
708 static inline int is_loop_device(struct file
*file
)
710 struct inode
*i
= file
->f_mapping
->host
;
712 return i
&& S_ISBLK(i
->i_mode
) && MAJOR(i
->i_rdev
) == LOOP_MAJOR
;
715 static int loop_set_fd(struct loop_device
*lo
, struct file
*lo_file
,
716 struct block_device
*bdev
, unsigned int arg
)
718 struct file
*file
, *f
;
720 struct address_space
*mapping
;
721 unsigned lo_blocksize
;
726 /* This is safe, since we have a reference from open(). */
727 __module_get(THIS_MODULE
);
735 if (lo
->lo_state
!= Lo_unbound
)
738 /* Avoid recursion */
740 while (is_loop_device(f
)) {
741 struct loop_device
*l
;
743 if (f
->f_mapping
->host
->i_rdev
== lo_file
->f_mapping
->host
->i_rdev
)
746 l
= f
->f_mapping
->host
->i_bdev
->bd_disk
->private_data
;
747 if (l
->lo_state
== Lo_unbound
) {
751 f
= l
->lo_backing_file
;
754 mapping
= file
->f_mapping
;
755 inode
= mapping
->host
;
757 if (!(file
->f_mode
& FMODE_WRITE
))
758 lo_flags
|= LO_FLAGS_READ_ONLY
;
761 if (S_ISREG(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
762 const struct address_space_operations
*aops
= mapping
->a_ops
;
764 * If we can't read - sorry. If we only can't write - well,
765 * it's going to be read-only.
767 if (!file
->f_op
->sendfile
)
769 if (aops
->prepare_write
&& aops
->commit_write
)
770 lo_flags
|= LO_FLAGS_USE_AOPS
;
771 if (!(lo_flags
& LO_FLAGS_USE_AOPS
) && !file
->f_op
->write
)
772 lo_flags
|= LO_FLAGS_READ_ONLY
;
774 lo_blocksize
= S_ISBLK(inode
->i_mode
) ?
775 inode
->i_bdev
->bd_block_size
: PAGE_SIZE
;
782 size
= get_loop_size(lo
, file
);
784 if ((loff_t
)(sector_t
)size
!= size
) {
789 if (!(lo_file
->f_mode
& FMODE_WRITE
))
790 lo_flags
|= LO_FLAGS_READ_ONLY
;
792 set_device_ro(bdev
, (lo_flags
& LO_FLAGS_READ_ONLY
) != 0);
794 lo
->lo_blocksize
= lo_blocksize
;
795 lo
->lo_device
= bdev
;
796 lo
->lo_flags
= lo_flags
;
797 lo
->lo_backing_file
= file
;
798 lo
->transfer
= transfer_none
;
800 lo
->lo_sizelimit
= 0;
801 lo
->old_gfp_mask
= mapping_gfp_mask(mapping
);
802 mapping_set_gfp_mask(mapping
, lo
->old_gfp_mask
& ~(__GFP_IO
|__GFP_FS
));
804 lo
->lo_bio
= lo
->lo_biotail
= NULL
;
807 * set queue make_request_fn, and add limits based on lower level
810 blk_queue_make_request(lo
->lo_queue
, loop_make_request
);
811 lo
->lo_queue
->queuedata
= lo
;
812 lo
->lo_queue
->unplug_fn
= loop_unplug
;
814 set_capacity(lo
->lo_disk
, size
);
815 bd_set_size(bdev
, size
<< 9);
817 set_blocksize(bdev
, lo_blocksize
);
819 lo
->lo_thread
= kthread_create(loop_thread
, lo
, "loop%d",
821 if (IS_ERR(lo
->lo_thread
)) {
822 error
= PTR_ERR(lo
->lo_thread
);
825 lo
->lo_state
= Lo_bound
;
826 wake_up_process(lo
->lo_thread
);
830 lo
->lo_thread
= NULL
;
831 lo
->lo_device
= NULL
;
832 lo
->lo_backing_file
= NULL
;
834 set_capacity(lo
->lo_disk
, 0);
835 invalidate_bdev(bdev
);
836 bd_set_size(bdev
, 0);
837 mapping_set_gfp_mask(mapping
, lo
->old_gfp_mask
);
838 lo
->lo_state
= Lo_unbound
;
842 /* This is safe: open() is still holding a reference. */
843 module_put(THIS_MODULE
);
848 loop_release_xfer(struct loop_device
*lo
)
851 struct loop_func_table
*xfer
= lo
->lo_encryption
;
855 err
= xfer
->release(lo
);
857 lo
->lo_encryption
= NULL
;
858 module_put(xfer
->owner
);
864 loop_init_xfer(struct loop_device
*lo
, struct loop_func_table
*xfer
,
865 const struct loop_info64
*i
)
870 struct module
*owner
= xfer
->owner
;
872 if (!try_module_get(owner
))
875 err
= xfer
->init(lo
, i
);
879 lo
->lo_encryption
= xfer
;
884 static int loop_clr_fd(struct loop_device
*lo
, struct block_device
*bdev
)
886 struct file
*filp
= lo
->lo_backing_file
;
887 gfp_t gfp
= lo
->old_gfp_mask
;
889 if (lo
->lo_state
!= Lo_bound
)
892 if (lo
->lo_refcnt
> 1) /* we needed one fd for the ioctl */
898 spin_lock_irq(&lo
->lo_lock
);
899 lo
->lo_state
= Lo_rundown
;
900 spin_unlock_irq(&lo
->lo_lock
);
902 kthread_stop(lo
->lo_thread
);
904 lo
->lo_backing_file
= NULL
;
906 loop_release_xfer(lo
);
909 lo
->lo_device
= NULL
;
910 lo
->lo_encryption
= NULL
;
912 lo
->lo_sizelimit
= 0;
913 lo
->lo_encrypt_key_size
= 0;
915 lo
->lo_thread
= NULL
;
916 memset(lo
->lo_encrypt_key
, 0, LO_KEY_SIZE
);
917 memset(lo
->lo_crypt_name
, 0, LO_NAME_SIZE
);
918 memset(lo
->lo_file_name
, 0, LO_NAME_SIZE
);
919 invalidate_bdev(bdev
);
920 set_capacity(lo
->lo_disk
, 0);
921 bd_set_size(bdev
, 0);
922 mapping_set_gfp_mask(filp
->f_mapping
, gfp
);
923 lo
->lo_state
= Lo_unbound
;
925 /* This is safe: open() is still holding a reference. */
926 module_put(THIS_MODULE
);
931 loop_set_status(struct loop_device
*lo
, const struct loop_info64
*info
)
934 struct loop_func_table
*xfer
;
936 if (lo
->lo_encrypt_key_size
&& lo
->lo_key_owner
!= current
->uid
&&
937 !capable(CAP_SYS_ADMIN
))
939 if (lo
->lo_state
!= Lo_bound
)
941 if ((unsigned int) info
->lo_encrypt_key_size
> LO_KEY_SIZE
)
944 err
= loop_release_xfer(lo
);
948 if (info
->lo_encrypt_type
) {
949 unsigned int type
= info
->lo_encrypt_type
;
951 if (type
>= MAX_LO_CRYPT
)
953 xfer
= xfer_funcs
[type
];
959 err
= loop_init_xfer(lo
, xfer
, info
);
963 if (lo
->lo_offset
!= info
->lo_offset
||
964 lo
->lo_sizelimit
!= info
->lo_sizelimit
) {
965 lo
->lo_offset
= info
->lo_offset
;
966 lo
->lo_sizelimit
= info
->lo_sizelimit
;
967 if (figure_loop_size(lo
))
971 memcpy(lo
->lo_file_name
, info
->lo_file_name
, LO_NAME_SIZE
);
972 memcpy(lo
->lo_crypt_name
, info
->lo_crypt_name
, LO_NAME_SIZE
);
973 lo
->lo_file_name
[LO_NAME_SIZE
-1] = 0;
974 lo
->lo_crypt_name
[LO_NAME_SIZE
-1] = 0;
978 lo
->transfer
= xfer
->transfer
;
979 lo
->ioctl
= xfer
->ioctl
;
981 lo
->lo_encrypt_key_size
= info
->lo_encrypt_key_size
;
982 lo
->lo_init
[0] = info
->lo_init
[0];
983 lo
->lo_init
[1] = info
->lo_init
[1];
984 if (info
->lo_encrypt_key_size
) {
985 memcpy(lo
->lo_encrypt_key
, info
->lo_encrypt_key
,
986 info
->lo_encrypt_key_size
);
987 lo
->lo_key_owner
= current
->uid
;
994 loop_get_status(struct loop_device
*lo
, struct loop_info64
*info
)
996 struct file
*file
= lo
->lo_backing_file
;
1000 if (lo
->lo_state
!= Lo_bound
)
1002 error
= vfs_getattr(file
->f_path
.mnt
, file
->f_path
.dentry
, &stat
);
1005 memset(info
, 0, sizeof(*info
));
1006 info
->lo_number
= lo
->lo_number
;
1007 info
->lo_device
= huge_encode_dev(stat
.dev
);
1008 info
->lo_inode
= stat
.ino
;
1009 info
->lo_rdevice
= huge_encode_dev(lo
->lo_device
? stat
.rdev
: stat
.dev
);
1010 info
->lo_offset
= lo
->lo_offset
;
1011 info
->lo_sizelimit
= lo
->lo_sizelimit
;
1012 info
->lo_flags
= lo
->lo_flags
;
1013 memcpy(info
->lo_file_name
, lo
->lo_file_name
, LO_NAME_SIZE
);
1014 memcpy(info
->lo_crypt_name
, lo
->lo_crypt_name
, LO_NAME_SIZE
);
1015 info
->lo_encrypt_type
=
1016 lo
->lo_encryption
? lo
->lo_encryption
->number
: 0;
1017 if (lo
->lo_encrypt_key_size
&& capable(CAP_SYS_ADMIN
)) {
1018 info
->lo_encrypt_key_size
= lo
->lo_encrypt_key_size
;
1019 memcpy(info
->lo_encrypt_key
, lo
->lo_encrypt_key
,
1020 lo
->lo_encrypt_key_size
);
1026 loop_info64_from_old(const struct loop_info
*info
, struct loop_info64
*info64
)
1028 memset(info64
, 0, sizeof(*info64
));
1029 info64
->lo_number
= info
->lo_number
;
1030 info64
->lo_device
= info
->lo_device
;
1031 info64
->lo_inode
= info
->lo_inode
;
1032 info64
->lo_rdevice
= info
->lo_rdevice
;
1033 info64
->lo_offset
= info
->lo_offset
;
1034 info64
->lo_sizelimit
= 0;
1035 info64
->lo_encrypt_type
= info
->lo_encrypt_type
;
1036 info64
->lo_encrypt_key_size
= info
->lo_encrypt_key_size
;
1037 info64
->lo_flags
= info
->lo_flags
;
1038 info64
->lo_init
[0] = info
->lo_init
[0];
1039 info64
->lo_init
[1] = info
->lo_init
[1];
1040 if (info
->lo_encrypt_type
== LO_CRYPT_CRYPTOAPI
)
1041 memcpy(info64
->lo_crypt_name
, info
->lo_name
, LO_NAME_SIZE
);
1043 memcpy(info64
->lo_file_name
, info
->lo_name
, LO_NAME_SIZE
);
1044 memcpy(info64
->lo_encrypt_key
, info
->lo_encrypt_key
, LO_KEY_SIZE
);
1048 loop_info64_to_old(const struct loop_info64
*info64
, struct loop_info
*info
)
1050 memset(info
, 0, sizeof(*info
));
1051 info
->lo_number
= info64
->lo_number
;
1052 info
->lo_device
= info64
->lo_device
;
1053 info
->lo_inode
= info64
->lo_inode
;
1054 info
->lo_rdevice
= info64
->lo_rdevice
;
1055 info
->lo_offset
= info64
->lo_offset
;
1056 info
->lo_encrypt_type
= info64
->lo_encrypt_type
;
1057 info
->lo_encrypt_key_size
= info64
->lo_encrypt_key_size
;
1058 info
->lo_flags
= info64
->lo_flags
;
1059 info
->lo_init
[0] = info64
->lo_init
[0];
1060 info
->lo_init
[1] = info64
->lo_init
[1];
1061 if (info
->lo_encrypt_type
== LO_CRYPT_CRYPTOAPI
)
1062 memcpy(info
->lo_name
, info64
->lo_crypt_name
, LO_NAME_SIZE
);
1064 memcpy(info
->lo_name
, info64
->lo_file_name
, LO_NAME_SIZE
);
1065 memcpy(info
->lo_encrypt_key
, info64
->lo_encrypt_key
, LO_KEY_SIZE
);
1067 /* error in case values were truncated */
1068 if (info
->lo_device
!= info64
->lo_device
||
1069 info
->lo_rdevice
!= info64
->lo_rdevice
||
1070 info
->lo_inode
!= info64
->lo_inode
||
1071 info
->lo_offset
!= info64
->lo_offset
)
1078 loop_set_status_old(struct loop_device
*lo
, const struct loop_info __user
*arg
)
1080 struct loop_info info
;
1081 struct loop_info64 info64
;
1083 if (copy_from_user(&info
, arg
, sizeof (struct loop_info
)))
1085 loop_info64_from_old(&info
, &info64
);
1086 return loop_set_status(lo
, &info64
);
1090 loop_set_status64(struct loop_device
*lo
, const struct loop_info64 __user
*arg
)
1092 struct loop_info64 info64
;
1094 if (copy_from_user(&info64
, arg
, sizeof (struct loop_info64
)))
1096 return loop_set_status(lo
, &info64
);
1100 loop_get_status_old(struct loop_device
*lo
, struct loop_info __user
*arg
) {
1101 struct loop_info info
;
1102 struct loop_info64 info64
;
1108 err
= loop_get_status(lo
, &info64
);
1110 err
= loop_info64_to_old(&info64
, &info
);
1111 if (!err
&& copy_to_user(arg
, &info
, sizeof(info
)))
1118 loop_get_status64(struct loop_device
*lo
, struct loop_info64 __user
*arg
) {
1119 struct loop_info64 info64
;
1125 err
= loop_get_status(lo
, &info64
);
1126 if (!err
&& copy_to_user(arg
, &info64
, sizeof(info64
)))
1132 static int lo_ioctl(struct inode
* inode
, struct file
* file
,
1133 unsigned int cmd
, unsigned long arg
)
1135 struct loop_device
*lo
= inode
->i_bdev
->bd_disk
->private_data
;
1138 mutex_lock(&lo
->lo_ctl_mutex
);
1141 err
= loop_set_fd(lo
, file
, inode
->i_bdev
, arg
);
1143 case LOOP_CHANGE_FD
:
1144 err
= loop_change_fd(lo
, file
, inode
->i_bdev
, arg
);
1147 err
= loop_clr_fd(lo
, inode
->i_bdev
);
1149 case LOOP_SET_STATUS
:
1150 err
= loop_set_status_old(lo
, (struct loop_info __user
*) arg
);
1152 case LOOP_GET_STATUS
:
1153 err
= loop_get_status_old(lo
, (struct loop_info __user
*) arg
);
1155 case LOOP_SET_STATUS64
:
1156 err
= loop_set_status64(lo
, (struct loop_info64 __user
*) arg
);
1158 case LOOP_GET_STATUS64
:
1159 err
= loop_get_status64(lo
, (struct loop_info64 __user
*) arg
);
1162 err
= lo
->ioctl
? lo
->ioctl(lo
, cmd
, arg
) : -EINVAL
;
1164 mutex_unlock(&lo
->lo_ctl_mutex
);
1168 #ifdef CONFIG_COMPAT
1169 struct compat_loop_info
{
1170 compat_int_t lo_number
; /* ioctl r/o */
1171 compat_dev_t lo_device
; /* ioctl r/o */
1172 compat_ulong_t lo_inode
; /* ioctl r/o */
1173 compat_dev_t lo_rdevice
; /* ioctl r/o */
1174 compat_int_t lo_offset
;
1175 compat_int_t lo_encrypt_type
;
1176 compat_int_t lo_encrypt_key_size
; /* ioctl w/o */
1177 compat_int_t lo_flags
; /* ioctl r/o */
1178 char lo_name
[LO_NAME_SIZE
];
1179 unsigned char lo_encrypt_key
[LO_KEY_SIZE
]; /* ioctl w/o */
1180 compat_ulong_t lo_init
[2];
1185 * Transfer 32-bit compatibility structure in userspace to 64-bit loop info
1186 * - noinlined to reduce stack space usage in main part of driver
1189 loop_info64_from_compat(const struct compat_loop_info __user
*arg
,
1190 struct loop_info64
*info64
)
1192 struct compat_loop_info info
;
1194 if (copy_from_user(&info
, arg
, sizeof(info
)))
1197 memset(info64
, 0, sizeof(*info64
));
1198 info64
->lo_number
= info
.lo_number
;
1199 info64
->lo_device
= info
.lo_device
;
1200 info64
->lo_inode
= info
.lo_inode
;
1201 info64
->lo_rdevice
= info
.lo_rdevice
;
1202 info64
->lo_offset
= info
.lo_offset
;
1203 info64
->lo_sizelimit
= 0;
1204 info64
->lo_encrypt_type
= info
.lo_encrypt_type
;
1205 info64
->lo_encrypt_key_size
= info
.lo_encrypt_key_size
;
1206 info64
->lo_flags
= info
.lo_flags
;
1207 info64
->lo_init
[0] = info
.lo_init
[0];
1208 info64
->lo_init
[1] = info
.lo_init
[1];
1209 if (info
.lo_encrypt_type
== LO_CRYPT_CRYPTOAPI
)
1210 memcpy(info64
->lo_crypt_name
, info
.lo_name
, LO_NAME_SIZE
);
1212 memcpy(info64
->lo_file_name
, info
.lo_name
, LO_NAME_SIZE
);
1213 memcpy(info64
->lo_encrypt_key
, info
.lo_encrypt_key
, LO_KEY_SIZE
);
1218 * Transfer 64-bit loop info to 32-bit compatibility structure in userspace
1219 * - noinlined to reduce stack space usage in main part of driver
1222 loop_info64_to_compat(const struct loop_info64
*info64
,
1223 struct compat_loop_info __user
*arg
)
1225 struct compat_loop_info info
;
1227 memset(&info
, 0, sizeof(info
));
1228 info
.lo_number
= info64
->lo_number
;
1229 info
.lo_device
= info64
->lo_device
;
1230 info
.lo_inode
= info64
->lo_inode
;
1231 info
.lo_rdevice
= info64
->lo_rdevice
;
1232 info
.lo_offset
= info64
->lo_offset
;
1233 info
.lo_encrypt_type
= info64
->lo_encrypt_type
;
1234 info
.lo_encrypt_key_size
= info64
->lo_encrypt_key_size
;
1235 info
.lo_flags
= info64
->lo_flags
;
1236 info
.lo_init
[0] = info64
->lo_init
[0];
1237 info
.lo_init
[1] = info64
->lo_init
[1];
1238 if (info
.lo_encrypt_type
== LO_CRYPT_CRYPTOAPI
)
1239 memcpy(info
.lo_name
, info64
->lo_crypt_name
, LO_NAME_SIZE
);
1241 memcpy(info
.lo_name
, info64
->lo_file_name
, LO_NAME_SIZE
);
1242 memcpy(info
.lo_encrypt_key
, info64
->lo_encrypt_key
, LO_KEY_SIZE
);
1244 /* error in case values were truncated */
1245 if (info
.lo_device
!= info64
->lo_device
||
1246 info
.lo_rdevice
!= info64
->lo_rdevice
||
1247 info
.lo_inode
!= info64
->lo_inode
||
1248 info
.lo_offset
!= info64
->lo_offset
||
1249 info
.lo_init
[0] != info64
->lo_init
[0] ||
1250 info
.lo_init
[1] != info64
->lo_init
[1])
1253 if (copy_to_user(arg
, &info
, sizeof(info
)))
1259 loop_set_status_compat(struct loop_device
*lo
,
1260 const struct compat_loop_info __user
*arg
)
1262 struct loop_info64 info64
;
1265 ret
= loop_info64_from_compat(arg
, &info64
);
1268 return loop_set_status(lo
, &info64
);
1272 loop_get_status_compat(struct loop_device
*lo
,
1273 struct compat_loop_info __user
*arg
)
1275 struct loop_info64 info64
;
1281 err
= loop_get_status(lo
, &info64
);
1283 err
= loop_info64_to_compat(&info64
, arg
);
1287 static long lo_compat_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
1289 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1290 struct loop_device
*lo
= inode
->i_bdev
->bd_disk
->private_data
;
1295 case LOOP_SET_STATUS
:
1296 mutex_lock(&lo
->lo_ctl_mutex
);
1297 err
= loop_set_status_compat(
1298 lo
, (const struct compat_loop_info __user
*) arg
);
1299 mutex_unlock(&lo
->lo_ctl_mutex
);
1301 case LOOP_GET_STATUS
:
1302 mutex_lock(&lo
->lo_ctl_mutex
);
1303 err
= loop_get_status_compat(
1304 lo
, (struct compat_loop_info __user
*) arg
);
1305 mutex_unlock(&lo
->lo_ctl_mutex
);
1308 case LOOP_GET_STATUS64
:
1309 case LOOP_SET_STATUS64
:
1310 arg
= (unsigned long) compat_ptr(arg
);
1312 case LOOP_CHANGE_FD
:
1313 err
= lo_ioctl(inode
, file
, cmd
, arg
);
1324 static struct loop_device
*loop_find_dev(int number
)
1326 struct loop_device
*lo
;
1328 list_for_each_entry(lo
, &loop_devices
, lo_list
) {
1329 if (lo
->lo_number
== number
)
1335 static struct loop_device
*loop_init_one(int i
);
1336 static int lo_open(struct inode
*inode
, struct file
*file
)
1338 struct loop_device
*lo
= inode
->i_bdev
->bd_disk
->private_data
;
1340 mutex_lock(&lo
->lo_ctl_mutex
);
1342 mutex_unlock(&lo
->lo_ctl_mutex
);
1344 mutex_lock(&loop_devices_mutex
);
1345 if (!loop_find_dev(lo
->lo_number
+ 1))
1346 loop_init_one(lo
->lo_number
+ 1);
1347 mutex_unlock(&loop_devices_mutex
);
1352 static int lo_release(struct inode
*inode
, struct file
*file
)
1354 struct loop_device
*lo
= inode
->i_bdev
->bd_disk
->private_data
;
1356 mutex_lock(&lo
->lo_ctl_mutex
);
1358 mutex_unlock(&lo
->lo_ctl_mutex
);
1363 static struct block_device_operations lo_fops
= {
1364 .owner
= THIS_MODULE
,
1366 .release
= lo_release
,
1368 #ifdef CONFIG_COMPAT
1369 .compat_ioctl
= lo_compat_ioctl
,
1374 * And now the modules code and kernel interface.
1376 static int max_loop
;
1377 module_param(max_loop
, int, 0);
1378 MODULE_PARM_DESC(max_loop
, "obsolete, loop device is created on-demand");
1379 MODULE_LICENSE("GPL");
1380 MODULE_ALIAS_BLOCKDEV_MAJOR(LOOP_MAJOR
);
1382 int loop_register_transfer(struct loop_func_table
*funcs
)
1384 unsigned int n
= funcs
->number
;
1386 if (n
>= MAX_LO_CRYPT
|| xfer_funcs
[n
])
1388 xfer_funcs
[n
] = funcs
;
1392 int loop_unregister_transfer(int number
)
1394 unsigned int n
= number
;
1395 struct loop_device
*lo
;
1396 struct loop_func_table
*xfer
;
1398 if (n
== 0 || n
>= MAX_LO_CRYPT
|| (xfer
= xfer_funcs
[n
]) == NULL
)
1401 xfer_funcs
[n
] = NULL
;
1403 list_for_each_entry(lo
, &loop_devices
, lo_list
) {
1404 mutex_lock(&lo
->lo_ctl_mutex
);
1406 if (lo
->lo_encryption
== xfer
)
1407 loop_release_xfer(lo
);
1409 mutex_unlock(&lo
->lo_ctl_mutex
);
1415 EXPORT_SYMBOL(loop_register_transfer
);
1416 EXPORT_SYMBOL(loop_unregister_transfer
);
1418 static struct loop_device
*loop_init_one(int i
)
1420 struct loop_device
*lo
;
1421 struct gendisk
*disk
;
1423 lo
= kzalloc(sizeof(*lo
), GFP_KERNEL
);
1427 lo
->lo_queue
= blk_alloc_queue(GFP_KERNEL
);
1431 disk
= lo
->lo_disk
= alloc_disk(1);
1433 goto out_free_queue
;
1435 mutex_init(&lo
->lo_ctl_mutex
);
1437 lo
->lo_thread
= NULL
;
1438 init_waitqueue_head(&lo
->lo_event
);
1439 spin_lock_init(&lo
->lo_lock
);
1440 disk
->major
= LOOP_MAJOR
;
1441 disk
->first_minor
= i
;
1442 disk
->fops
= &lo_fops
;
1443 disk
->private_data
= lo
;
1444 disk
->queue
= lo
->lo_queue
;
1445 sprintf(disk
->disk_name
, "loop%d", i
);
1447 list_add_tail(&lo
->lo_list
, &loop_devices
);
1451 blk_cleanup_queue(lo
->lo_queue
);
1455 return ERR_PTR(-ENOMEM
);
1458 static void loop_del_one(struct loop_device
*lo
)
1460 del_gendisk(lo
->lo_disk
);
1461 blk_cleanup_queue(lo
->lo_queue
);
1462 put_disk(lo
->lo_disk
);
1463 list_del(&lo
->lo_list
);
1467 static struct kobject
*loop_probe(dev_t dev
, int *part
, void *data
)
1469 unsigned int number
= dev
& MINORMASK
;
1470 struct loop_device
*lo
;
1472 mutex_lock(&loop_devices_mutex
);
1473 lo
= loop_find_dev(number
);
1475 lo
= loop_init_one(number
);
1476 mutex_unlock(&loop_devices_mutex
);
1482 return &lo
->lo_disk
->kobj
;
1485 static int __init
loop_init(void)
1487 struct loop_device
*lo
;
1489 if (register_blkdev(LOOP_MAJOR
, "loop"))
1491 blk_register_region(MKDEV(LOOP_MAJOR
, 0), 1UL << MINORBITS
,
1492 THIS_MODULE
, loop_probe
, NULL
, NULL
);
1494 lo
= loop_init_one(0);
1499 printk(KERN_INFO
"loop: the max_loop option is obsolete "
1500 "and will be removed in March 2008\n");
1503 printk(KERN_INFO
"loop: module loaded\n");
1507 unregister_blkdev(LOOP_MAJOR
, "loop");
1508 printk(KERN_ERR
"loop: ran out of memory\n");
1512 static void __exit
loop_exit(void)
1514 struct loop_device
*lo
, *next
;
1516 list_for_each_entry_safe(lo
, next
, &loop_devices
, lo_list
)
1519 blk_unregister_region(MKDEV(LOOP_MAJOR
, 0), 1UL << MINORBITS
);
1520 if (unregister_blkdev(LOOP_MAJOR
, "loop"))
1521 printk(KERN_WARNING
"loop: cannot unregister blkdev\n");
1524 module_init(loop_init
);
1525 module_exit(loop_exit
);
1528 static int __init
max_loop_setup(char *str
)
1530 max_loop
= simple_strtol(str
, NULL
, 0);
1534 __setup("max_loop=", max_loop_setup
);