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
43 * - Advisory locking is ignored here.
44 * - Should use an own CAP_* category instead of CAP_SYS_ADMIN
48 #include <linux/config.h>
49 #include <linux/module.h>
51 #include <linux/sched.h>
53 #include <linux/file.h>
54 #include <linux/stat.h>
55 #include <linux/errno.h>
56 #include <linux/major.h>
57 #include <linux/wait.h>
58 #include <linux/blkpg.h>
59 #include <linux/init.h>
60 #include <linux/devfs_fs_kernel.h>
61 #include <linux/smp_lock.h>
62 #include <linux/swap.h>
63 #include <linux/slab.h>
64 #include <linux/loop.h>
65 #include <linux/suspend.h>
66 #include <linux/writeback.h>
67 #include <linux/buffer_head.h> /* for invalidate_bdev() */
69 #include <asm/uaccess.h>
71 static int max_loop
= 8;
72 static struct loop_device
*loop_dev
;
73 static struct gendisk
**disks
;
78 static int transfer_none(struct loop_device
*lo
, int cmd
, char *raw_buf
,
79 char *loop_buf
, int size
, sector_t real_block
)
81 if (raw_buf
!= loop_buf
) {
83 memcpy(loop_buf
, raw_buf
, size
);
85 memcpy(raw_buf
, loop_buf
, size
);
91 static int transfer_xor(struct loop_device
*lo
, int cmd
, char *raw_buf
,
92 char *loop_buf
, int size
, sector_t real_block
)
105 key
= lo
->lo_encrypt_key
;
106 keysize
= lo
->lo_encrypt_key_size
;
107 for (i
= 0; i
< size
; i
++)
108 *out
++ = *in
++ ^ key
[(i
& 511) % keysize
];
112 static int xor_init(struct loop_device
*lo
, const struct loop_info64
*info
)
114 if (info
->lo_encrypt_key_size
<= 0)
119 static struct loop_func_table none_funcs
= {
120 .number
= LO_CRYPT_NONE
,
121 .transfer
= transfer_none
,
124 static struct loop_func_table xor_funcs
= {
125 .number
= LO_CRYPT_XOR
,
126 .transfer
= transfer_xor
,
130 /* xfer_funcs[0] is special - its release function is never called */
131 static struct loop_func_table
*xfer_funcs
[MAX_LO_CRYPT
] = {
137 figure_loop_size(struct loop_device
*lo
)
139 loff_t size
, offset
, loopsize
;
142 /* Compute loopsize in bytes */
143 size
= i_size_read(lo
->lo_backing_file
->f_dentry
->
144 d_inode
->i_mapping
->host
);
145 offset
= lo
->lo_offset
;
146 loopsize
= size
- offset
;
147 if (lo
->lo_sizelimit
> 0 && lo
->lo_sizelimit
< loopsize
)
148 loopsize
= lo
->lo_sizelimit
;
151 * Unfortunately, if we want to do I/O on the device,
152 * the number of 512-byte sectors has to fit into a sector_t.
154 size
= loopsize
>> 9;
157 if ((loff_t
)x
!= size
)
160 set_capacity(disks
[lo
->lo_number
], x
);
165 lo_do_transfer(struct loop_device
*lo
, int cmd
, char *rbuf
,
166 char *lbuf
, int size
, sector_t rblock
)
171 return lo
->transfer(lo
, cmd
, rbuf
, lbuf
, size
, rblock
);
175 do_lo_send(struct loop_device
*lo
, struct bio_vec
*bvec
, int bsize
, loff_t pos
)
177 struct file
*file
= lo
->lo_backing_file
; /* kudos to NFsckingS */
178 struct address_space
*mapping
= file
->f_dentry
->d_inode
->i_mapping
;
179 struct address_space_operations
*aops
= mapping
->a_ops
;
183 unsigned size
, offset
;
187 down(&mapping
->host
->i_sem
);
188 index
= pos
>> PAGE_CACHE_SHIFT
;
189 offset
= pos
& ((pgoff_t
)PAGE_CACHE_SIZE
- 1);
190 data
= kmap(bvec
->bv_page
) + bvec
->bv_offset
;
196 IV
= ((sector_t
)index
<< (PAGE_CACHE_SHIFT
- 9))+(offset
>> 9);
198 size
= PAGE_CACHE_SIZE
- offset
;
202 page
= grab_cache_page(mapping
, index
);
205 if (aops
->prepare_write(file
, page
, offset
, offset
+size
))
208 transfer_result
= lo_do_transfer(lo
, WRITE
, kaddr
+ offset
,
210 if (transfer_result
) {
212 * The transfer failed, but we still write the data to
213 * keep prepare/commit calls balanced.
215 printk(KERN_ERR
"loop: transfer error block %llu\n",
216 (unsigned long long)index
);
217 memset(kaddr
+ offset
, 0, size
);
219 flush_dcache_page(page
);
221 if (aops
->commit_write(file
, page
, offset
, offset
+size
))
231 page_cache_release(page
);
233 up(&mapping
->host
->i_sem
);
235 kunmap(bvec
->bv_page
);
240 page_cache_release(page
);
242 up(&mapping
->host
->i_sem
);
248 lo_send(struct loop_device
*lo
, struct bio
*bio
, int bsize
, loff_t pos
)
253 for (vecnr
= 0; vecnr
< bio
->bi_vcnt
; vecnr
++) {
254 struct bio_vec
*bvec
= &bio
->bi_io_vec
[vecnr
];
256 ret
= do_lo_send(lo
, bvec
, bsize
, pos
);
264 struct lo_read_data
{
265 struct loop_device
*lo
;
271 lo_read_actor(read_descriptor_t
*desc
, struct page
*page
,
272 unsigned long offset
, unsigned long size
)
275 unsigned long count
= desc
->count
;
276 struct lo_read_data
*p
= (struct lo_read_data
*)desc
->buf
;
277 struct loop_device
*lo
= p
->lo
;
280 IV
= ((sector_t
) page
->index
<< (PAGE_CACHE_SHIFT
- 9))+(offset
>> 9);
286 if (lo_do_transfer(lo
, READ
, kaddr
+ offset
, p
->data
, size
, IV
)) {
288 printk(KERN_ERR
"loop: transfer error block %ld\n",
290 desc
->error
= -EINVAL
;
294 desc
->count
= count
- size
;
295 desc
->written
+= size
;
301 do_lo_receive(struct loop_device
*lo
,
302 struct bio_vec
*bvec
, int bsize
, loff_t pos
)
304 struct lo_read_data cookie
;
309 cookie
.data
= kmap(bvec
->bv_page
) + bvec
->bv_offset
;
310 cookie
.bsize
= bsize
;
311 file
= lo
->lo_backing_file
;
312 retval
= file
->f_op
->sendfile(file
, &pos
, bvec
->bv_len
,
313 lo_read_actor
, &cookie
);
314 kunmap(bvec
->bv_page
);
315 return (retval
< 0)? retval
: 0;
319 lo_receive(struct loop_device
*lo
, struct bio
*bio
, int bsize
, loff_t pos
)
324 for (vecnr
= 0; vecnr
< bio
->bi_vcnt
; vecnr
++) {
325 struct bio_vec
*bvec
= &bio
->bi_io_vec
[vecnr
];
327 ret
= do_lo_receive(lo
, bvec
, bsize
, pos
);
335 static int do_bio_filebacked(struct loop_device
*lo
, struct bio
*bio
)
340 pos
= ((loff_t
) bio
->bi_sector
<< 9) + lo
->lo_offset
;
341 if (bio_rw(bio
) == WRITE
)
342 ret
= lo_send(lo
, bio
, lo
->lo_blocksize
, pos
);
344 ret
= lo_receive(lo
, bio
, lo
->lo_blocksize
, pos
);
348 static int loop_end_io_transfer(struct bio
*, unsigned int, int);
350 static void loop_put_buffer(struct bio
*bio
)
353 * check bi_end_io, may just be a remapped bio
355 if (bio
&& bio
->bi_end_io
== loop_end_io_transfer
) {
358 for (i
= 0; i
< bio
->bi_vcnt
; i
++)
359 __free_page(bio
->bi_io_vec
[i
].bv_page
);
366 * Add bio to back of pending list
368 static void loop_add_bio(struct loop_device
*lo
, struct bio
*bio
)
372 spin_lock_irqsave(&lo
->lo_lock
, flags
);
373 if (lo
->lo_biotail
) {
374 lo
->lo_biotail
->bi_next
= bio
;
375 lo
->lo_biotail
= bio
;
377 lo
->lo_bio
= lo
->lo_biotail
= bio
;
378 spin_unlock_irqrestore(&lo
->lo_lock
, flags
);
380 up(&lo
->lo_bh_mutex
);
384 * Grab first pending buffer
386 static struct bio
*loop_get_bio(struct loop_device
*lo
)
390 spin_lock_irq(&lo
->lo_lock
);
391 if ((bio
= lo
->lo_bio
)) {
392 if (bio
== lo
->lo_biotail
)
393 lo
->lo_biotail
= NULL
;
394 lo
->lo_bio
= bio
->bi_next
;
397 spin_unlock_irq(&lo
->lo_lock
);
403 * if this was a WRITE lo->transfer stuff has already been done. for READs,
404 * queue it for the loop thread and let it do the transfer out of
405 * bi_end_io context (we don't want to do decrypt of a page with irqs
408 static int loop_end_io_transfer(struct bio
*bio
, unsigned int bytes_done
, int err
)
410 struct bio
*rbh
= bio
->bi_private
;
411 struct loop_device
*lo
= rbh
->bi_bdev
->bd_disk
->private_data
;
416 if (err
|| bio_rw(bio
) == WRITE
) {
417 bio_endio(rbh
, rbh
->bi_size
, err
);
418 if (atomic_dec_and_test(&lo
->lo_pending
))
419 up(&lo
->lo_bh_mutex
);
420 loop_put_buffer(bio
);
422 loop_add_bio(lo
, bio
);
427 static struct bio
*loop_copy_bio(struct bio
*rbh
)
433 bio
= bio_alloc(__GFP_NOWARN
, rbh
->bi_vcnt
);
438 * iterate iovec list and alloc pages
440 __bio_for_each_segment(bv
, rbh
, i
, 0) {
441 struct bio_vec
*bbv
= &bio
->bi_io_vec
[i
];
443 bbv
->bv_page
= alloc_page(__GFP_NOWARN
|__GFP_HIGHMEM
);
444 if (bbv
->bv_page
== NULL
)
447 bbv
->bv_len
= bv
->bv_len
;
448 bbv
->bv_offset
= bv
->bv_offset
;
451 bio
->bi_vcnt
= rbh
->bi_vcnt
;
452 bio
->bi_size
= rbh
->bi_size
;
458 __free_page(bio
->bi_io_vec
[i
].bv_page
);
464 static struct bio
*loop_get_buffer(struct loop_device
*lo
, struct bio
*rbh
)
469 * When called on the page reclaim -> writepage path, this code can
470 * trivially consume all memory. So we drop PF_MEMALLOC to avoid
471 * stealing all the page reserves and throttle to the writeout rate.
472 * pdflush will have been woken by page reclaim. Let it do its work.
475 int flags
= current
->flags
;
477 current
->flags
&= ~PF_MEMALLOC
;
478 bio
= loop_copy_bio(rbh
);
479 if (flags
& PF_MEMALLOC
)
480 current
->flags
|= PF_MEMALLOC
;
483 blk_congestion_wait(WRITE
, HZ
/10);
484 } while (bio
== NULL
);
486 bio
->bi_end_io
= loop_end_io_transfer
;
487 bio
->bi_private
= rbh
;
488 bio
->bi_sector
= rbh
->bi_sector
+ (lo
->lo_offset
>> 9);
489 bio
->bi_rw
= rbh
->bi_rw
;
490 bio
->bi_bdev
= lo
->lo_device
;
495 static int loop_transfer_bio(struct loop_device
*lo
,
496 struct bio
*to_bio
, struct bio
*from_bio
)
499 struct bio_vec
*from_bvec
, *to_bvec
;
503 IV
= from_bio
->bi_sector
+ (lo
->lo_offset
>> 9);
505 __bio_for_each_segment(from_bvec
, from_bio
, i
, 0) {
506 to_bvec
= &to_bio
->bi_io_vec
[i
];
508 kmap(from_bvec
->bv_page
);
509 kmap(to_bvec
->bv_page
);
510 vfrom
= page_address(from_bvec
->bv_page
) + from_bvec
->bv_offset
;
511 vto
= page_address(to_bvec
->bv_page
) + to_bvec
->bv_offset
;
512 ret
|= lo_do_transfer(lo
, bio_data_dir(to_bio
), vto
, vfrom
,
513 from_bvec
->bv_len
, IV
);
514 kunmap(from_bvec
->bv_page
);
515 kunmap(to_bvec
->bv_page
);
516 IV
+= from_bvec
->bv_len
>> 9;
522 static int loop_make_request(request_queue_t
*q
, struct bio
*old_bio
)
524 struct bio
*new_bio
= NULL
;
525 struct loop_device
*lo
= q
->queuedata
;
526 int rw
= bio_rw(old_bio
);
531 spin_lock_irq(&lo
->lo_lock
);
532 if (lo
->lo_state
!= Lo_bound
)
534 atomic_inc(&lo
->lo_pending
);
535 spin_unlock_irq(&lo
->lo_lock
);
538 if (lo
->lo_flags
& LO_FLAGS_READ_ONLY
)
540 } else if (rw
== READA
) {
542 } else if (rw
!= READ
) {
543 printk(KERN_ERR
"loop: unknown command (%x)\n", rw
);
548 * file backed, queue for loop_thread to handle
550 if (lo
->lo_flags
& LO_FLAGS_DO_BMAP
) {
551 loop_add_bio(lo
, old_bio
);
556 * piggy old buffer on original, and submit for I/O
558 new_bio
= loop_get_buffer(lo
, old_bio
);
560 if (loop_transfer_bio(lo
, new_bio
, old_bio
))
564 generic_make_request(new_bio
);
568 if (atomic_dec_and_test(&lo
->lo_pending
))
569 up(&lo
->lo_bh_mutex
);
570 loop_put_buffer(new_bio
);
572 bio_io_error(old_bio
, old_bio
->bi_size
);
575 spin_unlock_irq(&lo
->lo_lock
);
579 static inline void loop_handle_bio(struct loop_device
*lo
, struct bio
*bio
)
584 * For block backed loop, we know this is a READ
586 if (lo
->lo_flags
& LO_FLAGS_DO_BMAP
) {
587 ret
= do_bio_filebacked(lo
, bio
);
588 bio_endio(bio
, bio
->bi_size
, ret
);
590 struct bio
*rbh
= bio
->bi_private
;
592 ret
= loop_transfer_bio(lo
, bio
, rbh
);
594 bio_endio(rbh
, rbh
->bi_size
, ret
);
595 loop_put_buffer(bio
);
600 * worker thread that handles reads/writes to file backed loop devices,
601 * to avoid blocking in our make_request_fn. it also does loop decrypting
602 * on reads for block backed loop, as that is too heavy to do from
603 * b_end_io context where irqs may be disabled.
605 static int loop_thread(void *data
)
607 struct loop_device
*lo
= data
;
610 daemonize("loop%d", lo
->lo_number
);
613 * loop can be used in an encrypted device,
614 * hence, it mustn't be stopped at all
615 * because it could be indirectly used during suspension
617 current
->flags
|= PF_IOTHREAD
;
619 set_user_nice(current
, -20);
621 lo
->lo_state
= Lo_bound
;
622 atomic_inc(&lo
->lo_pending
);
625 * up sem, we are running
630 down_interruptible(&lo
->lo_bh_mutex
);
632 * could be upped because of tear-down, not because of
635 if (!atomic_read(&lo
->lo_pending
))
638 bio
= loop_get_bio(lo
);
640 printk("loop: missing bio\n");
643 loop_handle_bio(lo
, bio
);
646 * upped both for pending work and tear-down, lo_pending
649 if (atomic_dec_and_test(&lo
->lo_pending
))
657 static int loop_set_fd(struct loop_device
*lo
, struct file
*lo_file
,
658 struct block_device
*bdev
, unsigned int arg
)
662 struct block_device
*lo_device
= NULL
;
663 unsigned lo_blocksize
;
667 /* This is safe, since we have a reference from open(). */
668 __module_get(THIS_MODULE
);
671 if (lo
->lo_state
!= Lo_unbound
)
680 inode
= file
->f_dentry
->d_inode
;
682 if (!(file
->f_mode
& FMODE_WRITE
))
683 lo_flags
|= LO_FLAGS_READ_ONLY
;
685 if (S_ISBLK(inode
->i_mode
)) {
686 lo_device
= inode
->i_bdev
;
687 if (lo_device
== bdev
) {
691 lo_blocksize
= block_size(lo_device
);
692 if (bdev_read_only(lo_device
))
693 lo_flags
|= LO_FLAGS_READ_ONLY
;
694 } else if (S_ISREG(inode
->i_mode
)) {
695 struct address_space_operations
*aops
= inode
->i_mapping
->a_ops
;
697 * If we can't read - sorry. If we only can't write - well,
698 * it's going to be read-only.
700 if (!inode
->i_fop
->sendfile
)
703 if (!aops
->prepare_write
|| !aops
->commit_write
)
704 lo_flags
|= LO_FLAGS_READ_ONLY
;
706 lo_blocksize
= inode
->i_blksize
;
707 lo_flags
|= LO_FLAGS_DO_BMAP
;
714 if (!(lo_file
->f_mode
& FMODE_WRITE
))
715 lo_flags
|= LO_FLAGS_READ_ONLY
;
717 set_device_ro(bdev
, (lo_flags
& LO_FLAGS_READ_ONLY
) != 0);
719 lo
->lo_blocksize
= lo_blocksize
;
720 lo
->lo_device
= lo_device
;
721 lo
->lo_flags
= lo_flags
;
722 lo
->lo_backing_file
= file
;
725 lo
->lo_sizelimit
= 0;
726 if (figure_loop_size(lo
)) {
731 lo
->old_gfp_mask
= mapping_gfp_mask(inode
->i_mapping
);
732 mapping_set_gfp_mask(inode
->i_mapping
,
733 lo
->old_gfp_mask
& ~(__GFP_IO
|__GFP_FS
));
735 set_blocksize(bdev
, lo_blocksize
);
737 lo
->lo_bio
= lo
->lo_biotail
= NULL
;
740 * set queue make_request_fn, and add limits based on lower level
743 blk_queue_make_request(lo
->lo_queue
, loop_make_request
);
744 lo
->lo_queue
->queuedata
= lo
;
747 * we remap to a block device, make sure we correctly stack limits
749 if (S_ISBLK(inode
->i_mode
)) {
750 request_queue_t
*q
= bdev_get_queue(lo_device
);
752 blk_queue_max_sectors(lo
->lo_queue
, q
->max_sectors
);
753 blk_queue_max_phys_segments(lo
->lo_queue
,q
->max_phys_segments
);
754 blk_queue_max_hw_segments(lo
->lo_queue
, q
->max_hw_segments
);
755 blk_queue_max_segment_size(lo
->lo_queue
, q
->max_segment_size
);
756 blk_queue_segment_boundary(lo
->lo_queue
, q
->seg_boundary_mask
);
757 blk_queue_merge_bvec(lo
->lo_queue
, q
->merge_bvec_fn
);
760 kernel_thread(loop_thread
, lo
, CLONE_KERNEL
);
769 /* This is safe: open() is still holding a reference. */
770 module_put(THIS_MODULE
);
775 loop_release_xfer(struct loop_device
*lo
)
778 struct loop_func_table
*xfer
= lo
->lo_encryption
;
782 err
= xfer
->release(lo
);
784 lo
->lo_encryption
= NULL
;
785 module_put(xfer
->owner
);
791 loop_init_xfer(struct loop_device
*lo
, struct loop_func_table
*xfer
,
792 const struct loop_info64
*i
)
797 struct module
*owner
= xfer
->owner
;
799 if (!try_module_get(owner
))
802 err
= xfer
->init(lo
, i
);
806 lo
->lo_encryption
= xfer
;
811 static int loop_clr_fd(struct loop_device
*lo
, struct block_device
*bdev
)
813 struct file
*filp
= lo
->lo_backing_file
;
814 int gfp
= lo
->old_gfp_mask
;
816 if (lo
->lo_state
!= Lo_bound
)
819 if (lo
->lo_refcnt
> 1) /* we needed one fd for the ioctl */
825 spin_lock_irq(&lo
->lo_lock
);
826 lo
->lo_state
= Lo_rundown
;
827 if (atomic_dec_and_test(&lo
->lo_pending
))
828 up(&lo
->lo_bh_mutex
);
829 spin_unlock_irq(&lo
->lo_lock
);
833 lo
->lo_backing_file
= NULL
;
835 loop_release_xfer(lo
);
838 lo
->lo_device
= NULL
;
839 lo
->lo_encryption
= NULL
;
841 lo
->lo_sizelimit
= 0;
842 lo
->lo_encrypt_key_size
= 0;
844 memset(lo
->lo_encrypt_key
, 0, LO_KEY_SIZE
);
845 memset(lo
->lo_crypt_name
, 0, LO_NAME_SIZE
);
846 memset(lo
->lo_file_name
, 0, LO_NAME_SIZE
);
847 invalidate_bdev(bdev
, 0);
848 set_capacity(disks
[lo
->lo_number
], 0);
849 mapping_set_gfp_mask(filp
->f_dentry
->d_inode
->i_mapping
, gfp
);
850 lo
->lo_state
= Lo_unbound
;
852 /* This is safe: open() is still holding a reference. */
853 module_put(THIS_MODULE
);
858 loop_set_status(struct loop_device
*lo
, const struct loop_info64
*info
)
861 struct loop_func_table
*xfer
;
863 if (lo
->lo_encrypt_key_size
&& lo
->lo_key_owner
!= current
->uid
&&
864 !capable(CAP_SYS_ADMIN
))
866 if (lo
->lo_state
!= Lo_bound
)
868 if ((unsigned int) info
->lo_encrypt_key_size
> LO_KEY_SIZE
)
871 err
= loop_release_xfer(lo
);
875 if (info
->lo_encrypt_type
) {
876 unsigned int type
= info
->lo_encrypt_type
;
878 if (type
>= MAX_LO_CRYPT
)
880 xfer
= xfer_funcs
[type
];
886 err
= loop_init_xfer(lo
, xfer
, info
);
890 if (lo
->lo_offset
!= info
->lo_offset
||
891 lo
->lo_sizelimit
!= info
->lo_sizelimit
) {
892 lo
->lo_offset
= info
->lo_offset
;
893 lo
->lo_sizelimit
= info
->lo_sizelimit
;
894 if (figure_loop_size(lo
))
898 memcpy(lo
->lo_file_name
, info
->lo_file_name
, LO_NAME_SIZE
);
899 memcpy(lo
->lo_crypt_name
, info
->lo_crypt_name
, LO_NAME_SIZE
);
900 lo
->lo_file_name
[LO_NAME_SIZE
-1] = 0;
901 lo
->lo_crypt_name
[LO_NAME_SIZE
-1] = 0;
905 lo
->transfer
= xfer
->transfer
;
906 lo
->ioctl
= xfer
->ioctl
;
908 lo
->lo_encrypt_key_size
= info
->lo_encrypt_key_size
;
909 lo
->lo_init
[0] = info
->lo_init
[0];
910 lo
->lo_init
[1] = info
->lo_init
[1];
911 if (info
->lo_encrypt_key_size
) {
912 memcpy(lo
->lo_encrypt_key
, info
->lo_encrypt_key
,
913 info
->lo_encrypt_key_size
);
914 lo
->lo_key_owner
= current
->uid
;
921 loop_get_status(struct loop_device
*lo
, struct loop_info64
*info
)
923 struct file
*file
= lo
->lo_backing_file
;
927 if (lo
->lo_state
!= Lo_bound
)
929 error
= vfs_getattr(file
->f_vfsmnt
, file
->f_dentry
, &stat
);
932 memset(info
, 0, sizeof(*info
));
933 info
->lo_number
= lo
->lo_number
;
934 info
->lo_device
= huge_encode_dev(stat
.dev
);
935 info
->lo_inode
= stat
.ino
;
936 info
->lo_rdevice
= huge_encode_dev(lo
->lo_device
? stat
.rdev
: stat
.dev
);
937 info
->lo_offset
= lo
->lo_offset
;
938 info
->lo_sizelimit
= lo
->lo_sizelimit
;
939 info
->lo_flags
= lo
->lo_flags
;
940 memcpy(info
->lo_file_name
, lo
->lo_file_name
, LO_NAME_SIZE
);
941 memcpy(info
->lo_crypt_name
, lo
->lo_crypt_name
, LO_NAME_SIZE
);
942 info
->lo_encrypt_type
=
943 lo
->lo_encryption
? lo
->lo_encryption
->number
: 0;
944 if (lo
->lo_encrypt_key_size
&& capable(CAP_SYS_ADMIN
)) {
945 info
->lo_encrypt_key_size
= lo
->lo_encrypt_key_size
;
946 memcpy(info
->lo_encrypt_key
, lo
->lo_encrypt_key
,
947 lo
->lo_encrypt_key_size
);
953 loop_info64_from_old(const struct loop_info
*info
, struct loop_info64
*info64
)
955 memset(info64
, 0, sizeof(*info64
));
956 info64
->lo_number
= info
->lo_number
;
957 info64
->lo_device
= info
->lo_device
;
958 info64
->lo_inode
= info
->lo_inode
;
959 info64
->lo_rdevice
= info
->lo_rdevice
;
960 info64
->lo_offset
= info
->lo_offset
;
961 info64
->lo_sizelimit
= 0;
962 info64
->lo_encrypt_type
= info
->lo_encrypt_type
;
963 info64
->lo_encrypt_key_size
= info
->lo_encrypt_key_size
;
964 info64
->lo_flags
= info
->lo_flags
;
965 info64
->lo_init
[0] = info
->lo_init
[0];
966 info64
->lo_init
[1] = info
->lo_init
[1];
967 if (info
->lo_encrypt_type
== LO_CRYPT_CRYPTOAPI
)
968 memcpy(info64
->lo_crypt_name
, info
->lo_name
, LO_NAME_SIZE
);
970 memcpy(info64
->lo_file_name
, info
->lo_name
, LO_NAME_SIZE
);
971 memcpy(info64
->lo_encrypt_key
, info
->lo_encrypt_key
, LO_KEY_SIZE
);
975 loop_info64_to_old(const struct loop_info64
*info64
, struct loop_info
*info
)
977 memset(info
, 0, sizeof(*info
));
978 info
->lo_number
= info64
->lo_number
;
979 info
->lo_device
= info64
->lo_device
;
980 info
->lo_inode
= info64
->lo_inode
;
981 info
->lo_rdevice
= info64
->lo_rdevice
;
982 info
->lo_offset
= info64
->lo_offset
;
983 info
->lo_encrypt_type
= info64
->lo_encrypt_type
;
984 info
->lo_encrypt_key_size
= info64
->lo_encrypt_key_size
;
985 info
->lo_flags
= info64
->lo_flags
;
986 info
->lo_init
[0] = info64
->lo_init
[0];
987 info
->lo_init
[1] = info64
->lo_init
[1];
988 if (info
->lo_encrypt_type
== LO_CRYPT_CRYPTOAPI
)
989 memcpy(info
->lo_name
, info64
->lo_crypt_name
, LO_NAME_SIZE
);
991 memcpy(info
->lo_name
, info64
->lo_file_name
, LO_NAME_SIZE
);
992 memcpy(info
->lo_encrypt_key
, info64
->lo_encrypt_key
, LO_KEY_SIZE
);
994 /* error in case values were truncated */
995 if (info
->lo_device
!= info64
->lo_device
||
996 info
->lo_rdevice
!= info64
->lo_rdevice
||
997 info
->lo_inode
!= info64
->lo_inode
||
998 info
->lo_offset
!= info64
->lo_offset
)
1005 loop_set_status_old(struct loop_device
*lo
, const struct loop_info
*arg
)
1007 struct loop_info info
;
1008 struct loop_info64 info64
;
1010 if (copy_from_user(&info
, arg
, sizeof (struct loop_info
)))
1012 loop_info64_from_old(&info
, &info64
);
1013 return loop_set_status(lo
, &info64
);
1017 loop_set_status64(struct loop_device
*lo
, const struct loop_info64
*arg
)
1019 struct loop_info64 info64
;
1021 if (copy_from_user(&info64
, arg
, sizeof (struct loop_info64
)))
1023 return loop_set_status(lo
, &info64
);
1027 loop_get_status_old(struct loop_device
*lo
, struct loop_info
*arg
) {
1028 struct loop_info info
;
1029 struct loop_info64 info64
;
1035 err
= loop_get_status(lo
, &info64
);
1037 err
= loop_info64_to_old(&info64
, &info
);
1038 if (!err
&& copy_to_user(arg
, &info
, sizeof(info
)))
1045 loop_get_status64(struct loop_device
*lo
, struct loop_info64
*arg
) {
1046 struct loop_info64 info64
;
1052 err
= loop_get_status(lo
, &info64
);
1053 if (!err
&& copy_to_user(arg
, &info64
, sizeof(info64
)))
1059 static int lo_ioctl(struct inode
* inode
, struct file
* file
,
1060 unsigned int cmd
, unsigned long arg
)
1062 struct loop_device
*lo
= inode
->i_bdev
->bd_disk
->private_data
;
1065 down(&lo
->lo_ctl_mutex
);
1068 err
= loop_set_fd(lo
, file
, inode
->i_bdev
, arg
);
1071 err
= loop_clr_fd(lo
, inode
->i_bdev
);
1073 case LOOP_SET_STATUS
:
1074 err
= loop_set_status_old(lo
, (struct loop_info
*) arg
);
1076 case LOOP_GET_STATUS
:
1077 err
= loop_get_status_old(lo
, (struct loop_info
*) arg
);
1079 case LOOP_SET_STATUS64
:
1080 err
= loop_set_status64(lo
, (struct loop_info64
*) arg
);
1082 case LOOP_GET_STATUS64
:
1083 err
= loop_get_status64(lo
, (struct loop_info64
*) arg
);
1086 err
= lo
->ioctl
? lo
->ioctl(lo
, cmd
, arg
) : -EINVAL
;
1088 up(&lo
->lo_ctl_mutex
);
1092 static int lo_open(struct inode
*inode
, struct file
*file
)
1094 struct loop_device
*lo
= inode
->i_bdev
->bd_disk
->private_data
;
1096 down(&lo
->lo_ctl_mutex
);
1098 up(&lo
->lo_ctl_mutex
);
1103 static int lo_release(struct inode
*inode
, struct file
*file
)
1105 struct loop_device
*lo
= inode
->i_bdev
->bd_disk
->private_data
;
1107 down(&lo
->lo_ctl_mutex
);
1109 up(&lo
->lo_ctl_mutex
);
1114 static struct block_device_operations lo_fops
= {
1115 .owner
= THIS_MODULE
,
1117 .release
= lo_release
,
1122 * And now the modules code and kernel interface.
1124 MODULE_PARM(max_loop
, "i");
1125 MODULE_PARM_DESC(max_loop
, "Maximum number of loop devices (1-256)");
1126 MODULE_LICENSE("GPL");
1128 int loop_register_transfer(struct loop_func_table
*funcs
)
1130 unsigned int n
= funcs
->number
;
1132 if (n
>= MAX_LO_CRYPT
|| xfer_funcs
[n
])
1134 xfer_funcs
[n
] = funcs
;
1138 int loop_unregister_transfer(int number
)
1140 unsigned int n
= number
;
1141 struct loop_device
*lo
;
1142 struct loop_func_table
*xfer
;
1144 if (n
== 0 || n
>= MAX_LO_CRYPT
|| (xfer
= xfer_funcs
[n
]) == NULL
)
1147 xfer_funcs
[n
] = NULL
;
1149 for (lo
= &loop_dev
[0]; lo
< &loop_dev
[max_loop
]; lo
++) {
1150 down(&lo
->lo_ctl_mutex
);
1152 if (lo
->lo_encryption
== xfer
)
1153 loop_release_xfer(lo
);
1155 up(&lo
->lo_ctl_mutex
);
1161 EXPORT_SYMBOL(loop_register_transfer
);
1162 EXPORT_SYMBOL(loop_unregister_transfer
);
1164 int __init
loop_init(void)
1168 if (max_loop
< 1 || max_loop
> 256) {
1169 printk(KERN_WARNING
"loop: invalid max_loop (must be between"
1170 " 1 and 256), using default (8)\n");
1174 if (register_blkdev(LOOP_MAJOR
, "loop"))
1177 loop_dev
= kmalloc(max_loop
* sizeof(struct loop_device
), GFP_KERNEL
);
1180 memset(loop_dev
, 0, max_loop
* sizeof(struct loop_device
));
1182 disks
= kmalloc(max_loop
* sizeof(struct gendisk
*), GFP_KERNEL
);
1186 for (i
= 0; i
< max_loop
; i
++) {
1187 disks
[i
] = alloc_disk(1);
1192 devfs_mk_dir("loop");
1194 for (i
= 0; i
< max_loop
; i
++) {
1195 struct loop_device
*lo
= &loop_dev
[i
];
1196 struct gendisk
*disk
= disks
[i
];
1198 memset(lo
, 0, sizeof(*lo
));
1199 lo
->lo_queue
= blk_alloc_queue(GFP_KERNEL
);
1202 disks
[i
]->queue
= lo
->lo_queue
;
1203 init_MUTEX(&lo
->lo_ctl_mutex
);
1204 init_MUTEX_LOCKED(&lo
->lo_sem
);
1205 init_MUTEX_LOCKED(&lo
->lo_bh_mutex
);
1207 spin_lock_init(&lo
->lo_lock
);
1208 disk
->major
= LOOP_MAJOR
;
1209 disk
->first_minor
= i
;
1210 disk
->fops
= &lo_fops
;
1211 sprintf(disk
->disk_name
, "loop%d", i
);
1212 sprintf(disk
->devfs_name
, "loop/%d", i
);
1213 disk
->private_data
= lo
;
1214 disk
->queue
= lo
->lo_queue
;
1217 printk(KERN_INFO
"loop: loaded (max %d devices)\n", max_loop
);
1222 blk_put_queue(loop_dev
[i
].lo_queue
);
1231 unregister_blkdev(LOOP_MAJOR
, "loop");
1232 printk(KERN_ERR
"loop: ran out of memory\n");
1236 void loop_exit(void)
1240 for (i
= 0; i
< max_loop
; i
++) {
1241 del_gendisk(disks
[i
]);
1242 blk_put_queue(loop_dev
[i
].lo_queue
);
1245 devfs_remove("loop");
1246 if (unregister_blkdev(LOOP_MAJOR
, "loop"))
1247 printk(KERN_WARNING
"loop: cannot unregister blkdev\n");
1253 module_init(loop_init
);
1254 module_exit(loop_exit
);
1257 static int __init
max_loop_setup(char *str
)
1259 max_loop
= simple_strtol(str
, NULL
, 0);
1263 __setup("max_loop=", max_loop_setup
);