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 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
35 * - Advisory locking is ignored here.
36 * - Should use an own CAP_* category instead of CAP_SYS_ADMIN
37 * - Should use the underlying filesystems/devices read function if possible
38 * to support read ahead (and for write)
41 * - The block number as IV passing to low level transfer functions is broken:
42 * it passes the underlying device's block number instead of the
43 * offset. This makes it change for a given block when the file is
44 * moved/restored/copied and also doesn't work over NFS.
45 * AV, Feb 12, 2000: we pass the logical block number now. It fixes the
46 * problem above. Encryption modules that used to rely on the old scheme
47 * should just call ->i_mapping->bmap() to calculate the physical block
51 #include <linux/module.h>
53 #include <linux/sched.h>
55 #include <linux/file.h>
56 #include <linux/stat.h>
57 #include <linux/errno.h>
58 #include <linux/major.h>
60 #include <linux/init.h>
61 #include <linux/devfs_fs_kernel.h>
63 #include <asm/uaccess.h>
65 #include <linux/loop.h>
67 #define MAJOR_NR LOOP_MAJOR
69 #define DEVICE_NAME "loop"
70 #define DEVICE_REQUEST do_lo_request
71 #define DEVICE_NR(device) (MINOR(device))
72 #define DEVICE_ON(device)
73 #define DEVICE_OFF(device)
74 #define DEVICE_NO_RANDOM
75 #define TIMEOUT_VALUE (6 * HZ)
76 #include <linux/blk.h>
78 #include <linux/malloc.h>
79 static int max_loop
= 8;
80 static struct loop_device
*loop_dev
;
81 static int *loop_sizes
;
82 static int *loop_blksizes
;
83 static devfs_handle_t devfs_handle
; /* For the directory */
91 static int transfer_none(struct loop_device
*lo
, int cmd
, char *raw_buf
,
92 char *loop_buf
, int size
, int real_block
)
95 memcpy(loop_buf
, raw_buf
, size
);
97 memcpy(raw_buf
, loop_buf
, size
);
101 static int transfer_xor(struct loop_device
*lo
, int cmd
, char *raw_buf
,
102 char *loop_buf
, int size
, int real_block
)
104 char *in
, *out
, *key
;
114 key
= lo
->lo_encrypt_key
;
115 keysize
= lo
->lo_encrypt_key_size
;
116 for (i
=0; i
< size
; i
++)
117 *out
++ = *in
++ ^ key
[(i
& 511) % keysize
];
121 static int none_status(struct loop_device
*lo
, struct loop_info
*info
)
126 static int xor_status(struct loop_device
*lo
, struct loop_info
*info
)
128 if (info
->lo_encrypt_key_size
<= 0)
133 struct loop_func_table none_funcs
= {
134 number
: LO_CRYPT_NONE
,
135 transfer
: transfer_none
,
139 struct loop_func_table xor_funcs
= {
140 number
: LO_CRYPT_XOR
,
141 transfer
: transfer_xor
,
145 /* xfer_funcs[0] is special - its release function is never called */
146 struct loop_func_table
*xfer_funcs
[MAX_LO_CRYPT
] = {
151 #define MAX_DISK_SIZE 1024*1024*1024
153 static void figure_loop_size(struct loop_device
*lo
)
157 if (S_ISREG(lo
->lo_dentry
->d_inode
->i_mode
))
158 size
= (lo
->lo_dentry
->d_inode
->i_size
- lo
->lo_offset
) >> BLOCK_SIZE_BITS
;
160 kdev_t lodev
= lo
->lo_device
;
161 if (blk_size
[MAJOR(lodev
)])
162 size
= blk_size
[MAJOR(lodev
)][MINOR(lodev
)] -
163 (lo
->lo_offset
>> BLOCK_SIZE_BITS
);
165 size
= MAX_DISK_SIZE
;
168 loop_sizes
[lo
->lo_number
] = size
;
171 static int lo_send(struct loop_device
*lo
, char *data
, int len
, loff_t pos
,
174 struct file
*file
= lo
->lo_backing_file
; /* kudos to NFsckingS */
175 struct address_space
*mapping
= lo
->lo_dentry
->d_inode
->i_mapping
;
176 struct address_space_operations
*aops
= mapping
->a_ops
;
180 unsigned size
, offset
;
182 index
= pos
>> PAGE_CACHE_SHIFT
;
183 offset
= pos
& (PAGE_CACHE_SIZE
- 1);
185 int IV
= index
* (PAGE_CACHE_SIZE
/blksize
) + offset
/blksize
;
186 size
= PAGE_CACHE_SIZE
- offset
;
190 page
= grab_cache_page(mapping
, index
);
193 if (aops
->prepare_write(file
, page
, offset
, offset
+size
))
195 kaddr
= page_address(page
);
196 if ((lo
->transfer
)(lo
, WRITE
, kaddr
+offset
, data
, size
, IV
))
198 if (aops
->commit_write(file
, page
, offset
, offset
+size
))
206 page_cache_release(page
);
211 printk(KERN_ERR
"loop: transfer error block %ld\n", index
);
212 ClearPageUptodate(page
);
216 page_cache_release(page
);
221 struct lo_read_data
{
222 struct loop_device
*lo
;
227 static int lo_read_actor(read_descriptor_t
* desc
, struct page
*page
, unsigned long offset
, unsigned long size
)
230 unsigned long count
= desc
->count
;
231 struct lo_read_data
*p
= (struct lo_read_data
*)desc
->buf
;
232 struct loop_device
*lo
= p
->lo
;
233 int IV
= page
->index
* (PAGE_CACHE_SIZE
/p
->blksize
) + offset
/p
->blksize
;
239 if ((lo
->transfer
)(lo
,READ
,kaddr
+offset
,p
->data
,size
,IV
)) {
241 printk(KERN_ERR
"loop: transfer error block %ld\n",
243 desc
->error
= -EINVAL
;
247 desc
->count
= count
- size
;
248 desc
->written
+= size
;
253 static int lo_receive(struct loop_device
*lo
, char *data
, int len
, loff_t pos
,
256 struct file
*file
= lo
->lo_backing_file
;
257 struct lo_read_data cookie
;
258 read_descriptor_t desc
;
262 cookie
.blksize
= blksize
;
265 desc
.buf
= (char*)&cookie
;
267 do_generic_file_read(file
, &pos
, &desc
, lo_read_actor
);
271 static void do_lo_request(request_queue_t
* q
)
273 int block
, offset
, len
, blksize
, size
;
275 struct loop_device
*lo
;
276 struct buffer_head
*bh
;
277 struct request
*current_request
;
282 current_request
=CURRENT
;
283 blkdev_dequeue_request(current_request
);
284 if (MINOR(current_request
->rq_dev
) >= max_loop
)
286 lo
= &loop_dev
[MINOR(current_request
->rq_dev
)];
287 if (!lo
->lo_dentry
|| !lo
->transfer
)
289 if (current_request
->cmd
== WRITE
) {
290 if (lo
->lo_flags
& LO_FLAGS_READ_ONLY
)
292 } else if (current_request
->cmd
!= READ
) {
293 printk(KERN_ERR
"unknown loop device command (%d)?!?",
294 current_request
->cmd
);
298 dest_addr
= current_request
->buffer
;
299 len
= current_request
->current_nr_sectors
<< 9;
301 blksize
= BLOCK_SIZE
;
302 if (blksize_size
[MAJOR(lo
->lo_device
)]) {
303 blksize
= blksize_size
[MAJOR(lo
->lo_device
)][MINOR(lo
->lo_device
)];
305 blksize
= BLOCK_SIZE
;
308 if (lo
->lo_flags
& LO_FLAGS_DO_BMAP
)
312 block
= current_request
->sector
* (512/blksize
);
315 block
= current_request
->sector
/ (blksize
>> 9);
316 offset
= (current_request
->sector
% (blksize
>> 9)) << 9;
318 block
+= lo
->lo_offset
/ blksize
;
319 offset
+= lo
->lo_offset
% blksize
;
320 if (offset
>= blksize
) {
324 spin_unlock_irq(&io_request_lock
);
328 size
= blksize
- offset
;
332 bh
= getblk(lo
->lo_device
, block
, blksize
);
334 printk(KERN_ERR
"loop: device %s: getblk(-, %d, %d) returned NULL",
335 kdevname(lo
->lo_device
),
339 if (!buffer_uptodate(bh
) && ((current_request
->cmd
== READ
) ||
340 (offset
|| (len
< blksize
)))) {
341 ll_rw_block(READ
, 1, &bh
);
343 if (!buffer_uptodate(bh
)) {
349 if ((lo
->transfer
)(lo
, current_request
->cmd
,
351 dest_addr
, size
, block
)) {
352 printk(KERN_ERR
"loop: transfer error block %d\n",
358 if (current_request
->cmd
== WRITE
) {
359 mark_buffer_uptodate(bh
, 1);
360 mark_buffer_dirty(bh
);
371 pos
= ((loff_t
)current_request
->sector
<< 9) + lo
->lo_offset
;
372 spin_unlock_irq(&io_request_lock
);
373 if (current_request
->cmd
== WRITE
) {
374 if (lo_send(lo
, dest_addr
, len
, pos
, blksize
))
377 if (lo_receive(lo
, dest_addr
, len
, pos
, blksize
))
381 spin_lock_irq(&io_request_lock
);
382 current_request
->sector
+= current_request
->current_nr_sectors
;
383 current_request
->nr_sectors
-= current_request
->current_nr_sectors
;
384 list_add(¤t_request
->queue
, &q
->queue_head
);
388 spin_lock_irq(&io_request_lock
);
390 list_add(¤t_request
->queue
, &q
->queue_head
);
395 static int loop_set_fd(struct loop_device
*lo
, kdev_t dev
, unsigned int arg
)
413 inode
= file
->f_dentry
->d_inode
;
415 if (S_ISBLK(inode
->i_mode
)) {
416 /* dentry will be wired, so... */
417 error
= blkdev_get(inode
->i_bdev
, file
->f_mode
,
418 file
->f_flags
, BDEV_FILE
);
420 lo
->lo_device
= inode
->i_rdev
;
423 /* Backed by a block device - don't need to hold onto
425 lo
->lo_backing_file
= NULL
;
429 } else if (S_ISREG(inode
->i_mode
)) {
430 struct address_space_operations
*aops
;
432 aops
= inode
->i_mapping
->a_ops
;
434 * If we can't read - sorry. If we only can't write - well,
435 * it's going to be read-only.
441 if (!aops
->prepare_write
|| !aops
->commit_write
)
442 lo
->lo_flags
|= LO_FLAGS_READ_ONLY
;
444 error
= get_write_access(inode
);
448 /* Backed by a regular file - we need to hold onto a file
449 structure for this file. Friggin' NFS can't live without
450 it on write and for reading we use do_generic_file_read(),
451 so... We create a new file structure based on the one
452 passed to us via 'arg'. This is to avoid changing the file
453 structure that the caller is using */
455 lo
->lo_device
= inode
->i_dev
;
456 lo
->lo_flags
|= LO_FLAGS_DO_BMAP
;
459 lo
->lo_backing_file
= get_empty_filp();
460 if (lo
->lo_backing_file
== NULL
) {
461 put_write_access(inode
);
465 lo
->lo_backing_file
->f_mode
= file
->f_mode
;
466 lo
->lo_backing_file
->f_pos
= file
->f_pos
;
467 lo
->lo_backing_file
->f_flags
= file
->f_flags
;
468 lo
->lo_backing_file
->f_owner
= file
->f_owner
;
469 lo
->lo_backing_file
->f_dentry
= file
->f_dentry
;
470 lo
->lo_backing_file
->f_vfsmnt
= mntget(file
->f_vfsmnt
);
471 lo
->lo_backing_file
->f_op
= fops_get(file
->f_op
);
472 lo
->lo_backing_file
->private_data
= file
->private_data
;
473 file_moveto(lo
->lo_backing_file
, file
);
478 if (IS_RDONLY (inode
) || is_read_only(lo
->lo_device
))
479 lo
->lo_flags
|= LO_FLAGS_READ_ONLY
;
481 set_device_ro(dev
, (lo
->lo_flags
& LO_FLAGS_READ_ONLY
)!=0);
483 lo
->lo_dentry
= dget(file
->f_dentry
);
486 figure_loop_size(lo
);
496 static int loop_release_xfer(struct loop_device
*lo
)
499 if (lo
->lo_encrypt_type
) {
500 struct loop_func_table
*xfer
= xfer_funcs
[lo
->lo_encrypt_type
];
501 if (xfer
&& xfer
->release
)
502 err
= xfer
->release(lo
);
503 if (xfer
&& xfer
->unlock
)
505 lo
->lo_encrypt_type
= 0;
510 static int loop_init_xfer(struct loop_device
*lo
, int type
,struct loop_info
*i
)
514 struct loop_func_table
*xfer
= xfer_funcs
[type
];
516 err
= xfer
->init(lo
, i
);
518 lo
->lo_encrypt_type
= type
;
526 static int loop_clr_fd(struct loop_device
*lo
, kdev_t dev
)
528 struct dentry
*dentry
= lo
->lo_dentry
;
532 if (lo
->lo_refcnt
> 1) /* we needed one fd for the ioctl */
535 if (S_ISBLK(dentry
->d_inode
->i_mode
))
536 blkdev_put(dentry
->d_inode
->i_bdev
, BDEV_FILE
);
538 lo
->lo_dentry
= NULL
;
540 if (lo
->lo_backing_file
!= NULL
) {
541 struct file
*filp
= lo
->lo_backing_file
;
542 if ((filp
->f_mode
& FMODE_WRITE
) == 0)
543 put_write_access(filp
->f_dentry
->d_inode
);
545 lo
->lo_backing_file
= NULL
;
550 loop_release_xfer(lo
);
554 lo
->lo_encrypt_type
= 0;
556 lo
->lo_encrypt_key_size
= 0;
557 memset(lo
->lo_encrypt_key
, 0, LO_KEY_SIZE
);
558 memset(lo
->lo_name
, 0, LO_NAME_SIZE
);
559 loop_sizes
[lo
->lo_number
] = 0;
560 invalidate_buffers(dev
);
565 static int loop_set_status(struct loop_device
*lo
, struct loop_info
*arg
)
567 struct loop_info info
;
571 if (lo
->lo_encrypt_key_size
&& lo
->lo_key_owner
!= current
->uid
&&
572 !capable(CAP_SYS_ADMIN
))
576 if (copy_from_user(&info
, arg
, sizeof (struct loop_info
)))
578 if ((unsigned int) info
.lo_encrypt_key_size
> LO_KEY_SIZE
)
580 type
= info
.lo_encrypt_type
;
581 if (type
>= MAX_LO_CRYPT
|| xfer_funcs
[type
] == NULL
)
583 if (type
== LO_CRYPT_XOR
&& info
.lo_encrypt_key_size
== 0)
585 err
= loop_release_xfer(lo
);
587 err
= loop_init_xfer(lo
, type
, &info
);
591 lo
->lo_offset
= info
.lo_offset
;
592 strncpy(lo
->lo_name
, info
.lo_name
, LO_NAME_SIZE
);
594 lo
->transfer
= xfer_funcs
[type
]->transfer
;
595 lo
->ioctl
= xfer_funcs
[type
]->ioctl
;
596 lo
->lo_encrypt_key_size
= info
.lo_encrypt_key_size
;
597 lo
->lo_init
[0] = info
.lo_init
[0];
598 lo
->lo_init
[1] = info
.lo_init
[1];
599 if (info
.lo_encrypt_key_size
) {
600 memcpy(lo
->lo_encrypt_key
, info
.lo_encrypt_key
,
601 info
.lo_encrypt_key_size
);
602 lo
->lo_key_owner
= current
->uid
;
604 figure_loop_size(lo
);
608 static int loop_get_status(struct loop_device
*lo
, struct loop_info
*arg
)
610 struct loop_info info
;
616 memset(&info
, 0, sizeof(info
));
617 info
.lo_number
= lo
->lo_number
;
618 info
.lo_device
= kdev_t_to_nr(lo
->lo_dentry
->d_inode
->i_dev
);
619 info
.lo_inode
= lo
->lo_dentry
->d_inode
->i_ino
;
620 info
.lo_rdevice
= kdev_t_to_nr(lo
->lo_device
);
621 info
.lo_offset
= lo
->lo_offset
;
622 info
.lo_flags
= lo
->lo_flags
;
623 strncpy(info
.lo_name
, lo
->lo_name
, LO_NAME_SIZE
);
624 info
.lo_encrypt_type
= lo
->lo_encrypt_type
;
625 if (lo
->lo_encrypt_key_size
&& capable(CAP_SYS_ADMIN
)) {
626 info
.lo_encrypt_key_size
= lo
->lo_encrypt_key_size
;
627 memcpy(info
.lo_encrypt_key
, lo
->lo_encrypt_key
,
628 lo
->lo_encrypt_key_size
);
630 return copy_to_user(arg
, &info
, sizeof(info
)) ? -EFAULT
: 0;
633 static int lo_ioctl(struct inode
* inode
, struct file
* file
,
634 unsigned int cmd
, unsigned long arg
)
636 struct loop_device
*lo
;
641 if (MAJOR(inode
->i_rdev
) != MAJOR_NR
) {
642 printk(KERN_WARNING
"lo_ioctl: pseudo-major != %d\n",
646 dev
= MINOR(inode
->i_rdev
);
652 return loop_set_fd(lo
, inode
->i_rdev
, arg
);
654 return loop_clr_fd(lo
, inode
->i_rdev
);
655 case LOOP_SET_STATUS
:
656 return loop_set_status(lo
, (struct loop_info
*) arg
);
657 case LOOP_GET_STATUS
:
658 return loop_get_status(lo
, (struct loop_info
*) arg
);
659 case BLKGETSIZE
: /* Return device size */
664 return put_user(loop_sizes
[lo
->lo_number
] << 1, (long *) arg
);
666 return lo
->ioctl
? lo
->ioctl(lo
, cmd
, arg
) : -EINVAL
;
671 static int lo_open(struct inode
*inode
, struct file
*file
)
673 struct loop_device
*lo
;
679 if (MAJOR(inode
->i_rdev
) != MAJOR_NR
) {
680 printk(KERN_WARNING
"lo_open: pseudo-major != %d\n", MAJOR_NR
);
683 dev
= MINOR(inode
->i_rdev
);
684 if (dev
>= max_loop
) {
689 type
= lo
->lo_encrypt_type
;
690 if (type
&& xfer_funcs
[type
] && xfer_funcs
[type
]->lock
)
691 xfer_funcs
[type
]->lock(lo
);
697 static int lo_release(struct inode
*inode
, struct file
*file
)
699 struct loop_device
*lo
;
704 if (MAJOR(inode
->i_rdev
) != MAJOR_NR
) {
705 printk(KERN_WARNING
"lo_release: pseudo-major != %d\n",
709 dev
= MINOR(inode
->i_rdev
);
713 if (lo
->lo_refcnt
<= 0)
714 printk(KERN_ERR
"lo_release: refcount(%d) <= 0\n",
717 int type
= lo
->lo_encrypt_type
;
719 if (xfer_funcs
[type
] && xfer_funcs
[type
]->unlock
)
720 xfer_funcs
[type
]->unlock(lo
);
726 static struct block_device_operations lo_fops
= {
733 * And now the modules code and kernel interface.
736 #define loop_init init_module
737 MODULE_PARM(max_loop
, "i");
738 MODULE_PARM_DESC(max_loop
, "Maximum number of loop devices (1-255)");
741 int loop_register_transfer(struct loop_func_table
*funcs
)
743 if ((unsigned)funcs
->number
> MAX_LO_CRYPT
|| xfer_funcs
[funcs
->number
])
745 xfer_funcs
[funcs
->number
] = funcs
;
749 int loop_unregister_transfer(int number
)
751 struct loop_device
*lo
;
753 if ((unsigned)number
>= MAX_LO_CRYPT
)
755 for (lo
= &loop_dev
[0]; lo
< &loop_dev
[max_loop
]; lo
++) {
756 int type
= lo
->lo_encrypt_type
;
757 if (type
== number
) {
758 xfer_funcs
[type
]->release(lo
);
760 lo
->lo_encrypt_type
= 0;
763 xfer_funcs
[number
] = NULL
;
767 EXPORT_SYMBOL(loop_register_transfer
);
768 EXPORT_SYMBOL(loop_unregister_transfer
);
770 static void no_plug_device(request_queue_t
*q
, kdev_t device
)
774 int __init
loop_init(void)
778 if (devfs_register_blkdev(MAJOR_NR
, "loop", &lo_fops
)) {
779 printk(KERN_WARNING
"Unable to get major number %d for loop device\n",
783 devfs_handle
= devfs_mk_dir (NULL
, "loop", NULL
);
784 devfs_register_series (devfs_handle
, "%u", max_loop
, DEVFS_FL_DEFAULT
,
786 S_IFBLK
| S_IRUSR
| S_IWUSR
| S_IRGRP
,
789 if ((max_loop
< 1) || (max_loop
> 255)) {
790 printk (KERN_WARNING
"loop: invalid max_loop (must be between 1 and 255), using default (8)\n");
794 printk(KERN_INFO
"loop: enabling %d loop devices\n", max_loop
);
796 loop_dev
= kmalloc (max_loop
* sizeof(struct loop_device
), GFP_KERNEL
);
798 printk (KERN_ERR
"loop: Unable to create loop_dev\n");
802 loop_sizes
= kmalloc(max_loop
* sizeof(int), GFP_KERNEL
);
804 printk (KERN_ERR
"loop: Unable to create loop_sizes\n");
809 loop_blksizes
= kmalloc (max_loop
* sizeof(int), GFP_KERNEL
);
810 if (!loop_blksizes
) {
811 printk (KERN_ERR
"loop: Unable to create loop_blksizes\n");
817 blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR
), DEVICE_REQUEST
);
818 blk_queue_pluggable(BLK_DEFAULT_QUEUE(MAJOR_NR
), no_plug_device
);
819 blk_queue_headactive(BLK_DEFAULT_QUEUE(MAJOR_NR
), 0);
820 for (i
=0; i
< max_loop
; i
++) {
821 memset(&loop_dev
[i
], 0, sizeof(struct loop_device
));
822 loop_dev
[i
].lo_number
= i
;
824 memset(loop_sizes
, 0, max_loop
* sizeof(int));
825 memset(loop_blksizes
, 0, max_loop
* sizeof(int));
826 blk_size
[MAJOR_NR
] = loop_sizes
;
827 blksize_size
[MAJOR_NR
] = loop_blksizes
;
828 for (i
=0; i
< max_loop
; i
++)
829 register_disk(NULL
, MKDEV(MAJOR_NR
,i
), 1, &lo_fops
, 0);
835 void cleanup_module(void)
837 devfs_unregister (devfs_handle
);
838 if (devfs_unregister_blkdev(MAJOR_NR
, "loop") != 0)
839 printk(KERN_WARNING
"loop: cannot unregister blkdev\n");
841 blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR
));
844 kfree (loop_blksizes
);
849 static int __init
max_loop_setup(char *str
)
851 max_loop
= simple_strtol(str
,NULL
,0);
855 __setup("max_loop=", max_loop_setup
);