11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/drivers/block/loop.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Written by Theodore Ts'o, 3/29/93 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Copyright 1993 by Theodore Ts'o. Redistribution of this file is 71da177e4SLinus Torvalds * permitted under the GNU General Public License. 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * DES encryption plus some minor changes by Werner Almesberger, 30-MAY-1993 101da177e4SLinus Torvalds * more DES encryption plus IDEA encryption by Nicholas J. Leon, June 20, 1996 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * Modularized and updated for 1.1.16 kernel - Mitch Dsouza 28th May 1994 131da177e4SLinus Torvalds * Adapted for 1.3.59 kernel - Andries Brouwer, 1 Feb 1996 141da177e4SLinus Torvalds * 151da177e4SLinus Torvalds * Fixed do_loop_request() re-entrancy - Vincent.Renardias@waw.com Mar 20, 1997 161da177e4SLinus Torvalds * 171da177e4SLinus Torvalds * Added devfs support - Richard Gooch <rgooch@atnf.csiro.au> 16-Jan-1998 181da177e4SLinus Torvalds * 191da177e4SLinus Torvalds * Handle sparse backing files correctly - Kenn Humborg, Jun 28, 1998 201da177e4SLinus Torvalds * 211da177e4SLinus Torvalds * Loadable modules and other fixes by AK, 1998 221da177e4SLinus Torvalds * 231da177e4SLinus Torvalds * Make real block number available to downstream transfer functions, enables 241da177e4SLinus Torvalds * CBC (and relatives) mode encryption requiring unique IVs per data block. 251da177e4SLinus Torvalds * Reed H. Petty, rhp@draper.net 261da177e4SLinus Torvalds * 271da177e4SLinus Torvalds * Maximum number of loop devices now dynamic via max_loop module parameter. 281da177e4SLinus Torvalds * Russell Kroll <rkroll@exploits.org> 19990701 291da177e4SLinus Torvalds * 301da177e4SLinus Torvalds * Maximum number of loop devices when compiled-in now selectable by passing 311da177e4SLinus Torvalds * max_loop=<1-255> to the kernel on boot. 3296de0e25SJan Engelhardt * Erik I. Bolsø, <eriki@himolde.no>, Oct 31, 1999 331da177e4SLinus Torvalds * 341da177e4SLinus Torvalds * Completely rewrite request handling to be make_request_fn style and 351da177e4SLinus Torvalds * non blocking, pushing work to a helper thread. Lots of fixes from 361da177e4SLinus Torvalds * Al Viro too. 371da177e4SLinus Torvalds * Jens Axboe <axboe@suse.de>, Nov 2000 381da177e4SLinus Torvalds * 391da177e4SLinus Torvalds * Support up to 256 loop devices 401da177e4SLinus Torvalds * Heinz Mauelshagen <mge@sistina.com>, Feb 2002 411da177e4SLinus Torvalds * 421da177e4SLinus Torvalds * Support for falling back on the write file operation when the address space 434e02ed4bSNick Piggin * operations write_begin is not available on the backing filesystem. 441da177e4SLinus Torvalds * Anton Altaparmakov, 16 Feb 2005 451da177e4SLinus Torvalds * 461da177e4SLinus Torvalds * Still To Fix: 471da177e4SLinus Torvalds * - Advisory locking is ignored here. 481da177e4SLinus Torvalds * - Should use an own CAP_* category instead of CAP_SYS_ADMIN 491da177e4SLinus Torvalds * 501da177e4SLinus Torvalds */ 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds #include <linux/module.h> 531da177e4SLinus Torvalds #include <linux/moduleparam.h> 541da177e4SLinus Torvalds #include <linux/sched.h> 551da177e4SLinus Torvalds #include <linux/fs.h> 561da177e4SLinus Torvalds #include <linux/file.h> 571da177e4SLinus Torvalds #include <linux/stat.h> 581da177e4SLinus Torvalds #include <linux/errno.h> 591da177e4SLinus Torvalds #include <linux/major.h> 601da177e4SLinus Torvalds #include <linux/wait.h> 611da177e4SLinus Torvalds #include <linux/blkdev.h> 621da177e4SLinus Torvalds #include <linux/blkpg.h> 631da177e4SLinus Torvalds #include <linux/init.h> 641da177e4SLinus Torvalds #include <linux/smp_lock.h> 651da177e4SLinus Torvalds #include <linux/swap.h> 661da177e4SLinus Torvalds #include <linux/slab.h> 671da177e4SLinus Torvalds #include <linux/loop.h> 68863d5b82SDavid Howells #include <linux/compat.h> 691da177e4SLinus Torvalds #include <linux/suspend.h> 7083144186SRafael J. Wysocki #include <linux/freezer.h> 711da177e4SLinus Torvalds #include <linux/writeback.h> 721da177e4SLinus Torvalds #include <linux/buffer_head.h> /* for invalidate_bdev() */ 731da177e4SLinus Torvalds #include <linux/completion.h> 741da177e4SLinus Torvalds #include <linux/highmem.h> 751da177e4SLinus Torvalds #include <linux/gfp.h> 766c997918SSerge E. Hallyn #include <linux/kthread.h> 77d6b29d7cSJens Axboe #include <linux/splice.h> 781da177e4SLinus Torvalds 791da177e4SLinus Torvalds #include <asm/uaccess.h> 801da177e4SLinus Torvalds 8173285082SKen Chen static LIST_HEAD(loop_devices); 8273285082SKen Chen static DEFINE_MUTEX(loop_devices_mutex); 831da177e4SLinus Torvalds 84476a4813SLaurent Vivier static int max_part; 85476a4813SLaurent Vivier static int part_shift; 86476a4813SLaurent Vivier 871da177e4SLinus Torvalds /* 881da177e4SLinus Torvalds * Transfer functions 891da177e4SLinus Torvalds */ 901da177e4SLinus Torvalds static int transfer_none(struct loop_device *lo, int cmd, 911da177e4SLinus Torvalds struct page *raw_page, unsigned raw_off, 921da177e4SLinus Torvalds struct page *loop_page, unsigned loop_off, 931da177e4SLinus Torvalds int size, sector_t real_block) 941da177e4SLinus Torvalds { 951da177e4SLinus Torvalds char *raw_buf = kmap_atomic(raw_page, KM_USER0) + raw_off; 961da177e4SLinus Torvalds char *loop_buf = kmap_atomic(loop_page, KM_USER1) + loop_off; 971da177e4SLinus Torvalds 981da177e4SLinus Torvalds if (cmd == READ) 991da177e4SLinus Torvalds memcpy(loop_buf, raw_buf, size); 1001da177e4SLinus Torvalds else 1011da177e4SLinus Torvalds memcpy(raw_buf, loop_buf, size); 1021da177e4SLinus Torvalds 1031da177e4SLinus Torvalds kunmap_atomic(raw_buf, KM_USER0); 1041da177e4SLinus Torvalds kunmap_atomic(loop_buf, KM_USER1); 1051da177e4SLinus Torvalds cond_resched(); 1061da177e4SLinus Torvalds return 0; 1071da177e4SLinus Torvalds } 1081da177e4SLinus Torvalds 1091da177e4SLinus Torvalds static int transfer_xor(struct loop_device *lo, int cmd, 1101da177e4SLinus Torvalds struct page *raw_page, unsigned raw_off, 1111da177e4SLinus Torvalds struct page *loop_page, unsigned loop_off, 1121da177e4SLinus Torvalds int size, sector_t real_block) 1131da177e4SLinus Torvalds { 1141da177e4SLinus Torvalds char *raw_buf = kmap_atomic(raw_page, KM_USER0) + raw_off; 1151da177e4SLinus Torvalds char *loop_buf = kmap_atomic(loop_page, KM_USER1) + loop_off; 1161da177e4SLinus Torvalds char *in, *out, *key; 1171da177e4SLinus Torvalds int i, keysize; 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds if (cmd == READ) { 1201da177e4SLinus Torvalds in = raw_buf; 1211da177e4SLinus Torvalds out = loop_buf; 1221da177e4SLinus Torvalds } else { 1231da177e4SLinus Torvalds in = loop_buf; 1241da177e4SLinus Torvalds out = raw_buf; 1251da177e4SLinus Torvalds } 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds key = lo->lo_encrypt_key; 1281da177e4SLinus Torvalds keysize = lo->lo_encrypt_key_size; 1291da177e4SLinus Torvalds for (i = 0; i < size; i++) 1301da177e4SLinus Torvalds *out++ = *in++ ^ key[(i & 511) % keysize]; 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds kunmap_atomic(raw_buf, KM_USER0); 1331da177e4SLinus Torvalds kunmap_atomic(loop_buf, KM_USER1); 1341da177e4SLinus Torvalds cond_resched(); 1351da177e4SLinus Torvalds return 0; 1361da177e4SLinus Torvalds } 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds static int xor_init(struct loop_device *lo, const struct loop_info64 *info) 1391da177e4SLinus Torvalds { 1401da177e4SLinus Torvalds if (unlikely(info->lo_encrypt_key_size <= 0)) 1411da177e4SLinus Torvalds return -EINVAL; 1421da177e4SLinus Torvalds return 0; 1431da177e4SLinus Torvalds } 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds static struct loop_func_table none_funcs = { 1461da177e4SLinus Torvalds .number = LO_CRYPT_NONE, 1471da177e4SLinus Torvalds .transfer = transfer_none, 1481da177e4SLinus Torvalds }; 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds static struct loop_func_table xor_funcs = { 1511da177e4SLinus Torvalds .number = LO_CRYPT_XOR, 1521da177e4SLinus Torvalds .transfer = transfer_xor, 1531da177e4SLinus Torvalds .init = xor_init 1541da177e4SLinus Torvalds }; 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds /* xfer_funcs[0] is special - its release function is never called */ 1571da177e4SLinus Torvalds static struct loop_func_table *xfer_funcs[MAX_LO_CRYPT] = { 1581da177e4SLinus Torvalds &none_funcs, 1591da177e4SLinus Torvalds &xor_funcs 1601da177e4SLinus Torvalds }; 1611da177e4SLinus Torvalds 1621da177e4SLinus Torvalds static loff_t get_loop_size(struct loop_device *lo, struct file *file) 1631da177e4SLinus Torvalds { 1641da177e4SLinus Torvalds loff_t size, offset, loopsize; 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds /* Compute loopsize in bytes */ 1671da177e4SLinus Torvalds size = i_size_read(file->f_mapping->host); 1681da177e4SLinus Torvalds offset = lo->lo_offset; 1691da177e4SLinus Torvalds loopsize = size - offset; 1701da177e4SLinus Torvalds if (lo->lo_sizelimit > 0 && lo->lo_sizelimit < loopsize) 1711da177e4SLinus Torvalds loopsize = lo->lo_sizelimit; 1721da177e4SLinus Torvalds 1731da177e4SLinus Torvalds /* 1741da177e4SLinus Torvalds * Unfortunately, if we want to do I/O on the device, 1751da177e4SLinus Torvalds * the number of 512-byte sectors has to fit into a sector_t. 1761da177e4SLinus Torvalds */ 1771da177e4SLinus Torvalds return loopsize >> 9; 1781da177e4SLinus Torvalds } 1791da177e4SLinus Torvalds 1801da177e4SLinus Torvalds static int 1811da177e4SLinus Torvalds figure_loop_size(struct loop_device *lo) 1821da177e4SLinus Torvalds { 1831da177e4SLinus Torvalds loff_t size = get_loop_size(lo, lo->lo_backing_file); 1841da177e4SLinus Torvalds sector_t x = (sector_t)size; 1851da177e4SLinus Torvalds 1861da177e4SLinus Torvalds if (unlikely((loff_t)x != size)) 1871da177e4SLinus Torvalds return -EFBIG; 1881da177e4SLinus Torvalds 18973285082SKen Chen set_capacity(lo->lo_disk, x); 1901da177e4SLinus Torvalds return 0; 1911da177e4SLinus Torvalds } 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds static inline int 1941da177e4SLinus Torvalds lo_do_transfer(struct loop_device *lo, int cmd, 1951da177e4SLinus Torvalds struct page *rpage, unsigned roffs, 1961da177e4SLinus Torvalds struct page *lpage, unsigned loffs, 1971da177e4SLinus Torvalds int size, sector_t rblock) 1981da177e4SLinus Torvalds { 1991da177e4SLinus Torvalds if (unlikely(!lo->transfer)) 2001da177e4SLinus Torvalds return 0; 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds return lo->transfer(lo, cmd, rpage, roffs, lpage, loffs, size, rblock); 2031da177e4SLinus Torvalds } 2041da177e4SLinus Torvalds 2051da177e4SLinus Torvalds /** 2061da177e4SLinus Torvalds * do_lo_send_aops - helper for writing data to a loop device 2071da177e4SLinus Torvalds * 2081da177e4SLinus Torvalds * This is the fast version for backing filesystems which implement the address 209afddba49SNick Piggin * space operations write_begin and write_end. 2101da177e4SLinus Torvalds */ 2111da177e4SLinus Torvalds static int do_lo_send_aops(struct loop_device *lo, struct bio_vec *bvec, 212511de73fSAl Viro loff_t pos, struct page *unused) 2131da177e4SLinus Torvalds { 2141da177e4SLinus Torvalds struct file *file = lo->lo_backing_file; /* kudos to NFsckingS */ 2151da177e4SLinus Torvalds struct address_space *mapping = file->f_mapping; 2161da177e4SLinus Torvalds pgoff_t index; 2171da177e4SLinus Torvalds unsigned offset, bv_offs; 218994fc28cSZach Brown int len, ret; 2191da177e4SLinus Torvalds 2201b1dcc1bSJes Sorensen mutex_lock(&mapping->host->i_mutex); 2211da177e4SLinus Torvalds index = pos >> PAGE_CACHE_SHIFT; 2221da177e4SLinus Torvalds offset = pos & ((pgoff_t)PAGE_CACHE_SIZE - 1); 2231da177e4SLinus Torvalds bv_offs = bvec->bv_offset; 2241da177e4SLinus Torvalds len = bvec->bv_len; 2251da177e4SLinus Torvalds while (len > 0) { 2261da177e4SLinus Torvalds sector_t IV; 227afddba49SNick Piggin unsigned size, copied; 2281da177e4SLinus Torvalds int transfer_result; 229afddba49SNick Piggin struct page *page; 230afddba49SNick Piggin void *fsdata; 2311da177e4SLinus Torvalds 2321da177e4SLinus Torvalds IV = ((sector_t)index << (PAGE_CACHE_SHIFT - 9))+(offset >> 9); 2331da177e4SLinus Torvalds size = PAGE_CACHE_SIZE - offset; 2341da177e4SLinus Torvalds if (size > len) 2351da177e4SLinus Torvalds size = len; 236afddba49SNick Piggin 237afddba49SNick Piggin ret = pagecache_write_begin(file, mapping, pos, size, 0, 238afddba49SNick Piggin &page, &fsdata); 239afddba49SNick Piggin if (ret) 2401da177e4SLinus Torvalds goto fail; 241afddba49SNick Piggin 2421da177e4SLinus Torvalds transfer_result = lo_do_transfer(lo, WRITE, page, offset, 2431da177e4SLinus Torvalds bvec->bv_page, bv_offs, size, IV); 244afddba49SNick Piggin copied = size; 2451da177e4SLinus Torvalds if (unlikely(transfer_result)) 246afddba49SNick Piggin copied = 0; 247afddba49SNick Piggin 248afddba49SNick Piggin ret = pagecache_write_end(file, mapping, pos, size, copied, 249afddba49SNick Piggin page, fsdata); 2508268f5a7SDmitry Monakhov if (ret < 0 || ret != copied) 251afddba49SNick Piggin goto fail; 252afddba49SNick Piggin 253afddba49SNick Piggin if (unlikely(transfer_result)) 254afddba49SNick Piggin goto fail; 255afddba49SNick Piggin 256afddba49SNick Piggin bv_offs += copied; 257afddba49SNick Piggin len -= copied; 2581da177e4SLinus Torvalds offset = 0; 2591da177e4SLinus Torvalds index++; 260afddba49SNick Piggin pos += copied; 2611da177e4SLinus Torvalds } 262994fc28cSZach Brown ret = 0; 2631da177e4SLinus Torvalds out: 2641b1dcc1bSJes Sorensen mutex_unlock(&mapping->host->i_mutex); 2651da177e4SLinus Torvalds return ret; 2661da177e4SLinus Torvalds fail: 2671da177e4SLinus Torvalds ret = -1; 2681da177e4SLinus Torvalds goto out; 2691da177e4SLinus Torvalds } 2701da177e4SLinus Torvalds 2711da177e4SLinus Torvalds /** 2721da177e4SLinus Torvalds * __do_lo_send_write - helper for writing data to a loop device 2731da177e4SLinus Torvalds * 2741da177e4SLinus Torvalds * This helper just factors out common code between do_lo_send_direct_write() 2751da177e4SLinus Torvalds * and do_lo_send_write(). 2761da177e4SLinus Torvalds */ 277858119e1SArjan van de Ven static int __do_lo_send_write(struct file *file, 27898ae6ccdSAl Viro u8 *buf, const int len, loff_t pos) 2791da177e4SLinus Torvalds { 2801da177e4SLinus Torvalds ssize_t bw; 2811da177e4SLinus Torvalds mm_segment_t old_fs = get_fs(); 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds set_fs(get_ds()); 2841da177e4SLinus Torvalds bw = file->f_op->write(file, buf, len, &pos); 2851da177e4SLinus Torvalds set_fs(old_fs); 2861da177e4SLinus Torvalds if (likely(bw == len)) 2871da177e4SLinus Torvalds return 0; 2881da177e4SLinus Torvalds printk(KERN_ERR "loop: Write error at byte offset %llu, length %i.\n", 2891da177e4SLinus Torvalds (unsigned long long)pos, len); 2901da177e4SLinus Torvalds if (bw >= 0) 2911da177e4SLinus Torvalds bw = -EIO; 2921da177e4SLinus Torvalds return bw; 2931da177e4SLinus Torvalds } 2941da177e4SLinus Torvalds 2951da177e4SLinus Torvalds /** 2961da177e4SLinus Torvalds * do_lo_send_direct_write - helper for writing data to a loop device 2971da177e4SLinus Torvalds * 2981da177e4SLinus Torvalds * This is the fast, non-transforming version for backing filesystems which do 299afddba49SNick Piggin * not implement the address space operations write_begin and write_end. 3001da177e4SLinus Torvalds * It uses the write file operation which should be present on all writeable 3011da177e4SLinus Torvalds * filesystems. 3021da177e4SLinus Torvalds */ 3031da177e4SLinus Torvalds static int do_lo_send_direct_write(struct loop_device *lo, 304511de73fSAl Viro struct bio_vec *bvec, loff_t pos, struct page *page) 3051da177e4SLinus Torvalds { 3061da177e4SLinus Torvalds ssize_t bw = __do_lo_send_write(lo->lo_backing_file, 30798ae6ccdSAl Viro kmap(bvec->bv_page) + bvec->bv_offset, 3081da177e4SLinus Torvalds bvec->bv_len, pos); 3091da177e4SLinus Torvalds kunmap(bvec->bv_page); 3101da177e4SLinus Torvalds cond_resched(); 3111da177e4SLinus Torvalds return bw; 3121da177e4SLinus Torvalds } 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds /** 3151da177e4SLinus Torvalds * do_lo_send_write - helper for writing data to a loop device 3161da177e4SLinus Torvalds * 3171da177e4SLinus Torvalds * This is the slow, transforming version for filesystems which do not 318afddba49SNick Piggin * implement the address space operations write_begin and write_end. It 3191da177e4SLinus Torvalds * uses the write file operation which should be present on all writeable 3201da177e4SLinus Torvalds * filesystems. 3211da177e4SLinus Torvalds * 3221da177e4SLinus Torvalds * Using fops->write is slower than using aops->{prepare,commit}_write in the 3231da177e4SLinus Torvalds * transforming case because we need to double buffer the data as we cannot do 3241da177e4SLinus Torvalds * the transformations in place as we do not have direct access to the 3251da177e4SLinus Torvalds * destination pages of the backing file. 3261da177e4SLinus Torvalds */ 3271da177e4SLinus Torvalds static int do_lo_send_write(struct loop_device *lo, struct bio_vec *bvec, 328511de73fSAl Viro loff_t pos, struct page *page) 3291da177e4SLinus Torvalds { 3301da177e4SLinus Torvalds int ret = lo_do_transfer(lo, WRITE, page, 0, bvec->bv_page, 3311da177e4SLinus Torvalds bvec->bv_offset, bvec->bv_len, pos >> 9); 3321da177e4SLinus Torvalds if (likely(!ret)) 3331da177e4SLinus Torvalds return __do_lo_send_write(lo->lo_backing_file, 33498ae6ccdSAl Viro page_address(page), bvec->bv_len, 3351da177e4SLinus Torvalds pos); 3361da177e4SLinus Torvalds printk(KERN_ERR "loop: Transfer error at byte offset %llu, " 3371da177e4SLinus Torvalds "length %i.\n", (unsigned long long)pos, bvec->bv_len); 3381da177e4SLinus Torvalds if (ret > 0) 3391da177e4SLinus Torvalds ret = -EIO; 3401da177e4SLinus Torvalds return ret; 3411da177e4SLinus Torvalds } 3421da177e4SLinus Torvalds 343511de73fSAl Viro static int lo_send(struct loop_device *lo, struct bio *bio, loff_t pos) 3441da177e4SLinus Torvalds { 345511de73fSAl Viro int (*do_lo_send)(struct loop_device *, struct bio_vec *, loff_t, 3461da177e4SLinus Torvalds struct page *page); 3471da177e4SLinus Torvalds struct bio_vec *bvec; 3481da177e4SLinus Torvalds struct page *page = NULL; 3491da177e4SLinus Torvalds int i, ret = 0; 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds do_lo_send = do_lo_send_aops; 3521da177e4SLinus Torvalds if (!(lo->lo_flags & LO_FLAGS_USE_AOPS)) { 3531da177e4SLinus Torvalds do_lo_send = do_lo_send_direct_write; 3541da177e4SLinus Torvalds if (lo->transfer != transfer_none) { 3551da177e4SLinus Torvalds page = alloc_page(GFP_NOIO | __GFP_HIGHMEM); 3561da177e4SLinus Torvalds if (unlikely(!page)) 3571da177e4SLinus Torvalds goto fail; 3581da177e4SLinus Torvalds kmap(page); 3591da177e4SLinus Torvalds do_lo_send = do_lo_send_write; 3601da177e4SLinus Torvalds } 3611da177e4SLinus Torvalds } 3621da177e4SLinus Torvalds bio_for_each_segment(bvec, bio, i) { 363511de73fSAl Viro ret = do_lo_send(lo, bvec, pos, page); 3641da177e4SLinus Torvalds if (ret < 0) 3651da177e4SLinus Torvalds break; 3661da177e4SLinus Torvalds pos += bvec->bv_len; 3671da177e4SLinus Torvalds } 3681da177e4SLinus Torvalds if (page) { 3691da177e4SLinus Torvalds kunmap(page); 3701da177e4SLinus Torvalds __free_page(page); 3711da177e4SLinus Torvalds } 3721da177e4SLinus Torvalds out: 3731da177e4SLinus Torvalds return ret; 3741da177e4SLinus Torvalds fail: 3751da177e4SLinus Torvalds printk(KERN_ERR "loop: Failed to allocate temporary page for write.\n"); 3761da177e4SLinus Torvalds ret = -ENOMEM; 3771da177e4SLinus Torvalds goto out; 3781da177e4SLinus Torvalds } 3791da177e4SLinus Torvalds 3801da177e4SLinus Torvalds struct lo_read_data { 3811da177e4SLinus Torvalds struct loop_device *lo; 3821da177e4SLinus Torvalds struct page *page; 3831da177e4SLinus Torvalds unsigned offset; 3841da177e4SLinus Torvalds int bsize; 3851da177e4SLinus Torvalds }; 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds static int 388fd582140SJens Axboe lo_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf, 389fd582140SJens Axboe struct splice_desc *sd) 3901da177e4SLinus Torvalds { 391fd582140SJens Axboe struct lo_read_data *p = sd->u.data; 3921da177e4SLinus Torvalds struct loop_device *lo = p->lo; 393fd582140SJens Axboe struct page *page = buf->page; 3941da177e4SLinus Torvalds sector_t IV; 395fd582140SJens Axboe size_t size; 396fd582140SJens Axboe int ret; 3971da177e4SLinus Torvalds 398cac36bb0SJens Axboe ret = buf->ops->confirm(pipe, buf); 399fd582140SJens Axboe if (unlikely(ret)) 400fd582140SJens Axboe return ret; 4011da177e4SLinus Torvalds 402fd582140SJens Axboe IV = ((sector_t) page->index << (PAGE_CACHE_SHIFT - 9)) + 403fd582140SJens Axboe (buf->offset >> 9); 404fd582140SJens Axboe size = sd->len; 405fd582140SJens Axboe if (size > p->bsize) 406fd582140SJens Axboe size = p->bsize; 4071da177e4SLinus Torvalds 408fd582140SJens Axboe if (lo_do_transfer(lo, READ, page, buf->offset, p->page, p->offset, size, IV)) { 4091da177e4SLinus Torvalds printk(KERN_ERR "loop: transfer error block %ld\n", 4101da177e4SLinus Torvalds page->index); 411fd582140SJens Axboe size = -EINVAL; 4121da177e4SLinus Torvalds } 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds flush_dcache_page(p->page); 4151da177e4SLinus Torvalds 416fd582140SJens Axboe if (size > 0) 4171da177e4SLinus Torvalds p->offset += size; 418fd582140SJens Axboe 4191da177e4SLinus Torvalds return size; 4201da177e4SLinus Torvalds } 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds static int 423fd582140SJens Axboe lo_direct_splice_actor(struct pipe_inode_info *pipe, struct splice_desc *sd) 424fd582140SJens Axboe { 425fd582140SJens Axboe return __splice_from_pipe(pipe, sd, lo_splice_actor); 426fd582140SJens Axboe } 427fd582140SJens Axboe 428fd582140SJens Axboe static int 4291da177e4SLinus Torvalds do_lo_receive(struct loop_device *lo, 4301da177e4SLinus Torvalds struct bio_vec *bvec, int bsize, loff_t pos) 4311da177e4SLinus Torvalds { 4321da177e4SLinus Torvalds struct lo_read_data cookie; 433fd582140SJens Axboe struct splice_desc sd; 4341da177e4SLinus Torvalds struct file *file; 435fd582140SJens Axboe long retval; 4361da177e4SLinus Torvalds 4371da177e4SLinus Torvalds cookie.lo = lo; 4381da177e4SLinus Torvalds cookie.page = bvec->bv_page; 4391da177e4SLinus Torvalds cookie.offset = bvec->bv_offset; 4401da177e4SLinus Torvalds cookie.bsize = bsize; 441fd582140SJens Axboe 442fd582140SJens Axboe sd.len = 0; 443fd582140SJens Axboe sd.total_len = bvec->bv_len; 444fd582140SJens Axboe sd.flags = 0; 445fd582140SJens Axboe sd.pos = pos; 446fd582140SJens Axboe sd.u.data = &cookie; 447fd582140SJens Axboe 4481da177e4SLinus Torvalds file = lo->lo_backing_file; 449fd582140SJens Axboe retval = splice_direct_to_actor(file, &sd, lo_direct_splice_actor); 450fd582140SJens Axboe 451fd582140SJens Axboe if (retval < 0) 452fd582140SJens Axboe return retval; 453fd582140SJens Axboe 454fd582140SJens Axboe return 0; 4551da177e4SLinus Torvalds } 4561da177e4SLinus Torvalds 4571da177e4SLinus Torvalds static int 4581da177e4SLinus Torvalds lo_receive(struct loop_device *lo, struct bio *bio, int bsize, loff_t pos) 4591da177e4SLinus Torvalds { 4601da177e4SLinus Torvalds struct bio_vec *bvec; 4611da177e4SLinus Torvalds int i, ret = 0; 4621da177e4SLinus Torvalds 4631da177e4SLinus Torvalds bio_for_each_segment(bvec, bio, i) { 4641da177e4SLinus Torvalds ret = do_lo_receive(lo, bvec, bsize, pos); 4651da177e4SLinus Torvalds if (ret < 0) 4661da177e4SLinus Torvalds break; 4671da177e4SLinus Torvalds pos += bvec->bv_len; 4681da177e4SLinus Torvalds } 4691da177e4SLinus Torvalds return ret; 4701da177e4SLinus Torvalds } 4711da177e4SLinus Torvalds 4721da177e4SLinus Torvalds static int do_bio_filebacked(struct loop_device *lo, struct bio *bio) 4731da177e4SLinus Torvalds { 4741da177e4SLinus Torvalds loff_t pos; 4751da177e4SLinus Torvalds int ret; 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds pos = ((loff_t) bio->bi_sector << 9) + lo->lo_offset; 4781da177e4SLinus Torvalds if (bio_rw(bio) == WRITE) 479511de73fSAl Viro ret = lo_send(lo, bio, pos); 4801da177e4SLinus Torvalds else 4811da177e4SLinus Torvalds ret = lo_receive(lo, bio, lo->lo_blocksize, pos); 4821da177e4SLinus Torvalds return ret; 4831da177e4SLinus Torvalds } 4841da177e4SLinus Torvalds 4851da177e4SLinus Torvalds /* 4861da177e4SLinus Torvalds * Add bio to back of pending list 4871da177e4SLinus Torvalds */ 4881da177e4SLinus Torvalds static void loop_add_bio(struct loop_device *lo, struct bio *bio) 4891da177e4SLinus Torvalds { 4901da177e4SLinus Torvalds if (lo->lo_biotail) { 4911da177e4SLinus Torvalds lo->lo_biotail->bi_next = bio; 4921da177e4SLinus Torvalds lo->lo_biotail = bio; 4931da177e4SLinus Torvalds } else 4941da177e4SLinus Torvalds lo->lo_bio = lo->lo_biotail = bio; 4951da177e4SLinus Torvalds } 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds /* 4981da177e4SLinus Torvalds * Grab first pending buffer 4991da177e4SLinus Torvalds */ 5001da177e4SLinus Torvalds static struct bio *loop_get_bio(struct loop_device *lo) 5011da177e4SLinus Torvalds { 5021da177e4SLinus Torvalds struct bio *bio; 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds if ((bio = lo->lo_bio)) { 5051da177e4SLinus Torvalds if (bio == lo->lo_biotail) 5061da177e4SLinus Torvalds lo->lo_biotail = NULL; 5071da177e4SLinus Torvalds lo->lo_bio = bio->bi_next; 5081da177e4SLinus Torvalds bio->bi_next = NULL; 5091da177e4SLinus Torvalds } 5101da177e4SLinus Torvalds 5111da177e4SLinus Torvalds return bio; 5121da177e4SLinus Torvalds } 5131da177e4SLinus Torvalds 514165125e1SJens Axboe static int loop_make_request(struct request_queue *q, struct bio *old_bio) 5151da177e4SLinus Torvalds { 5161da177e4SLinus Torvalds struct loop_device *lo = q->queuedata; 5171da177e4SLinus Torvalds int rw = bio_rw(old_bio); 5181da177e4SLinus Torvalds 51935a82d1aSNick Piggin if (rw == READA) 52035a82d1aSNick Piggin rw = READ; 52135a82d1aSNick Piggin 52235a82d1aSNick Piggin BUG_ON(!lo || (rw != READ && rw != WRITE)); 5231da177e4SLinus Torvalds 5241da177e4SLinus Torvalds spin_lock_irq(&lo->lo_lock); 5251da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 52635a82d1aSNick Piggin goto out; 52735a82d1aSNick Piggin if (unlikely(rw == WRITE && (lo->lo_flags & LO_FLAGS_READ_ONLY))) 52835a82d1aSNick Piggin goto out; 5291da177e4SLinus Torvalds loop_add_bio(lo, old_bio); 5306c997918SSerge E. Hallyn wake_up(&lo->lo_event); 53135a82d1aSNick Piggin spin_unlock_irq(&lo->lo_lock); 53235a82d1aSNick Piggin return 0; 53335a82d1aSNick Piggin 5341da177e4SLinus Torvalds out: 53535a82d1aSNick Piggin spin_unlock_irq(&lo->lo_lock); 5366712ecf8SNeilBrown bio_io_error(old_bio); 5371da177e4SLinus Torvalds return 0; 5381da177e4SLinus Torvalds } 5391da177e4SLinus Torvalds 5401da177e4SLinus Torvalds /* 5411da177e4SLinus Torvalds * kick off io on the underlying address space 5421da177e4SLinus Torvalds */ 543165125e1SJens Axboe static void loop_unplug(struct request_queue *q) 5441da177e4SLinus Torvalds { 5451da177e4SLinus Torvalds struct loop_device *lo = q->queuedata; 5461da177e4SLinus Torvalds 54775ad23bcSNick Piggin queue_flag_clear_unlocked(QUEUE_FLAG_PLUGGED, q); 5481da177e4SLinus Torvalds blk_run_address_space(lo->lo_backing_file->f_mapping); 5491da177e4SLinus Torvalds } 5501da177e4SLinus Torvalds 5511da177e4SLinus Torvalds struct switch_request { 5521da177e4SLinus Torvalds struct file *file; 5531da177e4SLinus Torvalds struct completion wait; 5541da177e4SLinus Torvalds }; 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds static void do_loop_switch(struct loop_device *, struct switch_request *); 5571da177e4SLinus Torvalds 5581da177e4SLinus Torvalds static inline void loop_handle_bio(struct loop_device *lo, struct bio *bio) 5591da177e4SLinus Torvalds { 5601da177e4SLinus Torvalds if (unlikely(!bio->bi_bdev)) { 5611da177e4SLinus Torvalds do_loop_switch(lo, bio->bi_private); 5621da177e4SLinus Torvalds bio_put(bio); 5631da177e4SLinus Torvalds } else { 56435a82d1aSNick Piggin int ret = do_bio_filebacked(lo, bio); 5656712ecf8SNeilBrown bio_endio(bio, ret); 5661da177e4SLinus Torvalds } 5671da177e4SLinus Torvalds } 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds /* 5701da177e4SLinus Torvalds * worker thread that handles reads/writes to file backed loop devices, 5711da177e4SLinus Torvalds * to avoid blocking in our make_request_fn. it also does loop decrypting 5721da177e4SLinus Torvalds * on reads for block backed loop, as that is too heavy to do from 5731da177e4SLinus Torvalds * b_end_io context where irqs may be disabled. 5746c997918SSerge E. Hallyn * 5756c997918SSerge E. Hallyn * Loop explanation: loop_clr_fd() sets lo_state to Lo_rundown before 5766c997918SSerge E. Hallyn * calling kthread_stop(). Therefore once kthread_should_stop() is 5776c997918SSerge E. Hallyn * true, make_request will not place any more requests. Therefore 5786c997918SSerge E. Hallyn * once kthread_should_stop() is true and lo_bio is NULL, we are 5796c997918SSerge E. Hallyn * done with the loop. 5801da177e4SLinus Torvalds */ 5811da177e4SLinus Torvalds static int loop_thread(void *data) 5821da177e4SLinus Torvalds { 5831da177e4SLinus Torvalds struct loop_device *lo = data; 5841da177e4SLinus Torvalds struct bio *bio; 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds set_user_nice(current, -20); 5871da177e4SLinus Torvalds 5886c997918SSerge E. Hallyn while (!kthread_should_stop() || lo->lo_bio) { 5891da177e4SLinus Torvalds 5906c997918SSerge E. Hallyn wait_event_interruptible(lo->lo_event, 5916c997918SSerge E. Hallyn lo->lo_bio || kthread_should_stop()); 59209c0dc68SLinus Torvalds 5936c997918SSerge E. Hallyn if (!lo->lo_bio) 59435a82d1aSNick Piggin continue; 59535a82d1aSNick Piggin spin_lock_irq(&lo->lo_lock); 5961da177e4SLinus Torvalds bio = loop_get_bio(lo); 59735a82d1aSNick Piggin spin_unlock_irq(&lo->lo_lock); 59835a82d1aSNick Piggin 59935a82d1aSNick Piggin BUG_ON(!bio); 6001da177e4SLinus Torvalds loop_handle_bio(lo, bio); 6011da177e4SLinus Torvalds } 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds return 0; 6041da177e4SLinus Torvalds } 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds /* 6071da177e4SLinus Torvalds * loop_switch performs the hard work of switching a backing store. 6081da177e4SLinus Torvalds * First it needs to flush existing IO, it does this by sending a magic 6091da177e4SLinus Torvalds * BIO down the pipe. The completion of this BIO does the actual switch. 6101da177e4SLinus Torvalds */ 6111da177e4SLinus Torvalds static int loop_switch(struct loop_device *lo, struct file *file) 6121da177e4SLinus Torvalds { 6131da177e4SLinus Torvalds struct switch_request w; 614a24eab1eSJens Axboe struct bio *bio = bio_alloc(GFP_KERNEL, 0); 6151da177e4SLinus Torvalds if (!bio) 6161da177e4SLinus Torvalds return -ENOMEM; 6171da177e4SLinus Torvalds init_completion(&w.wait); 6181da177e4SLinus Torvalds w.file = file; 6191da177e4SLinus Torvalds bio->bi_private = &w; 6201da177e4SLinus Torvalds bio->bi_bdev = NULL; 6211da177e4SLinus Torvalds loop_make_request(lo->lo_queue, bio); 6221da177e4SLinus Torvalds wait_for_completion(&w.wait); 6231da177e4SLinus Torvalds return 0; 6241da177e4SLinus Torvalds } 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds /* 62714f27939SMilan Broz * Helper to flush the IOs in loop, but keeping loop thread running 62814f27939SMilan Broz */ 62914f27939SMilan Broz static int loop_flush(struct loop_device *lo) 63014f27939SMilan Broz { 63114f27939SMilan Broz /* loop not yet configured, no running thread, nothing to flush */ 63214f27939SMilan Broz if (!lo->lo_thread) 63314f27939SMilan Broz return 0; 63414f27939SMilan Broz 63514f27939SMilan Broz return loop_switch(lo, NULL); 63614f27939SMilan Broz } 63714f27939SMilan Broz 63814f27939SMilan Broz /* 6391da177e4SLinus Torvalds * Do the actual switch; called from the BIO completion routine 6401da177e4SLinus Torvalds */ 6411da177e4SLinus Torvalds static void do_loop_switch(struct loop_device *lo, struct switch_request *p) 6421da177e4SLinus Torvalds { 6431da177e4SLinus Torvalds struct file *file = p->file; 6441da177e4SLinus Torvalds struct file *old_file = lo->lo_backing_file; 64514f27939SMilan Broz struct address_space *mapping; 6461da177e4SLinus Torvalds 64714f27939SMilan Broz /* if no new file, only flush of queued bios requested */ 64814f27939SMilan Broz if (!file) 64914f27939SMilan Broz goto out; 65014f27939SMilan Broz 65114f27939SMilan Broz mapping = file->f_mapping; 6521da177e4SLinus Torvalds mapping_set_gfp_mask(old_file->f_mapping, lo->old_gfp_mask); 6531da177e4SLinus Torvalds lo->lo_backing_file = file; 654ba52de12STheodore Ts'o lo->lo_blocksize = S_ISBLK(mapping->host->i_mode) ? 655ba52de12STheodore Ts'o mapping->host->i_bdev->bd_block_size : PAGE_SIZE; 6561da177e4SLinus Torvalds lo->old_gfp_mask = mapping_gfp_mask(mapping); 6571da177e4SLinus Torvalds mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS)); 65814f27939SMilan Broz out: 6591da177e4SLinus Torvalds complete(&p->wait); 6601da177e4SLinus Torvalds } 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds /* 6641da177e4SLinus Torvalds * loop_change_fd switched the backing store of a loopback device to 6651da177e4SLinus Torvalds * a new file. This is useful for operating system installers to free up 6661da177e4SLinus Torvalds * the original file and in High Availability environments to switch to 6671da177e4SLinus Torvalds * an alternative location for the content in case of server meltdown. 6681da177e4SLinus Torvalds * This can only work if the loop device is used read-only, and if the 6691da177e4SLinus Torvalds * new backing store is the same size and type as the old backing store. 6701da177e4SLinus Torvalds */ 671bb214884SAl Viro static int loop_change_fd(struct loop_device *lo, struct block_device *bdev, 672bb214884SAl Viro unsigned int arg) 6731da177e4SLinus Torvalds { 6741da177e4SLinus Torvalds struct file *file, *old_file; 6751da177e4SLinus Torvalds struct inode *inode; 6761da177e4SLinus Torvalds int error; 6771da177e4SLinus Torvalds 6781da177e4SLinus Torvalds error = -ENXIO; 6791da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 6801da177e4SLinus Torvalds goto out; 6811da177e4SLinus Torvalds 6821da177e4SLinus Torvalds /* the loop device has to be read-only */ 6831da177e4SLinus Torvalds error = -EINVAL; 6841da177e4SLinus Torvalds if (!(lo->lo_flags & LO_FLAGS_READ_ONLY)) 6851da177e4SLinus Torvalds goto out; 6861da177e4SLinus Torvalds 6871da177e4SLinus Torvalds error = -EBADF; 6881da177e4SLinus Torvalds file = fget(arg); 6891da177e4SLinus Torvalds if (!file) 6901da177e4SLinus Torvalds goto out; 6911da177e4SLinus Torvalds 6921da177e4SLinus Torvalds inode = file->f_mapping->host; 6931da177e4SLinus Torvalds old_file = lo->lo_backing_file; 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds error = -EINVAL; 6961da177e4SLinus Torvalds 6971da177e4SLinus Torvalds if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode)) 6981da177e4SLinus Torvalds goto out_putf; 6991da177e4SLinus Torvalds 700fd582140SJens Axboe /* new backing store needs to support loop (eg splice_read) */ 701fd582140SJens Axboe if (!inode->i_fop->splice_read) 7021da177e4SLinus Torvalds goto out_putf; 7031da177e4SLinus Torvalds 7041da177e4SLinus Torvalds /* size of the new backing store needs to be the same */ 7051da177e4SLinus Torvalds if (get_loop_size(lo, file) != get_loop_size(lo, old_file)) 7061da177e4SLinus Torvalds goto out_putf; 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds /* and ... switch */ 7091da177e4SLinus Torvalds error = loop_switch(lo, file); 7101da177e4SLinus Torvalds if (error) 7111da177e4SLinus Torvalds goto out_putf; 7121da177e4SLinus Torvalds 7131da177e4SLinus Torvalds fput(old_file); 714476a4813SLaurent Vivier if (max_part > 0) 715476a4813SLaurent Vivier ioctl_by_bdev(bdev, BLKRRPART, 0); 7161da177e4SLinus Torvalds return 0; 7171da177e4SLinus Torvalds 7181da177e4SLinus Torvalds out_putf: 7191da177e4SLinus Torvalds fput(file); 7201da177e4SLinus Torvalds out: 7211da177e4SLinus Torvalds return error; 7221da177e4SLinus Torvalds } 7231da177e4SLinus Torvalds 7241da177e4SLinus Torvalds static inline int is_loop_device(struct file *file) 7251da177e4SLinus Torvalds { 7261da177e4SLinus Torvalds struct inode *i = file->f_mapping->host; 7271da177e4SLinus Torvalds 7281da177e4SLinus Torvalds return i && S_ISBLK(i->i_mode) && MAJOR(i->i_rdev) == LOOP_MAJOR; 7291da177e4SLinus Torvalds } 7301da177e4SLinus Torvalds 731bb214884SAl Viro static int loop_set_fd(struct loop_device *lo, fmode_t mode, 7321da177e4SLinus Torvalds struct block_device *bdev, unsigned int arg) 7331da177e4SLinus Torvalds { 7341da177e4SLinus Torvalds struct file *file, *f; 7351da177e4SLinus Torvalds struct inode *inode; 7361da177e4SLinus Torvalds struct address_space *mapping; 7371da177e4SLinus Torvalds unsigned lo_blocksize; 7381da177e4SLinus Torvalds int lo_flags = 0; 7391da177e4SLinus Torvalds int error; 7401da177e4SLinus Torvalds loff_t size; 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds /* This is safe, since we have a reference from open(). */ 7431da177e4SLinus Torvalds __module_get(THIS_MODULE); 7441da177e4SLinus Torvalds 7451da177e4SLinus Torvalds error = -EBADF; 7461da177e4SLinus Torvalds file = fget(arg); 7471da177e4SLinus Torvalds if (!file) 7481da177e4SLinus Torvalds goto out; 7491da177e4SLinus Torvalds 7501da177e4SLinus Torvalds error = -EBUSY; 7511da177e4SLinus Torvalds if (lo->lo_state != Lo_unbound) 7521da177e4SLinus Torvalds goto out_putf; 7531da177e4SLinus Torvalds 7541da177e4SLinus Torvalds /* Avoid recursion */ 7551da177e4SLinus Torvalds f = file; 7561da177e4SLinus Torvalds while (is_loop_device(f)) { 7571da177e4SLinus Torvalds struct loop_device *l; 7581da177e4SLinus Torvalds 759bb214884SAl Viro if (f->f_mapping->host->i_bdev == bdev) 7601da177e4SLinus Torvalds goto out_putf; 7611da177e4SLinus Torvalds 7621da177e4SLinus Torvalds l = f->f_mapping->host->i_bdev->bd_disk->private_data; 7631da177e4SLinus Torvalds if (l->lo_state == Lo_unbound) { 7641da177e4SLinus Torvalds error = -EINVAL; 7651da177e4SLinus Torvalds goto out_putf; 7661da177e4SLinus Torvalds } 7671da177e4SLinus Torvalds f = l->lo_backing_file; 7681da177e4SLinus Torvalds } 7691da177e4SLinus Torvalds 7701da177e4SLinus Torvalds mapping = file->f_mapping; 7711da177e4SLinus Torvalds inode = mapping->host; 7721da177e4SLinus Torvalds 7731da177e4SLinus Torvalds if (!(file->f_mode & FMODE_WRITE)) 7741da177e4SLinus Torvalds lo_flags |= LO_FLAGS_READ_ONLY; 7751da177e4SLinus Torvalds 7761da177e4SLinus Torvalds error = -EINVAL; 7771da177e4SLinus Torvalds if (S_ISREG(inode->i_mode) || S_ISBLK(inode->i_mode)) { 778f5e54d6eSChristoph Hellwig const struct address_space_operations *aops = mapping->a_ops; 7791da177e4SLinus Torvalds /* 7801da177e4SLinus Torvalds * If we can't read - sorry. If we only can't write - well, 7811da177e4SLinus Torvalds * it's going to be read-only. 7821da177e4SLinus Torvalds */ 783fd582140SJens Axboe if (!file->f_op->splice_read) 7841da177e4SLinus Torvalds goto out_putf; 7854e02ed4bSNick Piggin if (aops->write_begin) 7861da177e4SLinus Torvalds lo_flags |= LO_FLAGS_USE_AOPS; 7871da177e4SLinus Torvalds if (!(lo_flags & LO_FLAGS_USE_AOPS) && !file->f_op->write) 7881da177e4SLinus Torvalds lo_flags |= LO_FLAGS_READ_ONLY; 7891da177e4SLinus Torvalds 790ba52de12STheodore Ts'o lo_blocksize = S_ISBLK(inode->i_mode) ? 791ba52de12STheodore Ts'o inode->i_bdev->bd_block_size : PAGE_SIZE; 792ba52de12STheodore Ts'o 7931da177e4SLinus Torvalds error = 0; 7941da177e4SLinus Torvalds } else { 7951da177e4SLinus Torvalds goto out_putf; 7961da177e4SLinus Torvalds } 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds size = get_loop_size(lo, file); 7991da177e4SLinus Torvalds 8001da177e4SLinus Torvalds if ((loff_t)(sector_t)size != size) { 8011da177e4SLinus Torvalds error = -EFBIG; 8021da177e4SLinus Torvalds goto out_putf; 8031da177e4SLinus Torvalds } 8041da177e4SLinus Torvalds 805bb214884SAl Viro if (!(mode & FMODE_WRITE)) 8061da177e4SLinus Torvalds lo_flags |= LO_FLAGS_READ_ONLY; 8071da177e4SLinus Torvalds 8081da177e4SLinus Torvalds set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0); 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds lo->lo_blocksize = lo_blocksize; 8111da177e4SLinus Torvalds lo->lo_device = bdev; 8121da177e4SLinus Torvalds lo->lo_flags = lo_flags; 8131da177e4SLinus Torvalds lo->lo_backing_file = file; 814eefe85eeSConstantine Sapuntzakis lo->transfer = transfer_none; 8151da177e4SLinus Torvalds lo->ioctl = NULL; 8161da177e4SLinus Torvalds lo->lo_sizelimit = 0; 8171da177e4SLinus Torvalds lo->old_gfp_mask = mapping_gfp_mask(mapping); 8181da177e4SLinus Torvalds mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS)); 8191da177e4SLinus Torvalds 8201da177e4SLinus Torvalds lo->lo_bio = lo->lo_biotail = NULL; 8211da177e4SLinus Torvalds 8221da177e4SLinus Torvalds /* 8231da177e4SLinus Torvalds * set queue make_request_fn, and add limits based on lower level 8241da177e4SLinus Torvalds * device 8251da177e4SLinus Torvalds */ 8261da177e4SLinus Torvalds blk_queue_make_request(lo->lo_queue, loop_make_request); 8271da177e4SLinus Torvalds lo->lo_queue->queuedata = lo; 8281da177e4SLinus Torvalds lo->lo_queue->unplug_fn = loop_unplug; 8291da177e4SLinus Torvalds 83073285082SKen Chen set_capacity(lo->lo_disk, size); 8311da177e4SLinus Torvalds bd_set_size(bdev, size << 9); 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds set_blocksize(bdev, lo_blocksize); 8341da177e4SLinus Torvalds 8356c997918SSerge E. Hallyn lo->lo_thread = kthread_create(loop_thread, lo, "loop%d", 8366c997918SSerge E. Hallyn lo->lo_number); 8376c997918SSerge E. Hallyn if (IS_ERR(lo->lo_thread)) { 8386c997918SSerge E. Hallyn error = PTR_ERR(lo->lo_thread); 839a7422bf8SSerge E. Hallyn goto out_clr; 8406c997918SSerge E. Hallyn } 8416c997918SSerge E. Hallyn lo->lo_state = Lo_bound; 8426c997918SSerge E. Hallyn wake_up_process(lo->lo_thread); 843476a4813SLaurent Vivier if (max_part > 0) 844476a4813SLaurent Vivier ioctl_by_bdev(bdev, BLKRRPART, 0); 8451da177e4SLinus Torvalds return 0; 8461da177e4SLinus Torvalds 847a7422bf8SSerge E. Hallyn out_clr: 848a7422bf8SSerge E. Hallyn lo->lo_thread = NULL; 849a7422bf8SSerge E. Hallyn lo->lo_device = NULL; 850a7422bf8SSerge E. Hallyn lo->lo_backing_file = NULL; 851a7422bf8SSerge E. Hallyn lo->lo_flags = 0; 85273285082SKen Chen set_capacity(lo->lo_disk, 0); 853f98393a6SPeter Zijlstra invalidate_bdev(bdev); 854a7422bf8SSerge E. Hallyn bd_set_size(bdev, 0); 855a7422bf8SSerge E. Hallyn mapping_set_gfp_mask(mapping, lo->old_gfp_mask); 856a7422bf8SSerge E. Hallyn lo->lo_state = Lo_unbound; 8571da177e4SLinus Torvalds out_putf: 8581da177e4SLinus Torvalds fput(file); 8591da177e4SLinus Torvalds out: 8601da177e4SLinus Torvalds /* This is safe: open() is still holding a reference. */ 8611da177e4SLinus Torvalds module_put(THIS_MODULE); 8621da177e4SLinus Torvalds return error; 8631da177e4SLinus Torvalds } 8641da177e4SLinus Torvalds 8651da177e4SLinus Torvalds static int 8661da177e4SLinus Torvalds loop_release_xfer(struct loop_device *lo) 8671da177e4SLinus Torvalds { 8681da177e4SLinus Torvalds int err = 0; 8691da177e4SLinus Torvalds struct loop_func_table *xfer = lo->lo_encryption; 8701da177e4SLinus Torvalds 8711da177e4SLinus Torvalds if (xfer) { 8721da177e4SLinus Torvalds if (xfer->release) 8731da177e4SLinus Torvalds err = xfer->release(lo); 8741da177e4SLinus Torvalds lo->transfer = NULL; 8751da177e4SLinus Torvalds lo->lo_encryption = NULL; 8761da177e4SLinus Torvalds module_put(xfer->owner); 8771da177e4SLinus Torvalds } 8781da177e4SLinus Torvalds return err; 8791da177e4SLinus Torvalds } 8801da177e4SLinus Torvalds 8811da177e4SLinus Torvalds static int 8821da177e4SLinus Torvalds loop_init_xfer(struct loop_device *lo, struct loop_func_table *xfer, 8831da177e4SLinus Torvalds const struct loop_info64 *i) 8841da177e4SLinus Torvalds { 8851da177e4SLinus Torvalds int err = 0; 8861da177e4SLinus Torvalds 8871da177e4SLinus Torvalds if (xfer) { 8881da177e4SLinus Torvalds struct module *owner = xfer->owner; 8891da177e4SLinus Torvalds 8901da177e4SLinus Torvalds if (!try_module_get(owner)) 8911da177e4SLinus Torvalds return -EINVAL; 8921da177e4SLinus Torvalds if (xfer->init) 8931da177e4SLinus Torvalds err = xfer->init(lo, i); 8941da177e4SLinus Torvalds if (err) 8951da177e4SLinus Torvalds module_put(owner); 8961da177e4SLinus Torvalds else 8971da177e4SLinus Torvalds lo->lo_encryption = xfer; 8981da177e4SLinus Torvalds } 8991da177e4SLinus Torvalds return err; 9001da177e4SLinus Torvalds } 9011da177e4SLinus Torvalds 9021da177e4SLinus Torvalds static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev) 9031da177e4SLinus Torvalds { 9041da177e4SLinus Torvalds struct file *filp = lo->lo_backing_file; 905b4e3ca1aSAl Viro gfp_t gfp = lo->old_gfp_mask; 9061da177e4SLinus Torvalds 9071da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 9081da177e4SLinus Torvalds return -ENXIO; 9091da177e4SLinus Torvalds 9101da177e4SLinus Torvalds if (lo->lo_refcnt > 1) /* we needed one fd for the ioctl */ 9111da177e4SLinus Torvalds return -EBUSY; 9121da177e4SLinus Torvalds 9131da177e4SLinus Torvalds if (filp == NULL) 9141da177e4SLinus Torvalds return -EINVAL; 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds spin_lock_irq(&lo->lo_lock); 9171da177e4SLinus Torvalds lo->lo_state = Lo_rundown; 9181da177e4SLinus Torvalds spin_unlock_irq(&lo->lo_lock); 9191da177e4SLinus Torvalds 9206c997918SSerge E. Hallyn kthread_stop(lo->lo_thread); 9211da177e4SLinus Torvalds 922*8ae30b89SMilan Broz lo->lo_queue->unplug_fn = NULL; 9231da177e4SLinus Torvalds lo->lo_backing_file = NULL; 9241da177e4SLinus Torvalds 9251da177e4SLinus Torvalds loop_release_xfer(lo); 9261da177e4SLinus Torvalds lo->transfer = NULL; 9271da177e4SLinus Torvalds lo->ioctl = NULL; 9281da177e4SLinus Torvalds lo->lo_device = NULL; 9291da177e4SLinus Torvalds lo->lo_encryption = NULL; 9301da177e4SLinus Torvalds lo->lo_offset = 0; 9311da177e4SLinus Torvalds lo->lo_sizelimit = 0; 9321da177e4SLinus Torvalds lo->lo_encrypt_key_size = 0; 9331da177e4SLinus Torvalds lo->lo_flags = 0; 9346c997918SSerge E. Hallyn lo->lo_thread = NULL; 9351da177e4SLinus Torvalds memset(lo->lo_encrypt_key, 0, LO_KEY_SIZE); 9361da177e4SLinus Torvalds memset(lo->lo_crypt_name, 0, LO_NAME_SIZE); 9371da177e4SLinus Torvalds memset(lo->lo_file_name, 0, LO_NAME_SIZE); 938bb214884SAl Viro if (bdev) 939f98393a6SPeter Zijlstra invalidate_bdev(bdev); 94073285082SKen Chen set_capacity(lo->lo_disk, 0); 941bb214884SAl Viro if (bdev) 9421da177e4SLinus Torvalds bd_set_size(bdev, 0); 9431da177e4SLinus Torvalds mapping_set_gfp_mask(filp->f_mapping, gfp); 9441da177e4SLinus Torvalds lo->lo_state = Lo_unbound; 9451da177e4SLinus Torvalds fput(filp); 9461da177e4SLinus Torvalds /* This is safe: open() is still holding a reference. */ 9471da177e4SLinus Torvalds module_put(THIS_MODULE); 948476a4813SLaurent Vivier if (max_part > 0) 949476a4813SLaurent Vivier ioctl_by_bdev(bdev, BLKRRPART, 0); 9501da177e4SLinus Torvalds return 0; 9511da177e4SLinus Torvalds } 9521da177e4SLinus Torvalds 9531da177e4SLinus Torvalds static int 9541da177e4SLinus Torvalds loop_set_status(struct loop_device *lo, const struct loop_info64 *info) 9551da177e4SLinus Torvalds { 9561da177e4SLinus Torvalds int err; 9571da177e4SLinus Torvalds struct loop_func_table *xfer; 958b0fafa81SDavid Howells uid_t uid = current_uid(); 9591da177e4SLinus Torvalds 960b0fafa81SDavid Howells if (lo->lo_encrypt_key_size && 961b0fafa81SDavid Howells lo->lo_key_owner != uid && 9621da177e4SLinus Torvalds !capable(CAP_SYS_ADMIN)) 9631da177e4SLinus Torvalds return -EPERM; 9641da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 9651da177e4SLinus Torvalds return -ENXIO; 9661da177e4SLinus Torvalds if ((unsigned int) info->lo_encrypt_key_size > LO_KEY_SIZE) 9671da177e4SLinus Torvalds return -EINVAL; 9681da177e4SLinus Torvalds 9691da177e4SLinus Torvalds err = loop_release_xfer(lo); 9701da177e4SLinus Torvalds if (err) 9711da177e4SLinus Torvalds return err; 9721da177e4SLinus Torvalds 9731da177e4SLinus Torvalds if (info->lo_encrypt_type) { 9741da177e4SLinus Torvalds unsigned int type = info->lo_encrypt_type; 9751da177e4SLinus Torvalds 9761da177e4SLinus Torvalds if (type >= MAX_LO_CRYPT) 9771da177e4SLinus Torvalds return -EINVAL; 9781da177e4SLinus Torvalds xfer = xfer_funcs[type]; 9791da177e4SLinus Torvalds if (xfer == NULL) 9801da177e4SLinus Torvalds return -EINVAL; 9811da177e4SLinus Torvalds } else 9821da177e4SLinus Torvalds xfer = NULL; 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds err = loop_init_xfer(lo, xfer, info); 9851da177e4SLinus Torvalds if (err) 9861da177e4SLinus Torvalds return err; 9871da177e4SLinus Torvalds 9881da177e4SLinus Torvalds if (lo->lo_offset != info->lo_offset || 9891da177e4SLinus Torvalds lo->lo_sizelimit != info->lo_sizelimit) { 9901da177e4SLinus Torvalds lo->lo_offset = info->lo_offset; 9911da177e4SLinus Torvalds lo->lo_sizelimit = info->lo_sizelimit; 9921da177e4SLinus Torvalds if (figure_loop_size(lo)) 9931da177e4SLinus Torvalds return -EFBIG; 9941da177e4SLinus Torvalds } 9951da177e4SLinus Torvalds 9961da177e4SLinus Torvalds memcpy(lo->lo_file_name, info->lo_file_name, LO_NAME_SIZE); 9971da177e4SLinus Torvalds memcpy(lo->lo_crypt_name, info->lo_crypt_name, LO_NAME_SIZE); 9981da177e4SLinus Torvalds lo->lo_file_name[LO_NAME_SIZE-1] = 0; 9991da177e4SLinus Torvalds lo->lo_crypt_name[LO_NAME_SIZE-1] = 0; 10001da177e4SLinus Torvalds 10011da177e4SLinus Torvalds if (!xfer) 10021da177e4SLinus Torvalds xfer = &none_funcs; 10031da177e4SLinus Torvalds lo->transfer = xfer->transfer; 10041da177e4SLinus Torvalds lo->ioctl = xfer->ioctl; 10051da177e4SLinus Torvalds 100696c58655SDavid Woodhouse if ((lo->lo_flags & LO_FLAGS_AUTOCLEAR) != 100796c58655SDavid Woodhouse (info->lo_flags & LO_FLAGS_AUTOCLEAR)) 100896c58655SDavid Woodhouse lo->lo_flags ^= LO_FLAGS_AUTOCLEAR; 100996c58655SDavid Woodhouse 10101da177e4SLinus Torvalds lo->lo_encrypt_key_size = info->lo_encrypt_key_size; 10111da177e4SLinus Torvalds lo->lo_init[0] = info->lo_init[0]; 10121da177e4SLinus Torvalds lo->lo_init[1] = info->lo_init[1]; 10131da177e4SLinus Torvalds if (info->lo_encrypt_key_size) { 10141da177e4SLinus Torvalds memcpy(lo->lo_encrypt_key, info->lo_encrypt_key, 10151da177e4SLinus Torvalds info->lo_encrypt_key_size); 1016b0fafa81SDavid Howells lo->lo_key_owner = uid; 10171da177e4SLinus Torvalds } 10181da177e4SLinus Torvalds 10191da177e4SLinus Torvalds return 0; 10201da177e4SLinus Torvalds } 10211da177e4SLinus Torvalds 10221da177e4SLinus Torvalds static int 10231da177e4SLinus Torvalds loop_get_status(struct loop_device *lo, struct loop_info64 *info) 10241da177e4SLinus Torvalds { 10251da177e4SLinus Torvalds struct file *file = lo->lo_backing_file; 10261da177e4SLinus Torvalds struct kstat stat; 10271da177e4SLinus Torvalds int error; 10281da177e4SLinus Torvalds 10291da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 10301da177e4SLinus Torvalds return -ENXIO; 10316c648be6SJosef Sipek error = vfs_getattr(file->f_path.mnt, file->f_path.dentry, &stat); 10321da177e4SLinus Torvalds if (error) 10331da177e4SLinus Torvalds return error; 10341da177e4SLinus Torvalds memset(info, 0, sizeof(*info)); 10351da177e4SLinus Torvalds info->lo_number = lo->lo_number; 10361da177e4SLinus Torvalds info->lo_device = huge_encode_dev(stat.dev); 10371da177e4SLinus Torvalds info->lo_inode = stat.ino; 10381da177e4SLinus Torvalds info->lo_rdevice = huge_encode_dev(lo->lo_device ? stat.rdev : stat.dev); 10391da177e4SLinus Torvalds info->lo_offset = lo->lo_offset; 10401da177e4SLinus Torvalds info->lo_sizelimit = lo->lo_sizelimit; 10411da177e4SLinus Torvalds info->lo_flags = lo->lo_flags; 10421da177e4SLinus Torvalds memcpy(info->lo_file_name, lo->lo_file_name, LO_NAME_SIZE); 10431da177e4SLinus Torvalds memcpy(info->lo_crypt_name, lo->lo_crypt_name, LO_NAME_SIZE); 10441da177e4SLinus Torvalds info->lo_encrypt_type = 10451da177e4SLinus Torvalds lo->lo_encryption ? lo->lo_encryption->number : 0; 10461da177e4SLinus Torvalds if (lo->lo_encrypt_key_size && capable(CAP_SYS_ADMIN)) { 10471da177e4SLinus Torvalds info->lo_encrypt_key_size = lo->lo_encrypt_key_size; 10481da177e4SLinus Torvalds memcpy(info->lo_encrypt_key, lo->lo_encrypt_key, 10491da177e4SLinus Torvalds lo->lo_encrypt_key_size); 10501da177e4SLinus Torvalds } 10511da177e4SLinus Torvalds return 0; 10521da177e4SLinus Torvalds } 10531da177e4SLinus Torvalds 10541da177e4SLinus Torvalds static void 10551da177e4SLinus Torvalds loop_info64_from_old(const struct loop_info *info, struct loop_info64 *info64) 10561da177e4SLinus Torvalds { 10571da177e4SLinus Torvalds memset(info64, 0, sizeof(*info64)); 10581da177e4SLinus Torvalds info64->lo_number = info->lo_number; 10591da177e4SLinus Torvalds info64->lo_device = info->lo_device; 10601da177e4SLinus Torvalds info64->lo_inode = info->lo_inode; 10611da177e4SLinus Torvalds info64->lo_rdevice = info->lo_rdevice; 10621da177e4SLinus Torvalds info64->lo_offset = info->lo_offset; 10631da177e4SLinus Torvalds info64->lo_sizelimit = 0; 10641da177e4SLinus Torvalds info64->lo_encrypt_type = info->lo_encrypt_type; 10651da177e4SLinus Torvalds info64->lo_encrypt_key_size = info->lo_encrypt_key_size; 10661da177e4SLinus Torvalds info64->lo_flags = info->lo_flags; 10671da177e4SLinus Torvalds info64->lo_init[0] = info->lo_init[0]; 10681da177e4SLinus Torvalds info64->lo_init[1] = info->lo_init[1]; 10691da177e4SLinus Torvalds if (info->lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 10701da177e4SLinus Torvalds memcpy(info64->lo_crypt_name, info->lo_name, LO_NAME_SIZE); 10711da177e4SLinus Torvalds else 10721da177e4SLinus Torvalds memcpy(info64->lo_file_name, info->lo_name, LO_NAME_SIZE); 10731da177e4SLinus Torvalds memcpy(info64->lo_encrypt_key, info->lo_encrypt_key, LO_KEY_SIZE); 10741da177e4SLinus Torvalds } 10751da177e4SLinus Torvalds 10761da177e4SLinus Torvalds static int 10771da177e4SLinus Torvalds loop_info64_to_old(const struct loop_info64 *info64, struct loop_info *info) 10781da177e4SLinus Torvalds { 10791da177e4SLinus Torvalds memset(info, 0, sizeof(*info)); 10801da177e4SLinus Torvalds info->lo_number = info64->lo_number; 10811da177e4SLinus Torvalds info->lo_device = info64->lo_device; 10821da177e4SLinus Torvalds info->lo_inode = info64->lo_inode; 10831da177e4SLinus Torvalds info->lo_rdevice = info64->lo_rdevice; 10841da177e4SLinus Torvalds info->lo_offset = info64->lo_offset; 10851da177e4SLinus Torvalds info->lo_encrypt_type = info64->lo_encrypt_type; 10861da177e4SLinus Torvalds info->lo_encrypt_key_size = info64->lo_encrypt_key_size; 10871da177e4SLinus Torvalds info->lo_flags = info64->lo_flags; 10881da177e4SLinus Torvalds info->lo_init[0] = info64->lo_init[0]; 10891da177e4SLinus Torvalds info->lo_init[1] = info64->lo_init[1]; 10901da177e4SLinus Torvalds if (info->lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 10911da177e4SLinus Torvalds memcpy(info->lo_name, info64->lo_crypt_name, LO_NAME_SIZE); 10921da177e4SLinus Torvalds else 10931da177e4SLinus Torvalds memcpy(info->lo_name, info64->lo_file_name, LO_NAME_SIZE); 10941da177e4SLinus Torvalds memcpy(info->lo_encrypt_key, info64->lo_encrypt_key, LO_KEY_SIZE); 10951da177e4SLinus Torvalds 10961da177e4SLinus Torvalds /* error in case values were truncated */ 10971da177e4SLinus Torvalds if (info->lo_device != info64->lo_device || 10981da177e4SLinus Torvalds info->lo_rdevice != info64->lo_rdevice || 10991da177e4SLinus Torvalds info->lo_inode != info64->lo_inode || 11001da177e4SLinus Torvalds info->lo_offset != info64->lo_offset) 11011da177e4SLinus Torvalds return -EOVERFLOW; 11021da177e4SLinus Torvalds 11031da177e4SLinus Torvalds return 0; 11041da177e4SLinus Torvalds } 11051da177e4SLinus Torvalds 11061da177e4SLinus Torvalds static int 11071da177e4SLinus Torvalds loop_set_status_old(struct loop_device *lo, const struct loop_info __user *arg) 11081da177e4SLinus Torvalds { 11091da177e4SLinus Torvalds struct loop_info info; 11101da177e4SLinus Torvalds struct loop_info64 info64; 11111da177e4SLinus Torvalds 11121da177e4SLinus Torvalds if (copy_from_user(&info, arg, sizeof (struct loop_info))) 11131da177e4SLinus Torvalds return -EFAULT; 11141da177e4SLinus Torvalds loop_info64_from_old(&info, &info64); 11151da177e4SLinus Torvalds return loop_set_status(lo, &info64); 11161da177e4SLinus Torvalds } 11171da177e4SLinus Torvalds 11181da177e4SLinus Torvalds static int 11191da177e4SLinus Torvalds loop_set_status64(struct loop_device *lo, const struct loop_info64 __user *arg) 11201da177e4SLinus Torvalds { 11211da177e4SLinus Torvalds struct loop_info64 info64; 11221da177e4SLinus Torvalds 11231da177e4SLinus Torvalds if (copy_from_user(&info64, arg, sizeof (struct loop_info64))) 11241da177e4SLinus Torvalds return -EFAULT; 11251da177e4SLinus Torvalds return loop_set_status(lo, &info64); 11261da177e4SLinus Torvalds } 11271da177e4SLinus Torvalds 11281da177e4SLinus Torvalds static int 11291da177e4SLinus Torvalds loop_get_status_old(struct loop_device *lo, struct loop_info __user *arg) { 11301da177e4SLinus Torvalds struct loop_info info; 11311da177e4SLinus Torvalds struct loop_info64 info64; 11321da177e4SLinus Torvalds int err = 0; 11331da177e4SLinus Torvalds 11341da177e4SLinus Torvalds if (!arg) 11351da177e4SLinus Torvalds err = -EINVAL; 11361da177e4SLinus Torvalds if (!err) 11371da177e4SLinus Torvalds err = loop_get_status(lo, &info64); 11381da177e4SLinus Torvalds if (!err) 11391da177e4SLinus Torvalds err = loop_info64_to_old(&info64, &info); 11401da177e4SLinus Torvalds if (!err && copy_to_user(arg, &info, sizeof(info))) 11411da177e4SLinus Torvalds err = -EFAULT; 11421da177e4SLinus Torvalds 11431da177e4SLinus Torvalds return err; 11441da177e4SLinus Torvalds } 11451da177e4SLinus Torvalds 11461da177e4SLinus Torvalds static int 11471da177e4SLinus Torvalds loop_get_status64(struct loop_device *lo, struct loop_info64 __user *arg) { 11481da177e4SLinus Torvalds struct loop_info64 info64; 11491da177e4SLinus Torvalds int err = 0; 11501da177e4SLinus Torvalds 11511da177e4SLinus Torvalds if (!arg) 11521da177e4SLinus Torvalds err = -EINVAL; 11531da177e4SLinus Torvalds if (!err) 11541da177e4SLinus Torvalds err = loop_get_status(lo, &info64); 11551da177e4SLinus Torvalds if (!err && copy_to_user(arg, &info64, sizeof(info64))) 11561da177e4SLinus Torvalds err = -EFAULT; 11571da177e4SLinus Torvalds 11581da177e4SLinus Torvalds return err; 11591da177e4SLinus Torvalds } 11601da177e4SLinus Torvalds 1161bb214884SAl Viro static int lo_ioctl(struct block_device *bdev, fmode_t mode, 11621da177e4SLinus Torvalds unsigned int cmd, unsigned long arg) 11631da177e4SLinus Torvalds { 1164bb214884SAl Viro struct loop_device *lo = bdev->bd_disk->private_data; 11651da177e4SLinus Torvalds int err; 11661da177e4SLinus Torvalds 1167f85221ddSIngo Molnar mutex_lock(&lo->lo_ctl_mutex); 11681da177e4SLinus Torvalds switch (cmd) { 11691da177e4SLinus Torvalds case LOOP_SET_FD: 1170bb214884SAl Viro err = loop_set_fd(lo, mode, bdev, arg); 11711da177e4SLinus Torvalds break; 11721da177e4SLinus Torvalds case LOOP_CHANGE_FD: 1173bb214884SAl Viro err = loop_change_fd(lo, bdev, arg); 11741da177e4SLinus Torvalds break; 11751da177e4SLinus Torvalds case LOOP_CLR_FD: 1176bb214884SAl Viro err = loop_clr_fd(lo, bdev); 11771da177e4SLinus Torvalds break; 11781da177e4SLinus Torvalds case LOOP_SET_STATUS: 11791da177e4SLinus Torvalds err = loop_set_status_old(lo, (struct loop_info __user *) arg); 11801da177e4SLinus Torvalds break; 11811da177e4SLinus Torvalds case LOOP_GET_STATUS: 11821da177e4SLinus Torvalds err = loop_get_status_old(lo, (struct loop_info __user *) arg); 11831da177e4SLinus Torvalds break; 11841da177e4SLinus Torvalds case LOOP_SET_STATUS64: 11851da177e4SLinus Torvalds err = loop_set_status64(lo, (struct loop_info64 __user *) arg); 11861da177e4SLinus Torvalds break; 11871da177e4SLinus Torvalds case LOOP_GET_STATUS64: 11881da177e4SLinus Torvalds err = loop_get_status64(lo, (struct loop_info64 __user *) arg); 11891da177e4SLinus Torvalds break; 11901da177e4SLinus Torvalds default: 11911da177e4SLinus Torvalds err = lo->ioctl ? lo->ioctl(lo, cmd, arg) : -EINVAL; 11921da177e4SLinus Torvalds } 1193f85221ddSIngo Molnar mutex_unlock(&lo->lo_ctl_mutex); 11941da177e4SLinus Torvalds return err; 11951da177e4SLinus Torvalds } 11961da177e4SLinus Torvalds 1197863d5b82SDavid Howells #ifdef CONFIG_COMPAT 1198863d5b82SDavid Howells struct compat_loop_info { 1199863d5b82SDavid Howells compat_int_t lo_number; /* ioctl r/o */ 1200863d5b82SDavid Howells compat_dev_t lo_device; /* ioctl r/o */ 1201863d5b82SDavid Howells compat_ulong_t lo_inode; /* ioctl r/o */ 1202863d5b82SDavid Howells compat_dev_t lo_rdevice; /* ioctl r/o */ 1203863d5b82SDavid Howells compat_int_t lo_offset; 1204863d5b82SDavid Howells compat_int_t lo_encrypt_type; 1205863d5b82SDavid Howells compat_int_t lo_encrypt_key_size; /* ioctl w/o */ 1206863d5b82SDavid Howells compat_int_t lo_flags; /* ioctl r/o */ 1207863d5b82SDavid Howells char lo_name[LO_NAME_SIZE]; 1208863d5b82SDavid Howells unsigned char lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */ 1209863d5b82SDavid Howells compat_ulong_t lo_init[2]; 1210863d5b82SDavid Howells char reserved[4]; 1211863d5b82SDavid Howells }; 1212863d5b82SDavid Howells 1213863d5b82SDavid Howells /* 1214863d5b82SDavid Howells * Transfer 32-bit compatibility structure in userspace to 64-bit loop info 1215863d5b82SDavid Howells * - noinlined to reduce stack space usage in main part of driver 1216863d5b82SDavid Howells */ 1217863d5b82SDavid Howells static noinline int 1218ba674cfcSAl Viro loop_info64_from_compat(const struct compat_loop_info __user *arg, 1219863d5b82SDavid Howells struct loop_info64 *info64) 1220863d5b82SDavid Howells { 1221863d5b82SDavid Howells struct compat_loop_info info; 1222863d5b82SDavid Howells 1223863d5b82SDavid Howells if (copy_from_user(&info, arg, sizeof(info))) 1224863d5b82SDavid Howells return -EFAULT; 1225863d5b82SDavid Howells 1226863d5b82SDavid Howells memset(info64, 0, sizeof(*info64)); 1227863d5b82SDavid Howells info64->lo_number = info.lo_number; 1228863d5b82SDavid Howells info64->lo_device = info.lo_device; 1229863d5b82SDavid Howells info64->lo_inode = info.lo_inode; 1230863d5b82SDavid Howells info64->lo_rdevice = info.lo_rdevice; 1231863d5b82SDavid Howells info64->lo_offset = info.lo_offset; 1232863d5b82SDavid Howells info64->lo_sizelimit = 0; 1233863d5b82SDavid Howells info64->lo_encrypt_type = info.lo_encrypt_type; 1234863d5b82SDavid Howells info64->lo_encrypt_key_size = info.lo_encrypt_key_size; 1235863d5b82SDavid Howells info64->lo_flags = info.lo_flags; 1236863d5b82SDavid Howells info64->lo_init[0] = info.lo_init[0]; 1237863d5b82SDavid Howells info64->lo_init[1] = info.lo_init[1]; 1238863d5b82SDavid Howells if (info.lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 1239863d5b82SDavid Howells memcpy(info64->lo_crypt_name, info.lo_name, LO_NAME_SIZE); 1240863d5b82SDavid Howells else 1241863d5b82SDavid Howells memcpy(info64->lo_file_name, info.lo_name, LO_NAME_SIZE); 1242863d5b82SDavid Howells memcpy(info64->lo_encrypt_key, info.lo_encrypt_key, LO_KEY_SIZE); 1243863d5b82SDavid Howells return 0; 1244863d5b82SDavid Howells } 1245863d5b82SDavid Howells 1246863d5b82SDavid Howells /* 1247863d5b82SDavid Howells * Transfer 64-bit loop info to 32-bit compatibility structure in userspace 1248863d5b82SDavid Howells * - noinlined to reduce stack space usage in main part of driver 1249863d5b82SDavid Howells */ 1250863d5b82SDavid Howells static noinline int 1251863d5b82SDavid Howells loop_info64_to_compat(const struct loop_info64 *info64, 1252863d5b82SDavid Howells struct compat_loop_info __user *arg) 1253863d5b82SDavid Howells { 1254863d5b82SDavid Howells struct compat_loop_info info; 1255863d5b82SDavid Howells 1256863d5b82SDavid Howells memset(&info, 0, sizeof(info)); 1257863d5b82SDavid Howells info.lo_number = info64->lo_number; 1258863d5b82SDavid Howells info.lo_device = info64->lo_device; 1259863d5b82SDavid Howells info.lo_inode = info64->lo_inode; 1260863d5b82SDavid Howells info.lo_rdevice = info64->lo_rdevice; 1261863d5b82SDavid Howells info.lo_offset = info64->lo_offset; 1262863d5b82SDavid Howells info.lo_encrypt_type = info64->lo_encrypt_type; 1263863d5b82SDavid Howells info.lo_encrypt_key_size = info64->lo_encrypt_key_size; 1264863d5b82SDavid Howells info.lo_flags = info64->lo_flags; 1265863d5b82SDavid Howells info.lo_init[0] = info64->lo_init[0]; 1266863d5b82SDavid Howells info.lo_init[1] = info64->lo_init[1]; 1267863d5b82SDavid Howells if (info.lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 1268863d5b82SDavid Howells memcpy(info.lo_name, info64->lo_crypt_name, LO_NAME_SIZE); 1269863d5b82SDavid Howells else 1270863d5b82SDavid Howells memcpy(info.lo_name, info64->lo_file_name, LO_NAME_SIZE); 1271863d5b82SDavid Howells memcpy(info.lo_encrypt_key, info64->lo_encrypt_key, LO_KEY_SIZE); 1272863d5b82SDavid Howells 1273863d5b82SDavid Howells /* error in case values were truncated */ 1274863d5b82SDavid Howells if (info.lo_device != info64->lo_device || 1275863d5b82SDavid Howells info.lo_rdevice != info64->lo_rdevice || 1276863d5b82SDavid Howells info.lo_inode != info64->lo_inode || 1277863d5b82SDavid Howells info.lo_offset != info64->lo_offset || 1278863d5b82SDavid Howells info.lo_init[0] != info64->lo_init[0] || 1279863d5b82SDavid Howells info.lo_init[1] != info64->lo_init[1]) 1280863d5b82SDavid Howells return -EOVERFLOW; 1281863d5b82SDavid Howells 1282863d5b82SDavid Howells if (copy_to_user(arg, &info, sizeof(info))) 1283863d5b82SDavid Howells return -EFAULT; 1284863d5b82SDavid Howells return 0; 1285863d5b82SDavid Howells } 1286863d5b82SDavid Howells 1287863d5b82SDavid Howells static int 1288863d5b82SDavid Howells loop_set_status_compat(struct loop_device *lo, 1289863d5b82SDavid Howells const struct compat_loop_info __user *arg) 1290863d5b82SDavid Howells { 1291863d5b82SDavid Howells struct loop_info64 info64; 1292863d5b82SDavid Howells int ret; 1293863d5b82SDavid Howells 1294863d5b82SDavid Howells ret = loop_info64_from_compat(arg, &info64); 1295863d5b82SDavid Howells if (ret < 0) 1296863d5b82SDavid Howells return ret; 1297863d5b82SDavid Howells return loop_set_status(lo, &info64); 1298863d5b82SDavid Howells } 1299863d5b82SDavid Howells 1300863d5b82SDavid Howells static int 1301863d5b82SDavid Howells loop_get_status_compat(struct loop_device *lo, 1302863d5b82SDavid Howells struct compat_loop_info __user *arg) 1303863d5b82SDavid Howells { 1304863d5b82SDavid Howells struct loop_info64 info64; 1305863d5b82SDavid Howells int err = 0; 1306863d5b82SDavid Howells 1307863d5b82SDavid Howells if (!arg) 1308863d5b82SDavid Howells err = -EINVAL; 1309863d5b82SDavid Howells if (!err) 1310863d5b82SDavid Howells err = loop_get_status(lo, &info64); 1311863d5b82SDavid Howells if (!err) 1312863d5b82SDavid Howells err = loop_info64_to_compat(&info64, arg); 1313863d5b82SDavid Howells return err; 1314863d5b82SDavid Howells } 1315863d5b82SDavid Howells 1316bb214884SAl Viro static int lo_compat_ioctl(struct block_device *bdev, fmode_t mode, 1317bb214884SAl Viro unsigned int cmd, unsigned long arg) 1318863d5b82SDavid Howells { 1319bb214884SAl Viro struct loop_device *lo = bdev->bd_disk->private_data; 1320863d5b82SDavid Howells int err; 1321863d5b82SDavid Howells 1322863d5b82SDavid Howells switch(cmd) { 1323863d5b82SDavid Howells case LOOP_SET_STATUS: 1324863d5b82SDavid Howells mutex_lock(&lo->lo_ctl_mutex); 1325863d5b82SDavid Howells err = loop_set_status_compat( 1326863d5b82SDavid Howells lo, (const struct compat_loop_info __user *) arg); 1327863d5b82SDavid Howells mutex_unlock(&lo->lo_ctl_mutex); 1328863d5b82SDavid Howells break; 1329863d5b82SDavid Howells case LOOP_GET_STATUS: 1330863d5b82SDavid Howells mutex_lock(&lo->lo_ctl_mutex); 1331863d5b82SDavid Howells err = loop_get_status_compat( 1332863d5b82SDavid Howells lo, (struct compat_loop_info __user *) arg); 1333863d5b82SDavid Howells mutex_unlock(&lo->lo_ctl_mutex); 1334863d5b82SDavid Howells break; 1335863d5b82SDavid Howells case LOOP_CLR_FD: 1336863d5b82SDavid Howells case LOOP_GET_STATUS64: 1337863d5b82SDavid Howells case LOOP_SET_STATUS64: 1338863d5b82SDavid Howells arg = (unsigned long) compat_ptr(arg); 1339863d5b82SDavid Howells case LOOP_SET_FD: 1340863d5b82SDavid Howells case LOOP_CHANGE_FD: 1341bb214884SAl Viro err = lo_ioctl(bdev, mode, cmd, arg); 1342863d5b82SDavid Howells break; 1343863d5b82SDavid Howells default: 1344863d5b82SDavid Howells err = -ENOIOCTLCMD; 1345863d5b82SDavid Howells break; 1346863d5b82SDavid Howells } 1347863d5b82SDavid Howells return err; 1348863d5b82SDavid Howells } 1349863d5b82SDavid Howells #endif 1350863d5b82SDavid Howells 1351bb214884SAl Viro static int lo_open(struct block_device *bdev, fmode_t mode) 13521da177e4SLinus Torvalds { 1353bb214884SAl Viro struct loop_device *lo = bdev->bd_disk->private_data; 13541da177e4SLinus Torvalds 1355f85221ddSIngo Molnar mutex_lock(&lo->lo_ctl_mutex); 13561da177e4SLinus Torvalds lo->lo_refcnt++; 1357f85221ddSIngo Molnar mutex_unlock(&lo->lo_ctl_mutex); 13581da177e4SLinus Torvalds 13591da177e4SLinus Torvalds return 0; 13601da177e4SLinus Torvalds } 13611da177e4SLinus Torvalds 1362bb214884SAl Viro static int lo_release(struct gendisk *disk, fmode_t mode) 13631da177e4SLinus Torvalds { 1364bb214884SAl Viro struct loop_device *lo = disk->private_data; 13651da177e4SLinus Torvalds 1366f85221ddSIngo Molnar mutex_lock(&lo->lo_ctl_mutex); 136796c58655SDavid Woodhouse 136814f27939SMilan Broz if (--lo->lo_refcnt) 136914f27939SMilan Broz goto out; 137014f27939SMilan Broz 137114f27939SMilan Broz if (lo->lo_flags & LO_FLAGS_AUTOCLEAR) { 137214f27939SMilan Broz /* 137314f27939SMilan Broz * In autoclear mode, stop the loop thread 137414f27939SMilan Broz * and remove configuration after last close. 137514f27939SMilan Broz */ 1376bb214884SAl Viro loop_clr_fd(lo, NULL); 137714f27939SMilan Broz } else { 137814f27939SMilan Broz /* 137914f27939SMilan Broz * Otherwise keep thread (if running) and config, 138014f27939SMilan Broz * but flush possible ongoing bios in thread. 138114f27939SMilan Broz */ 138214f27939SMilan Broz loop_flush(lo); 138314f27939SMilan Broz } 138496c58655SDavid Woodhouse 138514f27939SMilan Broz out: 1386f85221ddSIngo Molnar mutex_unlock(&lo->lo_ctl_mutex); 13871da177e4SLinus Torvalds 13881da177e4SLinus Torvalds return 0; 13891da177e4SLinus Torvalds } 13901da177e4SLinus Torvalds 13911da177e4SLinus Torvalds static struct block_device_operations lo_fops = { 13921da177e4SLinus Torvalds .owner = THIS_MODULE, 1393bb214884SAl Viro .open = lo_open, 1394bb214884SAl Viro .release = lo_release, 1395bb214884SAl Viro .ioctl = lo_ioctl, 1396863d5b82SDavid Howells #ifdef CONFIG_COMPAT 1397bb214884SAl Viro .compat_ioctl = lo_compat_ioctl, 1398863d5b82SDavid Howells #endif 13991da177e4SLinus Torvalds }; 14001da177e4SLinus Torvalds 14011da177e4SLinus Torvalds /* 14021da177e4SLinus Torvalds * And now the modules code and kernel interface. 14031da177e4SLinus Torvalds */ 140473285082SKen Chen static int max_loop; 14051da177e4SLinus Torvalds module_param(max_loop, int, 0); 1406a47653fcSKen Chen MODULE_PARM_DESC(max_loop, "Maximum number of loop devices"); 1407476a4813SLaurent Vivier module_param(max_part, int, 0); 1408476a4813SLaurent Vivier MODULE_PARM_DESC(max_part, "Maximum number of partitions per loop device"); 14091da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 14101da177e4SLinus Torvalds MODULE_ALIAS_BLOCKDEV_MAJOR(LOOP_MAJOR); 14111da177e4SLinus Torvalds 14121da177e4SLinus Torvalds int loop_register_transfer(struct loop_func_table *funcs) 14131da177e4SLinus Torvalds { 14141da177e4SLinus Torvalds unsigned int n = funcs->number; 14151da177e4SLinus Torvalds 14161da177e4SLinus Torvalds if (n >= MAX_LO_CRYPT || xfer_funcs[n]) 14171da177e4SLinus Torvalds return -EINVAL; 14181da177e4SLinus Torvalds xfer_funcs[n] = funcs; 14191da177e4SLinus Torvalds return 0; 14201da177e4SLinus Torvalds } 14211da177e4SLinus Torvalds 14221da177e4SLinus Torvalds int loop_unregister_transfer(int number) 14231da177e4SLinus Torvalds { 14241da177e4SLinus Torvalds unsigned int n = number; 14251da177e4SLinus Torvalds struct loop_device *lo; 14261da177e4SLinus Torvalds struct loop_func_table *xfer; 14271da177e4SLinus Torvalds 14281da177e4SLinus Torvalds if (n == 0 || n >= MAX_LO_CRYPT || (xfer = xfer_funcs[n]) == NULL) 14291da177e4SLinus Torvalds return -EINVAL; 14301da177e4SLinus Torvalds 14311da177e4SLinus Torvalds xfer_funcs[n] = NULL; 14321da177e4SLinus Torvalds 143373285082SKen Chen list_for_each_entry(lo, &loop_devices, lo_list) { 1434f85221ddSIngo Molnar mutex_lock(&lo->lo_ctl_mutex); 14351da177e4SLinus Torvalds 14361da177e4SLinus Torvalds if (lo->lo_encryption == xfer) 14371da177e4SLinus Torvalds loop_release_xfer(lo); 14381da177e4SLinus Torvalds 1439f85221ddSIngo Molnar mutex_unlock(&lo->lo_ctl_mutex); 14401da177e4SLinus Torvalds } 14411da177e4SLinus Torvalds 14421da177e4SLinus Torvalds return 0; 14431da177e4SLinus Torvalds } 14441da177e4SLinus Torvalds 14451da177e4SLinus Torvalds EXPORT_SYMBOL(loop_register_transfer); 14461da177e4SLinus Torvalds EXPORT_SYMBOL(loop_unregister_transfer); 14471da177e4SLinus Torvalds 1448a47653fcSKen Chen static struct loop_device *loop_alloc(int i) 14491da177e4SLinus Torvalds { 145073285082SKen Chen struct loop_device *lo; 145173285082SKen Chen struct gendisk *disk; 14521da177e4SLinus Torvalds 145373285082SKen Chen lo = kzalloc(sizeof(*lo), GFP_KERNEL); 145473285082SKen Chen if (!lo) 145573285082SKen Chen goto out; 14561da177e4SLinus Torvalds 14571da177e4SLinus Torvalds lo->lo_queue = blk_alloc_queue(GFP_KERNEL); 14581da177e4SLinus Torvalds if (!lo->lo_queue) 145973285082SKen Chen goto out_free_dev; 146073285082SKen Chen 1461476a4813SLaurent Vivier disk = lo->lo_disk = alloc_disk(1 << part_shift); 146273285082SKen Chen if (!disk) 146373285082SKen Chen goto out_free_queue; 146473285082SKen Chen 1465f85221ddSIngo Molnar mutex_init(&lo->lo_ctl_mutex); 14661da177e4SLinus Torvalds lo->lo_number = i; 14676c997918SSerge E. Hallyn lo->lo_thread = NULL; 14686c997918SSerge E. Hallyn init_waitqueue_head(&lo->lo_event); 14691da177e4SLinus Torvalds spin_lock_init(&lo->lo_lock); 14701da177e4SLinus Torvalds disk->major = LOOP_MAJOR; 1471476a4813SLaurent Vivier disk->first_minor = i << part_shift; 14721da177e4SLinus Torvalds disk->fops = &lo_fops; 14731da177e4SLinus Torvalds disk->private_data = lo; 14741da177e4SLinus Torvalds disk->queue = lo->lo_queue; 147573285082SKen Chen sprintf(disk->disk_name, "loop%d", i); 147673285082SKen Chen return lo; 147773285082SKen Chen 147873285082SKen Chen out_free_queue: 147973285082SKen Chen blk_cleanup_queue(lo->lo_queue); 148073285082SKen Chen out_free_dev: 148173285082SKen Chen kfree(lo); 148273285082SKen Chen out: 148307002e99SAl Viro return NULL; 14841da177e4SLinus Torvalds } 14851da177e4SLinus Torvalds 1486a47653fcSKen Chen static void loop_free(struct loop_device *lo) 148773285082SKen Chen { 148873285082SKen Chen blk_cleanup_queue(lo->lo_queue); 148973285082SKen Chen put_disk(lo->lo_disk); 149073285082SKen Chen list_del(&lo->lo_list); 149173285082SKen Chen kfree(lo); 149273285082SKen Chen } 149373285082SKen Chen 1494a47653fcSKen Chen static struct loop_device *loop_init_one(int i) 1495a47653fcSKen Chen { 1496a47653fcSKen Chen struct loop_device *lo; 1497a47653fcSKen Chen 1498a47653fcSKen Chen list_for_each_entry(lo, &loop_devices, lo_list) { 1499a47653fcSKen Chen if (lo->lo_number == i) 1500a47653fcSKen Chen return lo; 1501a47653fcSKen Chen } 1502a47653fcSKen Chen 1503a47653fcSKen Chen lo = loop_alloc(i); 1504a47653fcSKen Chen if (lo) { 1505a47653fcSKen Chen add_disk(lo->lo_disk); 1506a47653fcSKen Chen list_add_tail(&lo->lo_list, &loop_devices); 1507a47653fcSKen Chen } 1508a47653fcSKen Chen return lo; 1509a47653fcSKen Chen } 1510a47653fcSKen Chen 1511a47653fcSKen Chen static void loop_del_one(struct loop_device *lo) 1512a47653fcSKen Chen { 1513a47653fcSKen Chen del_gendisk(lo->lo_disk); 1514a47653fcSKen Chen loop_free(lo); 1515a47653fcSKen Chen } 1516a47653fcSKen Chen 151773285082SKen Chen static struct kobject *loop_probe(dev_t dev, int *part, void *data) 151873285082SKen Chen { 1519705962ccSAl Viro struct loop_device *lo; 152007002e99SAl Viro struct kobject *kobj; 152173285082SKen Chen 1522705962ccSAl Viro mutex_lock(&loop_devices_mutex); 1523705962ccSAl Viro lo = loop_init_one(dev & MINORMASK); 152407002e99SAl Viro kobj = lo ? get_disk(lo->lo_disk) : ERR_PTR(-ENOMEM); 152573285082SKen Chen mutex_unlock(&loop_devices_mutex); 152673285082SKen Chen 152773285082SKen Chen *part = 0; 152807002e99SAl Viro return kobj; 152973285082SKen Chen } 153073285082SKen Chen 153173285082SKen Chen static int __init loop_init(void) 153273285082SKen Chen { 1533a47653fcSKen Chen int i, nr; 1534a47653fcSKen Chen unsigned long range; 1535a47653fcSKen Chen struct loop_device *lo, *next; 1536a47653fcSKen Chen 1537a47653fcSKen Chen /* 1538a47653fcSKen Chen * loop module now has a feature to instantiate underlying device 1539a47653fcSKen Chen * structure on-demand, provided that there is an access dev node. 1540a47653fcSKen Chen * However, this will not work well with user space tool that doesn't 1541a47653fcSKen Chen * know about such "feature". In order to not break any existing 1542a47653fcSKen Chen * tool, we do the following: 1543a47653fcSKen Chen * 1544a47653fcSKen Chen * (1) if max_loop is specified, create that many upfront, and this 1545a47653fcSKen Chen * also becomes a hard limit. 1546a47653fcSKen Chen * (2) if max_loop is not specified, create 8 loop device on module 1547a47653fcSKen Chen * load, user can further extend loop device by create dev node 1548a47653fcSKen Chen * themselves and have kernel automatically instantiate actual 1549a47653fcSKen Chen * device on-demand. 1550a47653fcSKen Chen */ 1551476a4813SLaurent Vivier 1552476a4813SLaurent Vivier part_shift = 0; 1553476a4813SLaurent Vivier if (max_part > 0) 1554476a4813SLaurent Vivier part_shift = fls(max_part); 1555476a4813SLaurent Vivier 1556476a4813SLaurent Vivier if (max_loop > 1UL << (MINORBITS - part_shift)) 1557a47653fcSKen Chen return -EINVAL; 155873285082SKen Chen 155973285082SKen Chen if (max_loop) { 1560a47653fcSKen Chen nr = max_loop; 1561a47653fcSKen Chen range = max_loop; 1562a47653fcSKen Chen } else { 1563a47653fcSKen Chen nr = 8; 1564476a4813SLaurent Vivier range = 1UL << (MINORBITS - part_shift); 156573285082SKen Chen } 1566a47653fcSKen Chen 1567a47653fcSKen Chen if (register_blkdev(LOOP_MAJOR, "loop")) 1568a47653fcSKen Chen return -EIO; 1569a47653fcSKen Chen 1570a47653fcSKen Chen for (i = 0; i < nr; i++) { 1571a47653fcSKen Chen lo = loop_alloc(i); 1572a47653fcSKen Chen if (!lo) 1573a47653fcSKen Chen goto Enomem; 1574a47653fcSKen Chen list_add_tail(&lo->lo_list, &loop_devices); 1575a47653fcSKen Chen } 1576a47653fcSKen Chen 1577a47653fcSKen Chen /* point of no return */ 1578a47653fcSKen Chen 1579a47653fcSKen Chen list_for_each_entry(lo, &loop_devices, lo_list) 1580a47653fcSKen Chen add_disk(lo->lo_disk); 1581a47653fcSKen Chen 1582a47653fcSKen Chen blk_register_region(MKDEV(LOOP_MAJOR, 0), range, 1583a47653fcSKen Chen THIS_MODULE, loop_probe, NULL, NULL); 1584a47653fcSKen Chen 158573285082SKen Chen printk(KERN_INFO "loop: module loaded\n"); 15861da177e4SLinus Torvalds return 0; 1587a47653fcSKen Chen 1588a47653fcSKen Chen Enomem: 1589a47653fcSKen Chen printk(KERN_INFO "loop: out of memory\n"); 1590a47653fcSKen Chen 1591a47653fcSKen Chen list_for_each_entry_safe(lo, next, &loop_devices, lo_list) 1592a47653fcSKen Chen loop_free(lo); 1593a47653fcSKen Chen 1594a47653fcSKen Chen unregister_blkdev(LOOP_MAJOR, "loop"); 1595a47653fcSKen Chen return -ENOMEM; 15961da177e4SLinus Torvalds } 15971da177e4SLinus Torvalds 159873285082SKen Chen static void __exit loop_exit(void) 15991da177e4SLinus Torvalds { 1600a47653fcSKen Chen unsigned long range; 160173285082SKen Chen struct loop_device *lo, *next; 16021da177e4SLinus Torvalds 1603476a4813SLaurent Vivier range = max_loop ? max_loop : 1UL << (MINORBITS - part_shift); 1604a47653fcSKen Chen 160573285082SKen Chen list_for_each_entry_safe(lo, next, &loop_devices, lo_list) 160673285082SKen Chen loop_del_one(lo); 160773285082SKen Chen 1608a47653fcSKen Chen blk_unregister_region(MKDEV(LOOP_MAJOR, 0), range); 160900d59405SAkinobu Mita unregister_blkdev(LOOP_MAJOR, "loop"); 16101da177e4SLinus Torvalds } 16111da177e4SLinus Torvalds 16121da177e4SLinus Torvalds module_init(loop_init); 16131da177e4SLinus Torvalds module_exit(loop_exit); 16141da177e4SLinus Torvalds 16151da177e4SLinus Torvalds #ifndef MODULE 16161da177e4SLinus Torvalds static int __init max_loop_setup(char *str) 16171da177e4SLinus Torvalds { 16181da177e4SLinus Torvalds max_loop = simple_strtol(str, NULL, 0); 16191da177e4SLinus Torvalds return 1; 16201da177e4SLinus Torvalds } 16211da177e4SLinus Torvalds 16221da177e4SLinus Torvalds __setup("max_loop=", max_loop_setup); 16231da177e4SLinus Torvalds #endif 1624