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/swap.h> 651da177e4SLinus Torvalds #include <linux/slab.h> 661da177e4SLinus Torvalds #include <linux/loop.h> 67863d5b82SDavid Howells #include <linux/compat.h> 681da177e4SLinus Torvalds #include <linux/suspend.h> 6983144186SRafael J. Wysocki #include <linux/freezer.h> 706e9624b8SArnd Bergmann #include <linux/smp_lock.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> 756c997918SSerge E. Hallyn #include <linux/kthread.h> 76d6b29d7cSJens Axboe #include <linux/splice.h> 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds #include <asm/uaccess.h> 791da177e4SLinus Torvalds 8073285082SKen Chen static LIST_HEAD(loop_devices); 8173285082SKen Chen static DEFINE_MUTEX(loop_devices_mutex); 821da177e4SLinus Torvalds 83476a4813SLaurent Vivier static int max_part; 84476a4813SLaurent Vivier static int part_shift; 85476a4813SLaurent Vivier 861da177e4SLinus Torvalds /* 871da177e4SLinus Torvalds * Transfer functions 881da177e4SLinus Torvalds */ 891da177e4SLinus Torvalds static int transfer_none(struct loop_device *lo, int cmd, 901da177e4SLinus Torvalds struct page *raw_page, unsigned raw_off, 911da177e4SLinus Torvalds struct page *loop_page, unsigned loop_off, 921da177e4SLinus Torvalds int size, sector_t real_block) 931da177e4SLinus Torvalds { 941da177e4SLinus Torvalds char *raw_buf = kmap_atomic(raw_page, KM_USER0) + raw_off; 951da177e4SLinus Torvalds char *loop_buf = kmap_atomic(loop_page, KM_USER1) + loop_off; 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds if (cmd == READ) 981da177e4SLinus Torvalds memcpy(loop_buf, raw_buf, size); 991da177e4SLinus Torvalds else 1001da177e4SLinus Torvalds memcpy(raw_buf, loop_buf, size); 1011da177e4SLinus Torvalds 1021da177e4SLinus Torvalds kunmap_atomic(raw_buf, KM_USER0); 1031da177e4SLinus Torvalds kunmap_atomic(loop_buf, KM_USER1); 1041da177e4SLinus Torvalds cond_resched(); 1051da177e4SLinus Torvalds return 0; 1061da177e4SLinus Torvalds } 1071da177e4SLinus Torvalds 1081da177e4SLinus Torvalds static int transfer_xor(struct loop_device *lo, int cmd, 1091da177e4SLinus Torvalds struct page *raw_page, unsigned raw_off, 1101da177e4SLinus Torvalds struct page *loop_page, unsigned loop_off, 1111da177e4SLinus Torvalds int size, sector_t real_block) 1121da177e4SLinus Torvalds { 1131da177e4SLinus Torvalds char *raw_buf = kmap_atomic(raw_page, KM_USER0) + raw_off; 1141da177e4SLinus Torvalds char *loop_buf = kmap_atomic(loop_page, KM_USER1) + loop_off; 1151da177e4SLinus Torvalds char *in, *out, *key; 1161da177e4SLinus Torvalds int i, keysize; 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds if (cmd == READ) { 1191da177e4SLinus Torvalds in = raw_buf; 1201da177e4SLinus Torvalds out = loop_buf; 1211da177e4SLinus Torvalds } else { 1221da177e4SLinus Torvalds in = loop_buf; 1231da177e4SLinus Torvalds out = raw_buf; 1241da177e4SLinus Torvalds } 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds key = lo->lo_encrypt_key; 1271da177e4SLinus Torvalds keysize = lo->lo_encrypt_key_size; 1281da177e4SLinus Torvalds for (i = 0; i < size; i++) 1291da177e4SLinus Torvalds *out++ = *in++ ^ key[(i & 511) % keysize]; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds kunmap_atomic(raw_buf, KM_USER0); 1321da177e4SLinus Torvalds kunmap_atomic(loop_buf, KM_USER1); 1331da177e4SLinus Torvalds cond_resched(); 1341da177e4SLinus Torvalds return 0; 1351da177e4SLinus Torvalds } 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds static int xor_init(struct loop_device *lo, const struct loop_info64 *info) 1381da177e4SLinus Torvalds { 1391da177e4SLinus Torvalds if (unlikely(info->lo_encrypt_key_size <= 0)) 1401da177e4SLinus Torvalds return -EINVAL; 1411da177e4SLinus Torvalds return 0; 1421da177e4SLinus Torvalds } 1431da177e4SLinus Torvalds 1441da177e4SLinus Torvalds static struct loop_func_table none_funcs = { 1451da177e4SLinus Torvalds .number = LO_CRYPT_NONE, 1461da177e4SLinus Torvalds .transfer = transfer_none, 1471da177e4SLinus Torvalds }; 1481da177e4SLinus Torvalds 1491da177e4SLinus Torvalds static struct loop_func_table xor_funcs = { 1501da177e4SLinus Torvalds .number = LO_CRYPT_XOR, 1511da177e4SLinus Torvalds .transfer = transfer_xor, 1521da177e4SLinus Torvalds .init = xor_init 1531da177e4SLinus Torvalds }; 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds /* xfer_funcs[0] is special - its release function is never called */ 1561da177e4SLinus Torvalds static struct loop_func_table *xfer_funcs[MAX_LO_CRYPT] = { 1571da177e4SLinus Torvalds &none_funcs, 1581da177e4SLinus Torvalds &xor_funcs 1591da177e4SLinus Torvalds }; 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds static loff_t get_loop_size(struct loop_device *lo, struct file *file) 1621da177e4SLinus Torvalds { 1631da177e4SLinus Torvalds loff_t size, offset, loopsize; 1641da177e4SLinus Torvalds 1651da177e4SLinus Torvalds /* Compute loopsize in bytes */ 1661da177e4SLinus Torvalds size = i_size_read(file->f_mapping->host); 1671da177e4SLinus Torvalds offset = lo->lo_offset; 1681da177e4SLinus Torvalds loopsize = size - offset; 1691da177e4SLinus Torvalds if (lo->lo_sizelimit > 0 && lo->lo_sizelimit < loopsize) 1701da177e4SLinus Torvalds loopsize = lo->lo_sizelimit; 1711da177e4SLinus Torvalds 1721da177e4SLinus Torvalds /* 1731da177e4SLinus Torvalds * Unfortunately, if we want to do I/O on the device, 1741da177e4SLinus Torvalds * the number of 512-byte sectors has to fit into a sector_t. 1751da177e4SLinus Torvalds */ 1761da177e4SLinus Torvalds return loopsize >> 9; 1771da177e4SLinus Torvalds } 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds static int 1801da177e4SLinus Torvalds figure_loop_size(struct loop_device *lo) 1811da177e4SLinus Torvalds { 1821da177e4SLinus Torvalds loff_t size = get_loop_size(lo, lo->lo_backing_file); 1831da177e4SLinus Torvalds sector_t x = (sector_t)size; 1841da177e4SLinus Torvalds 1851da177e4SLinus Torvalds if (unlikely((loff_t)x != size)) 1861da177e4SLinus Torvalds return -EFBIG; 1871da177e4SLinus Torvalds 18873285082SKen Chen set_capacity(lo->lo_disk, x); 1891da177e4SLinus Torvalds return 0; 1901da177e4SLinus Torvalds } 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds static inline int 1931da177e4SLinus Torvalds lo_do_transfer(struct loop_device *lo, int cmd, 1941da177e4SLinus Torvalds struct page *rpage, unsigned roffs, 1951da177e4SLinus Torvalds struct page *lpage, unsigned loffs, 1961da177e4SLinus Torvalds int size, sector_t rblock) 1971da177e4SLinus Torvalds { 1981da177e4SLinus Torvalds if (unlikely(!lo->transfer)) 1991da177e4SLinus Torvalds return 0; 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds return lo->transfer(lo, cmd, rpage, roffs, lpage, loffs, size, rblock); 2021da177e4SLinus Torvalds } 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds /** 2051da177e4SLinus Torvalds * do_lo_send_aops - helper for writing data to a loop device 2061da177e4SLinus Torvalds * 2071da177e4SLinus Torvalds * This is the fast version for backing filesystems which implement the address 208afddba49SNick Piggin * space operations write_begin and write_end. 2091da177e4SLinus Torvalds */ 2101da177e4SLinus Torvalds static int do_lo_send_aops(struct loop_device *lo, struct bio_vec *bvec, 211511de73fSAl Viro loff_t pos, struct page *unused) 2121da177e4SLinus Torvalds { 2131da177e4SLinus Torvalds struct file *file = lo->lo_backing_file; /* kudos to NFsckingS */ 2141da177e4SLinus Torvalds struct address_space *mapping = file->f_mapping; 2151da177e4SLinus Torvalds pgoff_t index; 2161da177e4SLinus Torvalds unsigned offset, bv_offs; 217994fc28cSZach Brown int len, ret; 2181da177e4SLinus Torvalds 2191b1dcc1bSJes Sorensen mutex_lock(&mapping->host->i_mutex); 2201da177e4SLinus Torvalds index = pos >> PAGE_CACHE_SHIFT; 2211da177e4SLinus Torvalds offset = pos & ((pgoff_t)PAGE_CACHE_SIZE - 1); 2221da177e4SLinus Torvalds bv_offs = bvec->bv_offset; 2231da177e4SLinus Torvalds len = bvec->bv_len; 2241da177e4SLinus Torvalds while (len > 0) { 2251da177e4SLinus Torvalds sector_t IV; 226afddba49SNick Piggin unsigned size, copied; 2271da177e4SLinus Torvalds int transfer_result; 228afddba49SNick Piggin struct page *page; 229afddba49SNick Piggin void *fsdata; 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds IV = ((sector_t)index << (PAGE_CACHE_SHIFT - 9))+(offset >> 9); 2321da177e4SLinus Torvalds size = PAGE_CACHE_SIZE - offset; 2331da177e4SLinus Torvalds if (size > len) 2341da177e4SLinus Torvalds size = len; 235afddba49SNick Piggin 236afddba49SNick Piggin ret = pagecache_write_begin(file, mapping, pos, size, 0, 237afddba49SNick Piggin &page, &fsdata); 238afddba49SNick Piggin if (ret) 2391da177e4SLinus Torvalds goto fail; 240afddba49SNick Piggin 24102246c41SNikanth Karthikesan file_update_time(file); 24202246c41SNikanth Karthikesan 2431da177e4SLinus Torvalds transfer_result = lo_do_transfer(lo, WRITE, page, offset, 2441da177e4SLinus Torvalds bvec->bv_page, bv_offs, size, IV); 245afddba49SNick Piggin copied = size; 2461da177e4SLinus Torvalds if (unlikely(transfer_result)) 247afddba49SNick Piggin copied = 0; 248afddba49SNick Piggin 249afddba49SNick Piggin ret = pagecache_write_end(file, mapping, pos, size, copied, 250afddba49SNick Piggin page, fsdata); 2518268f5a7SDmitry Monakhov if (ret < 0 || ret != copied) 252afddba49SNick Piggin goto fail; 253afddba49SNick Piggin 254afddba49SNick Piggin if (unlikely(transfer_result)) 255afddba49SNick Piggin goto fail; 256afddba49SNick Piggin 257afddba49SNick Piggin bv_offs += copied; 258afddba49SNick Piggin len -= copied; 2591da177e4SLinus Torvalds offset = 0; 2601da177e4SLinus Torvalds index++; 261afddba49SNick Piggin pos += copied; 2621da177e4SLinus Torvalds } 263994fc28cSZach Brown ret = 0; 2641da177e4SLinus Torvalds out: 2651b1dcc1bSJes Sorensen mutex_unlock(&mapping->host->i_mutex); 2661da177e4SLinus Torvalds return ret; 2671da177e4SLinus Torvalds fail: 2681da177e4SLinus Torvalds ret = -1; 2691da177e4SLinus Torvalds goto out; 2701da177e4SLinus Torvalds } 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds /** 2731da177e4SLinus Torvalds * __do_lo_send_write - helper for writing data to a loop device 2741da177e4SLinus Torvalds * 2751da177e4SLinus Torvalds * This helper just factors out common code between do_lo_send_direct_write() 2761da177e4SLinus Torvalds * and do_lo_send_write(). 2771da177e4SLinus Torvalds */ 278858119e1SArjan van de Ven static int __do_lo_send_write(struct file *file, 27998ae6ccdSAl Viro u8 *buf, const int len, loff_t pos) 2801da177e4SLinus Torvalds { 2811da177e4SLinus Torvalds ssize_t bw; 2821da177e4SLinus Torvalds mm_segment_t old_fs = get_fs(); 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds set_fs(get_ds()); 2851da177e4SLinus Torvalds bw = file->f_op->write(file, buf, len, &pos); 2861da177e4SLinus Torvalds set_fs(old_fs); 2871da177e4SLinus Torvalds if (likely(bw == len)) 2881da177e4SLinus Torvalds return 0; 2891da177e4SLinus Torvalds printk(KERN_ERR "loop: Write error at byte offset %llu, length %i.\n", 2901da177e4SLinus Torvalds (unsigned long long)pos, len); 2911da177e4SLinus Torvalds if (bw >= 0) 2921da177e4SLinus Torvalds bw = -EIO; 2931da177e4SLinus Torvalds return bw; 2941da177e4SLinus Torvalds } 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds /** 2971da177e4SLinus Torvalds * do_lo_send_direct_write - helper for writing data to a loop device 2981da177e4SLinus Torvalds * 2991da177e4SLinus Torvalds * This is the fast, non-transforming version for backing filesystems which do 300afddba49SNick Piggin * not implement the address space operations write_begin and write_end. 3011da177e4SLinus Torvalds * It uses the write file operation which should be present on all writeable 3021da177e4SLinus Torvalds * filesystems. 3031da177e4SLinus Torvalds */ 3041da177e4SLinus Torvalds static int do_lo_send_direct_write(struct loop_device *lo, 305511de73fSAl Viro struct bio_vec *bvec, loff_t pos, struct page *page) 3061da177e4SLinus Torvalds { 3071da177e4SLinus Torvalds ssize_t bw = __do_lo_send_write(lo->lo_backing_file, 30898ae6ccdSAl Viro kmap(bvec->bv_page) + bvec->bv_offset, 3091da177e4SLinus Torvalds bvec->bv_len, pos); 3101da177e4SLinus Torvalds kunmap(bvec->bv_page); 3111da177e4SLinus Torvalds cond_resched(); 3121da177e4SLinus Torvalds return bw; 3131da177e4SLinus Torvalds } 3141da177e4SLinus Torvalds 3151da177e4SLinus Torvalds /** 3161da177e4SLinus Torvalds * do_lo_send_write - helper for writing data to a loop device 3171da177e4SLinus Torvalds * 3181da177e4SLinus Torvalds * This is the slow, transforming version for filesystems which do not 319afddba49SNick Piggin * implement the address space operations write_begin and write_end. It 3201da177e4SLinus Torvalds * uses the write file operation which should be present on all writeable 3211da177e4SLinus Torvalds * filesystems. 3221da177e4SLinus Torvalds * 3231da177e4SLinus Torvalds * Using fops->write is slower than using aops->{prepare,commit}_write in the 3241da177e4SLinus Torvalds * transforming case because we need to double buffer the data as we cannot do 3251da177e4SLinus Torvalds * the transformations in place as we do not have direct access to the 3261da177e4SLinus Torvalds * destination pages of the backing file. 3271da177e4SLinus Torvalds */ 3281da177e4SLinus Torvalds static int do_lo_send_write(struct loop_device *lo, struct bio_vec *bvec, 329511de73fSAl Viro loff_t pos, struct page *page) 3301da177e4SLinus Torvalds { 3311da177e4SLinus Torvalds int ret = lo_do_transfer(lo, WRITE, page, 0, bvec->bv_page, 3321da177e4SLinus Torvalds bvec->bv_offset, bvec->bv_len, pos >> 9); 3331da177e4SLinus Torvalds if (likely(!ret)) 3341da177e4SLinus Torvalds return __do_lo_send_write(lo->lo_backing_file, 33598ae6ccdSAl Viro page_address(page), bvec->bv_len, 3361da177e4SLinus Torvalds pos); 3371da177e4SLinus Torvalds printk(KERN_ERR "loop: Transfer error at byte offset %llu, " 3381da177e4SLinus Torvalds "length %i.\n", (unsigned long long)pos, bvec->bv_len); 3391da177e4SLinus Torvalds if (ret > 0) 3401da177e4SLinus Torvalds ret = -EIO; 3411da177e4SLinus Torvalds return ret; 3421da177e4SLinus Torvalds } 3431da177e4SLinus Torvalds 344511de73fSAl Viro static int lo_send(struct loop_device *lo, struct bio *bio, loff_t pos) 3451da177e4SLinus Torvalds { 346511de73fSAl Viro int (*do_lo_send)(struct loop_device *, struct bio_vec *, loff_t, 3471da177e4SLinus Torvalds struct page *page); 3481da177e4SLinus Torvalds struct bio_vec *bvec; 3491da177e4SLinus Torvalds struct page *page = NULL; 3501da177e4SLinus Torvalds int i, ret = 0; 3511da177e4SLinus Torvalds 3521da177e4SLinus Torvalds do_lo_send = do_lo_send_aops; 3531da177e4SLinus Torvalds if (!(lo->lo_flags & LO_FLAGS_USE_AOPS)) { 3541da177e4SLinus Torvalds do_lo_send = do_lo_send_direct_write; 3551da177e4SLinus Torvalds if (lo->transfer != transfer_none) { 3561da177e4SLinus Torvalds page = alloc_page(GFP_NOIO | __GFP_HIGHMEM); 3571da177e4SLinus Torvalds if (unlikely(!page)) 3581da177e4SLinus Torvalds goto fail; 3591da177e4SLinus Torvalds kmap(page); 3601da177e4SLinus Torvalds do_lo_send = do_lo_send_write; 3611da177e4SLinus Torvalds } 3621da177e4SLinus Torvalds } 3631da177e4SLinus Torvalds bio_for_each_segment(bvec, bio, i) { 364511de73fSAl Viro ret = do_lo_send(lo, bvec, pos, page); 3651da177e4SLinus Torvalds if (ret < 0) 3661da177e4SLinus Torvalds break; 3671da177e4SLinus Torvalds pos += bvec->bv_len; 3681da177e4SLinus Torvalds } 3691da177e4SLinus Torvalds if (page) { 3701da177e4SLinus Torvalds kunmap(page); 3711da177e4SLinus Torvalds __free_page(page); 3721da177e4SLinus Torvalds } 3731da177e4SLinus Torvalds out: 3741da177e4SLinus Torvalds return ret; 3751da177e4SLinus Torvalds fail: 3761da177e4SLinus Torvalds printk(KERN_ERR "loop: Failed to allocate temporary page for write.\n"); 3771da177e4SLinus Torvalds ret = -ENOMEM; 3781da177e4SLinus Torvalds goto out; 3791da177e4SLinus Torvalds } 3801da177e4SLinus Torvalds 3811da177e4SLinus Torvalds struct lo_read_data { 3821da177e4SLinus Torvalds struct loop_device *lo; 3831da177e4SLinus Torvalds struct page *page; 3841da177e4SLinus Torvalds unsigned offset; 3851da177e4SLinus Torvalds int bsize; 3861da177e4SLinus Torvalds }; 3871da177e4SLinus Torvalds 3881da177e4SLinus Torvalds static int 389fd582140SJens Axboe lo_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf, 390fd582140SJens Axboe struct splice_desc *sd) 3911da177e4SLinus Torvalds { 392fd582140SJens Axboe struct lo_read_data *p = sd->u.data; 3931da177e4SLinus Torvalds struct loop_device *lo = p->lo; 394fd582140SJens Axboe struct page *page = buf->page; 3951da177e4SLinus Torvalds sector_t IV; 396a3941ec1SRoel Kluin int size, 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; 47868db1961SNikanth Karthikesan 47968db1961SNikanth Karthikesan if (bio_rw(bio) == WRITE) { 48068db1961SNikanth Karthikesan struct file *file = lo->lo_backing_file; 48168db1961SNikanth Karthikesan 482*6259f284STejun Heo /* REQ_HARDBARRIER is deprecated */ 483*6259f284STejun Heo if (bio->bi_rw & REQ_HARDBARRIER) { 48468db1961SNikanth Karthikesan ret = -EOPNOTSUPP; 48568db1961SNikanth Karthikesan goto out; 48668db1961SNikanth Karthikesan } 48768db1961SNikanth Karthikesan 488*6259f284STejun Heo if (bio->bi_rw & REQ_FLUSH) { 4898018ab05SChristoph Hellwig ret = vfs_fsync(file, 0); 490*6259f284STejun Heo if (unlikely(ret && ret != -EINVAL)) { 49168db1961SNikanth Karthikesan ret = -EIO; 49268db1961SNikanth Karthikesan goto out; 49368db1961SNikanth Karthikesan } 49468db1961SNikanth Karthikesan } 49568db1961SNikanth Karthikesan 496511de73fSAl Viro ret = lo_send(lo, bio, pos); 49768db1961SNikanth Karthikesan 498*6259f284STejun Heo if ((bio->bi_rw & REQ_FUA) && !ret) { 4998018ab05SChristoph Hellwig ret = vfs_fsync(file, 0); 500*6259f284STejun Heo if (unlikely(ret && ret != -EINVAL)) 50168db1961SNikanth Karthikesan ret = -EIO; 50268db1961SNikanth Karthikesan } 50368db1961SNikanth Karthikesan } else 5041da177e4SLinus Torvalds ret = lo_receive(lo, bio, lo->lo_blocksize, pos); 50568db1961SNikanth Karthikesan 50668db1961SNikanth Karthikesan out: 5071da177e4SLinus Torvalds return ret; 5081da177e4SLinus Torvalds } 5091da177e4SLinus Torvalds 5101da177e4SLinus Torvalds /* 5111da177e4SLinus Torvalds * Add bio to back of pending list 5121da177e4SLinus Torvalds */ 5131da177e4SLinus Torvalds static void loop_add_bio(struct loop_device *lo, struct bio *bio) 5141da177e4SLinus Torvalds { 515e686307fSAkinobu Mita bio_list_add(&lo->lo_bio_list, bio); 5161da177e4SLinus Torvalds } 5171da177e4SLinus Torvalds 5181da177e4SLinus Torvalds /* 5191da177e4SLinus Torvalds * Grab first pending buffer 5201da177e4SLinus Torvalds */ 5211da177e4SLinus Torvalds static struct bio *loop_get_bio(struct loop_device *lo) 5221da177e4SLinus Torvalds { 523e686307fSAkinobu Mita return bio_list_pop(&lo->lo_bio_list); 5241da177e4SLinus Torvalds } 5251da177e4SLinus Torvalds 526165125e1SJens Axboe static int loop_make_request(struct request_queue *q, struct bio *old_bio) 5271da177e4SLinus Torvalds { 5281da177e4SLinus Torvalds struct loop_device *lo = q->queuedata; 5291da177e4SLinus Torvalds int rw = bio_rw(old_bio); 5301da177e4SLinus Torvalds 53135a82d1aSNick Piggin if (rw == READA) 53235a82d1aSNick Piggin rw = READ; 53335a82d1aSNick Piggin 53435a82d1aSNick Piggin BUG_ON(!lo || (rw != READ && rw != WRITE)); 5351da177e4SLinus Torvalds 5361da177e4SLinus Torvalds spin_lock_irq(&lo->lo_lock); 5371da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 53835a82d1aSNick Piggin goto out; 53935a82d1aSNick Piggin if (unlikely(rw == WRITE && (lo->lo_flags & LO_FLAGS_READ_ONLY))) 54035a82d1aSNick Piggin goto out; 5411da177e4SLinus Torvalds loop_add_bio(lo, old_bio); 5426c997918SSerge E. Hallyn wake_up(&lo->lo_event); 54335a82d1aSNick Piggin spin_unlock_irq(&lo->lo_lock); 54435a82d1aSNick Piggin return 0; 54535a82d1aSNick Piggin 5461da177e4SLinus Torvalds out: 54735a82d1aSNick Piggin spin_unlock_irq(&lo->lo_lock); 5486712ecf8SNeilBrown bio_io_error(old_bio); 5491da177e4SLinus Torvalds return 0; 5501da177e4SLinus Torvalds } 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds /* 5531da177e4SLinus Torvalds * kick off io on the underlying address space 5541da177e4SLinus Torvalds */ 555165125e1SJens Axboe static void loop_unplug(struct request_queue *q) 5561da177e4SLinus Torvalds { 5571da177e4SLinus Torvalds struct loop_device *lo = q->queuedata; 5581da177e4SLinus Torvalds 55975ad23bcSNick Piggin queue_flag_clear_unlocked(QUEUE_FLAG_PLUGGED, q); 5601da177e4SLinus Torvalds blk_run_address_space(lo->lo_backing_file->f_mapping); 5611da177e4SLinus Torvalds } 5621da177e4SLinus Torvalds 5631da177e4SLinus Torvalds struct switch_request { 5641da177e4SLinus Torvalds struct file *file; 5651da177e4SLinus Torvalds struct completion wait; 5661da177e4SLinus Torvalds }; 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds static void do_loop_switch(struct loop_device *, struct switch_request *); 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds static inline void loop_handle_bio(struct loop_device *lo, struct bio *bio) 5711da177e4SLinus Torvalds { 5721da177e4SLinus Torvalds if (unlikely(!bio->bi_bdev)) { 5731da177e4SLinus Torvalds do_loop_switch(lo, bio->bi_private); 5741da177e4SLinus Torvalds bio_put(bio); 5751da177e4SLinus Torvalds } else { 57635a82d1aSNick Piggin int ret = do_bio_filebacked(lo, bio); 5776712ecf8SNeilBrown bio_endio(bio, ret); 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds } 5801da177e4SLinus Torvalds 5811da177e4SLinus Torvalds /* 5821da177e4SLinus Torvalds * worker thread that handles reads/writes to file backed loop devices, 5831da177e4SLinus Torvalds * to avoid blocking in our make_request_fn. it also does loop decrypting 5841da177e4SLinus Torvalds * on reads for block backed loop, as that is too heavy to do from 5851da177e4SLinus Torvalds * b_end_io context where irqs may be disabled. 5866c997918SSerge E. Hallyn * 5876c997918SSerge E. Hallyn * Loop explanation: loop_clr_fd() sets lo_state to Lo_rundown before 5886c997918SSerge E. Hallyn * calling kthread_stop(). Therefore once kthread_should_stop() is 5896c997918SSerge E. Hallyn * true, make_request will not place any more requests. Therefore 5906c997918SSerge E. Hallyn * once kthread_should_stop() is true and lo_bio is NULL, we are 5916c997918SSerge E. Hallyn * done with the loop. 5921da177e4SLinus Torvalds */ 5931da177e4SLinus Torvalds static int loop_thread(void *data) 5941da177e4SLinus Torvalds { 5951da177e4SLinus Torvalds struct loop_device *lo = data; 5961da177e4SLinus Torvalds struct bio *bio; 5971da177e4SLinus Torvalds 5981da177e4SLinus Torvalds set_user_nice(current, -20); 5991da177e4SLinus Torvalds 600e686307fSAkinobu Mita while (!kthread_should_stop() || !bio_list_empty(&lo->lo_bio_list)) { 6011da177e4SLinus Torvalds 6026c997918SSerge E. Hallyn wait_event_interruptible(lo->lo_event, 603e686307fSAkinobu Mita !bio_list_empty(&lo->lo_bio_list) || 604e686307fSAkinobu Mita kthread_should_stop()); 60509c0dc68SLinus Torvalds 606e686307fSAkinobu Mita if (bio_list_empty(&lo->lo_bio_list)) 60735a82d1aSNick Piggin continue; 60835a82d1aSNick Piggin spin_lock_irq(&lo->lo_lock); 6091da177e4SLinus Torvalds bio = loop_get_bio(lo); 61035a82d1aSNick Piggin spin_unlock_irq(&lo->lo_lock); 61135a82d1aSNick Piggin 61235a82d1aSNick Piggin BUG_ON(!bio); 6131da177e4SLinus Torvalds loop_handle_bio(lo, bio); 6141da177e4SLinus Torvalds } 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds return 0; 6171da177e4SLinus Torvalds } 6181da177e4SLinus Torvalds 6191da177e4SLinus Torvalds /* 6201da177e4SLinus Torvalds * loop_switch performs the hard work of switching a backing store. 6211da177e4SLinus Torvalds * First it needs to flush existing IO, it does this by sending a magic 6221da177e4SLinus Torvalds * BIO down the pipe. The completion of this BIO does the actual switch. 6231da177e4SLinus Torvalds */ 6241da177e4SLinus Torvalds static int loop_switch(struct loop_device *lo, struct file *file) 6251da177e4SLinus Torvalds { 6261da177e4SLinus Torvalds struct switch_request w; 627a24eab1eSJens Axboe struct bio *bio = bio_alloc(GFP_KERNEL, 0); 6281da177e4SLinus Torvalds if (!bio) 6291da177e4SLinus Torvalds return -ENOMEM; 6301da177e4SLinus Torvalds init_completion(&w.wait); 6311da177e4SLinus Torvalds w.file = file; 6321da177e4SLinus Torvalds bio->bi_private = &w; 6331da177e4SLinus Torvalds bio->bi_bdev = NULL; 6341da177e4SLinus Torvalds loop_make_request(lo->lo_queue, bio); 6351da177e4SLinus Torvalds wait_for_completion(&w.wait); 6361da177e4SLinus Torvalds return 0; 6371da177e4SLinus Torvalds } 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds /* 64014f27939SMilan Broz * Helper to flush the IOs in loop, but keeping loop thread running 64114f27939SMilan Broz */ 64214f27939SMilan Broz static int loop_flush(struct loop_device *lo) 64314f27939SMilan Broz { 64414f27939SMilan Broz /* loop not yet configured, no running thread, nothing to flush */ 64514f27939SMilan Broz if (!lo->lo_thread) 64614f27939SMilan Broz return 0; 64714f27939SMilan Broz 64814f27939SMilan Broz return loop_switch(lo, NULL); 64914f27939SMilan Broz } 65014f27939SMilan Broz 65114f27939SMilan Broz /* 6521da177e4SLinus Torvalds * Do the actual switch; called from the BIO completion routine 6531da177e4SLinus Torvalds */ 6541da177e4SLinus Torvalds static void do_loop_switch(struct loop_device *lo, struct switch_request *p) 6551da177e4SLinus Torvalds { 6561da177e4SLinus Torvalds struct file *file = p->file; 6571da177e4SLinus Torvalds struct file *old_file = lo->lo_backing_file; 65814f27939SMilan Broz struct address_space *mapping; 6591da177e4SLinus Torvalds 66014f27939SMilan Broz /* if no new file, only flush of queued bios requested */ 66114f27939SMilan Broz if (!file) 66214f27939SMilan Broz goto out; 66314f27939SMilan Broz 66414f27939SMilan Broz mapping = file->f_mapping; 6651da177e4SLinus Torvalds mapping_set_gfp_mask(old_file->f_mapping, lo->old_gfp_mask); 6661da177e4SLinus Torvalds lo->lo_backing_file = file; 667ba52de12STheodore Ts'o lo->lo_blocksize = S_ISBLK(mapping->host->i_mode) ? 668ba52de12STheodore Ts'o mapping->host->i_bdev->bd_block_size : PAGE_SIZE; 6691da177e4SLinus Torvalds lo->old_gfp_mask = mapping_gfp_mask(mapping); 6701da177e4SLinus Torvalds mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS)); 67114f27939SMilan Broz out: 6721da177e4SLinus Torvalds complete(&p->wait); 6731da177e4SLinus Torvalds } 6741da177e4SLinus Torvalds 6751da177e4SLinus Torvalds 6761da177e4SLinus Torvalds /* 6771da177e4SLinus Torvalds * loop_change_fd switched the backing store of a loopback device to 6781da177e4SLinus Torvalds * a new file. This is useful for operating system installers to free up 6791da177e4SLinus Torvalds * the original file and in High Availability environments to switch to 6801da177e4SLinus Torvalds * an alternative location for the content in case of server meltdown. 6811da177e4SLinus Torvalds * This can only work if the loop device is used read-only, and if the 6821da177e4SLinus Torvalds * new backing store is the same size and type as the old backing store. 6831da177e4SLinus Torvalds */ 684bb214884SAl Viro static int loop_change_fd(struct loop_device *lo, struct block_device *bdev, 685bb214884SAl Viro unsigned int arg) 6861da177e4SLinus Torvalds { 6871da177e4SLinus Torvalds struct file *file, *old_file; 6881da177e4SLinus Torvalds struct inode *inode; 6891da177e4SLinus Torvalds int error; 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds error = -ENXIO; 6921da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 6931da177e4SLinus Torvalds goto out; 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds /* the loop device has to be read-only */ 6961da177e4SLinus Torvalds error = -EINVAL; 6971da177e4SLinus Torvalds if (!(lo->lo_flags & LO_FLAGS_READ_ONLY)) 6981da177e4SLinus Torvalds goto out; 6991da177e4SLinus Torvalds 7001da177e4SLinus Torvalds error = -EBADF; 7011da177e4SLinus Torvalds file = fget(arg); 7021da177e4SLinus Torvalds if (!file) 7031da177e4SLinus Torvalds goto out; 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds inode = file->f_mapping->host; 7061da177e4SLinus Torvalds old_file = lo->lo_backing_file; 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds error = -EINVAL; 7091da177e4SLinus Torvalds 7101da177e4SLinus Torvalds if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode)) 7111da177e4SLinus Torvalds goto out_putf; 7121da177e4SLinus Torvalds 7131da177e4SLinus Torvalds /* size of the new backing store needs to be the same */ 7141da177e4SLinus Torvalds if (get_loop_size(lo, file) != get_loop_size(lo, old_file)) 7151da177e4SLinus Torvalds goto out_putf; 7161da177e4SLinus Torvalds 7171da177e4SLinus Torvalds /* and ... switch */ 7181da177e4SLinus Torvalds error = loop_switch(lo, file); 7191da177e4SLinus Torvalds if (error) 7201da177e4SLinus Torvalds goto out_putf; 7211da177e4SLinus Torvalds 7221da177e4SLinus Torvalds fput(old_file); 723476a4813SLaurent Vivier if (max_part > 0) 724476a4813SLaurent Vivier ioctl_by_bdev(bdev, BLKRRPART, 0); 7251da177e4SLinus Torvalds return 0; 7261da177e4SLinus Torvalds 7271da177e4SLinus Torvalds out_putf: 7281da177e4SLinus Torvalds fput(file); 7291da177e4SLinus Torvalds out: 7301da177e4SLinus Torvalds return error; 7311da177e4SLinus Torvalds } 7321da177e4SLinus Torvalds 7331da177e4SLinus Torvalds static inline int is_loop_device(struct file *file) 7341da177e4SLinus Torvalds { 7351da177e4SLinus Torvalds struct inode *i = file->f_mapping->host; 7361da177e4SLinus Torvalds 7371da177e4SLinus Torvalds return i && S_ISBLK(i->i_mode) && MAJOR(i->i_rdev) == LOOP_MAJOR; 7381da177e4SLinus Torvalds } 7391da177e4SLinus Torvalds 740bb214884SAl Viro static int loop_set_fd(struct loop_device *lo, fmode_t mode, 7411da177e4SLinus Torvalds struct block_device *bdev, unsigned int arg) 7421da177e4SLinus Torvalds { 7431da177e4SLinus Torvalds struct file *file, *f; 7441da177e4SLinus Torvalds struct inode *inode; 7451da177e4SLinus Torvalds struct address_space *mapping; 7461da177e4SLinus Torvalds unsigned lo_blocksize; 7471da177e4SLinus Torvalds int lo_flags = 0; 7481da177e4SLinus Torvalds int error; 7491da177e4SLinus Torvalds loff_t size; 7501da177e4SLinus Torvalds 7511da177e4SLinus Torvalds /* This is safe, since we have a reference from open(). */ 7521da177e4SLinus Torvalds __module_get(THIS_MODULE); 7531da177e4SLinus Torvalds 7541da177e4SLinus Torvalds error = -EBADF; 7551da177e4SLinus Torvalds file = fget(arg); 7561da177e4SLinus Torvalds if (!file) 7571da177e4SLinus Torvalds goto out; 7581da177e4SLinus Torvalds 7591da177e4SLinus Torvalds error = -EBUSY; 7601da177e4SLinus Torvalds if (lo->lo_state != Lo_unbound) 7611da177e4SLinus Torvalds goto out_putf; 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds /* Avoid recursion */ 7641da177e4SLinus Torvalds f = file; 7651da177e4SLinus Torvalds while (is_loop_device(f)) { 7661da177e4SLinus Torvalds struct loop_device *l; 7671da177e4SLinus Torvalds 768bb214884SAl Viro if (f->f_mapping->host->i_bdev == bdev) 7691da177e4SLinus Torvalds goto out_putf; 7701da177e4SLinus Torvalds 7711da177e4SLinus Torvalds l = f->f_mapping->host->i_bdev->bd_disk->private_data; 7721da177e4SLinus Torvalds if (l->lo_state == Lo_unbound) { 7731da177e4SLinus Torvalds error = -EINVAL; 7741da177e4SLinus Torvalds goto out_putf; 7751da177e4SLinus Torvalds } 7761da177e4SLinus Torvalds f = l->lo_backing_file; 7771da177e4SLinus Torvalds } 7781da177e4SLinus Torvalds 7791da177e4SLinus Torvalds mapping = file->f_mapping; 7801da177e4SLinus Torvalds inode = mapping->host; 7811da177e4SLinus Torvalds 7821da177e4SLinus Torvalds if (!(file->f_mode & FMODE_WRITE)) 7831da177e4SLinus Torvalds lo_flags |= LO_FLAGS_READ_ONLY; 7841da177e4SLinus Torvalds 7851da177e4SLinus Torvalds error = -EINVAL; 7861da177e4SLinus Torvalds if (S_ISREG(inode->i_mode) || S_ISBLK(inode->i_mode)) { 787f5e54d6eSChristoph Hellwig const struct address_space_operations *aops = mapping->a_ops; 7886818173bSMiklos Szeredi 7894e02ed4bSNick Piggin if (aops->write_begin) 7901da177e4SLinus Torvalds lo_flags |= LO_FLAGS_USE_AOPS; 7911da177e4SLinus Torvalds if (!(lo_flags & LO_FLAGS_USE_AOPS) && !file->f_op->write) 7921da177e4SLinus Torvalds lo_flags |= LO_FLAGS_READ_ONLY; 7931da177e4SLinus Torvalds 794ba52de12STheodore Ts'o lo_blocksize = S_ISBLK(inode->i_mode) ? 795ba52de12STheodore Ts'o inode->i_bdev->bd_block_size : PAGE_SIZE; 796ba52de12STheodore Ts'o 7971da177e4SLinus Torvalds error = 0; 7981da177e4SLinus Torvalds } else { 7991da177e4SLinus Torvalds goto out_putf; 8001da177e4SLinus Torvalds } 8011da177e4SLinus Torvalds 8021da177e4SLinus Torvalds size = get_loop_size(lo, file); 8031da177e4SLinus Torvalds 8041da177e4SLinus Torvalds if ((loff_t)(sector_t)size != size) { 8051da177e4SLinus Torvalds error = -EFBIG; 8061da177e4SLinus Torvalds goto out_putf; 8071da177e4SLinus Torvalds } 8081da177e4SLinus Torvalds 809bb214884SAl Viro if (!(mode & FMODE_WRITE)) 8101da177e4SLinus Torvalds lo_flags |= LO_FLAGS_READ_ONLY; 8111da177e4SLinus Torvalds 8121da177e4SLinus Torvalds set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0); 8131da177e4SLinus Torvalds 8141da177e4SLinus Torvalds lo->lo_blocksize = lo_blocksize; 8151da177e4SLinus Torvalds lo->lo_device = bdev; 8161da177e4SLinus Torvalds lo->lo_flags = lo_flags; 8171da177e4SLinus Torvalds lo->lo_backing_file = file; 818eefe85eeSConstantine Sapuntzakis lo->transfer = transfer_none; 8191da177e4SLinus Torvalds lo->ioctl = NULL; 8201da177e4SLinus Torvalds lo->lo_sizelimit = 0; 8211da177e4SLinus Torvalds lo->old_gfp_mask = mapping_gfp_mask(mapping); 8221da177e4SLinus Torvalds mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS)); 8231da177e4SLinus Torvalds 824e686307fSAkinobu Mita bio_list_init(&lo->lo_bio_list); 8251da177e4SLinus Torvalds 8261da177e4SLinus Torvalds /* 8271da177e4SLinus Torvalds * set queue make_request_fn, and add limits based on lower level 8281da177e4SLinus Torvalds * device 8291da177e4SLinus Torvalds */ 8301da177e4SLinus Torvalds blk_queue_make_request(lo->lo_queue, loop_make_request); 8311da177e4SLinus Torvalds lo->lo_queue->queuedata = lo; 8321da177e4SLinus Torvalds lo->lo_queue->unplug_fn = loop_unplug; 8331da177e4SLinus Torvalds 83468db1961SNikanth Karthikesan if (!(lo_flags & LO_FLAGS_READ_ONLY) && file->f_op->fsync) 8354913efe4STejun Heo blk_queue_flush(lo->lo_queue, REQ_FLUSH); 83668db1961SNikanth Karthikesan 83773285082SKen Chen set_capacity(lo->lo_disk, size); 8381da177e4SLinus Torvalds bd_set_size(bdev, size << 9); 839c3473c63SDavid Zeuthen /* let user-space know about the new size */ 840c3473c63SDavid Zeuthen kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE); 8411da177e4SLinus Torvalds 8421da177e4SLinus Torvalds set_blocksize(bdev, lo_blocksize); 8431da177e4SLinus Torvalds 8446c997918SSerge E. Hallyn lo->lo_thread = kthread_create(loop_thread, lo, "loop%d", 8456c997918SSerge E. Hallyn lo->lo_number); 8466c997918SSerge E. Hallyn if (IS_ERR(lo->lo_thread)) { 8476c997918SSerge E. Hallyn error = PTR_ERR(lo->lo_thread); 848a7422bf8SSerge E. Hallyn goto out_clr; 8496c997918SSerge E. Hallyn } 8506c997918SSerge E. Hallyn lo->lo_state = Lo_bound; 8516c997918SSerge E. Hallyn wake_up_process(lo->lo_thread); 852476a4813SLaurent Vivier if (max_part > 0) 853476a4813SLaurent Vivier ioctl_by_bdev(bdev, BLKRRPART, 0); 8541da177e4SLinus Torvalds return 0; 8551da177e4SLinus Torvalds 856a7422bf8SSerge E. Hallyn out_clr: 857a7422bf8SSerge E. Hallyn lo->lo_thread = NULL; 858a7422bf8SSerge E. Hallyn lo->lo_device = NULL; 859a7422bf8SSerge E. Hallyn lo->lo_backing_file = NULL; 860a7422bf8SSerge E. Hallyn lo->lo_flags = 0; 86173285082SKen Chen set_capacity(lo->lo_disk, 0); 862f98393a6SPeter Zijlstra invalidate_bdev(bdev); 863a7422bf8SSerge E. Hallyn bd_set_size(bdev, 0); 864c3473c63SDavid Zeuthen kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE); 865a7422bf8SSerge E. Hallyn mapping_set_gfp_mask(mapping, lo->old_gfp_mask); 866a7422bf8SSerge E. Hallyn lo->lo_state = Lo_unbound; 8671da177e4SLinus Torvalds out_putf: 8681da177e4SLinus Torvalds fput(file); 8691da177e4SLinus Torvalds out: 8701da177e4SLinus Torvalds /* This is safe: open() is still holding a reference. */ 8711da177e4SLinus Torvalds module_put(THIS_MODULE); 8721da177e4SLinus Torvalds return error; 8731da177e4SLinus Torvalds } 8741da177e4SLinus Torvalds 8751da177e4SLinus Torvalds static int 8761da177e4SLinus Torvalds loop_release_xfer(struct loop_device *lo) 8771da177e4SLinus Torvalds { 8781da177e4SLinus Torvalds int err = 0; 8791da177e4SLinus Torvalds struct loop_func_table *xfer = lo->lo_encryption; 8801da177e4SLinus Torvalds 8811da177e4SLinus Torvalds if (xfer) { 8821da177e4SLinus Torvalds if (xfer->release) 8831da177e4SLinus Torvalds err = xfer->release(lo); 8841da177e4SLinus Torvalds lo->transfer = NULL; 8851da177e4SLinus Torvalds lo->lo_encryption = NULL; 8861da177e4SLinus Torvalds module_put(xfer->owner); 8871da177e4SLinus Torvalds } 8881da177e4SLinus Torvalds return err; 8891da177e4SLinus Torvalds } 8901da177e4SLinus Torvalds 8911da177e4SLinus Torvalds static int 8921da177e4SLinus Torvalds loop_init_xfer(struct loop_device *lo, struct loop_func_table *xfer, 8931da177e4SLinus Torvalds const struct loop_info64 *i) 8941da177e4SLinus Torvalds { 8951da177e4SLinus Torvalds int err = 0; 8961da177e4SLinus Torvalds 8971da177e4SLinus Torvalds if (xfer) { 8981da177e4SLinus Torvalds struct module *owner = xfer->owner; 8991da177e4SLinus Torvalds 9001da177e4SLinus Torvalds if (!try_module_get(owner)) 9011da177e4SLinus Torvalds return -EINVAL; 9021da177e4SLinus Torvalds if (xfer->init) 9031da177e4SLinus Torvalds err = xfer->init(lo, i); 9041da177e4SLinus Torvalds if (err) 9051da177e4SLinus Torvalds module_put(owner); 9061da177e4SLinus Torvalds else 9071da177e4SLinus Torvalds lo->lo_encryption = xfer; 9081da177e4SLinus Torvalds } 9091da177e4SLinus Torvalds return err; 9101da177e4SLinus Torvalds } 9111da177e4SLinus Torvalds 9121da177e4SLinus Torvalds static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev) 9131da177e4SLinus Torvalds { 9141da177e4SLinus Torvalds struct file *filp = lo->lo_backing_file; 915b4e3ca1aSAl Viro gfp_t gfp = lo->old_gfp_mask; 9161da177e4SLinus Torvalds 9171da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 9181da177e4SLinus Torvalds return -ENXIO; 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds if (lo->lo_refcnt > 1) /* we needed one fd for the ioctl */ 9211da177e4SLinus Torvalds return -EBUSY; 9221da177e4SLinus Torvalds 9231da177e4SLinus Torvalds if (filp == NULL) 9241da177e4SLinus Torvalds return -EINVAL; 9251da177e4SLinus Torvalds 9261da177e4SLinus Torvalds spin_lock_irq(&lo->lo_lock); 9271da177e4SLinus Torvalds lo->lo_state = Lo_rundown; 9281da177e4SLinus Torvalds spin_unlock_irq(&lo->lo_lock); 9291da177e4SLinus Torvalds 9306c997918SSerge E. Hallyn kthread_stop(lo->lo_thread); 9311da177e4SLinus Torvalds 9328ae30b89SMilan Broz lo->lo_queue->unplug_fn = NULL; 9331da177e4SLinus Torvalds lo->lo_backing_file = NULL; 9341da177e4SLinus Torvalds 9351da177e4SLinus Torvalds loop_release_xfer(lo); 9361da177e4SLinus Torvalds lo->transfer = NULL; 9371da177e4SLinus Torvalds lo->ioctl = NULL; 9381da177e4SLinus Torvalds lo->lo_device = NULL; 9391da177e4SLinus Torvalds lo->lo_encryption = NULL; 9401da177e4SLinus Torvalds lo->lo_offset = 0; 9411da177e4SLinus Torvalds lo->lo_sizelimit = 0; 9421da177e4SLinus Torvalds lo->lo_encrypt_key_size = 0; 9431da177e4SLinus Torvalds lo->lo_flags = 0; 9446c997918SSerge E. Hallyn lo->lo_thread = NULL; 9451da177e4SLinus Torvalds memset(lo->lo_encrypt_key, 0, LO_KEY_SIZE); 9461da177e4SLinus Torvalds memset(lo->lo_crypt_name, 0, LO_NAME_SIZE); 9471da177e4SLinus Torvalds memset(lo->lo_file_name, 0, LO_NAME_SIZE); 948bb214884SAl Viro if (bdev) 949f98393a6SPeter Zijlstra invalidate_bdev(bdev); 95073285082SKen Chen set_capacity(lo->lo_disk, 0); 951c3473c63SDavid Zeuthen if (bdev) { 9521da177e4SLinus Torvalds bd_set_size(bdev, 0); 953c3473c63SDavid Zeuthen /* let user-space know about this change */ 954c3473c63SDavid Zeuthen kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE); 955c3473c63SDavid Zeuthen } 9561da177e4SLinus Torvalds mapping_set_gfp_mask(filp->f_mapping, gfp); 9571da177e4SLinus Torvalds lo->lo_state = Lo_unbound; 9581da177e4SLinus Torvalds /* This is safe: open() is still holding a reference. */ 9591da177e4SLinus Torvalds module_put(THIS_MODULE); 960cf6e6932SAlexey Dobriyan if (max_part > 0 && bdev) 961476a4813SLaurent Vivier ioctl_by_bdev(bdev, BLKRRPART, 0); 962f028f3b2SNikanth Karthikesan mutex_unlock(&lo->lo_ctl_mutex); 963f028f3b2SNikanth Karthikesan /* 964f028f3b2SNikanth Karthikesan * Need not hold lo_ctl_mutex to fput backing file. 965f028f3b2SNikanth Karthikesan * Calling fput holding lo_ctl_mutex triggers a circular 966f028f3b2SNikanth Karthikesan * lock dependency possibility warning as fput can take 967f028f3b2SNikanth Karthikesan * bd_mutex which is usually taken before lo_ctl_mutex. 968f028f3b2SNikanth Karthikesan */ 969f028f3b2SNikanth Karthikesan fput(filp); 9701da177e4SLinus Torvalds return 0; 9711da177e4SLinus Torvalds } 9721da177e4SLinus Torvalds 9731da177e4SLinus Torvalds static int 9741da177e4SLinus Torvalds loop_set_status(struct loop_device *lo, const struct loop_info64 *info) 9751da177e4SLinus Torvalds { 9761da177e4SLinus Torvalds int err; 9771da177e4SLinus Torvalds struct loop_func_table *xfer; 978b0fafa81SDavid Howells uid_t uid = current_uid(); 9791da177e4SLinus Torvalds 980b0fafa81SDavid Howells if (lo->lo_encrypt_key_size && 981b0fafa81SDavid Howells lo->lo_key_owner != uid && 9821da177e4SLinus Torvalds !capable(CAP_SYS_ADMIN)) 9831da177e4SLinus Torvalds return -EPERM; 9841da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 9851da177e4SLinus Torvalds return -ENXIO; 9861da177e4SLinus Torvalds if ((unsigned int) info->lo_encrypt_key_size > LO_KEY_SIZE) 9871da177e4SLinus Torvalds return -EINVAL; 9881da177e4SLinus Torvalds 9891da177e4SLinus Torvalds err = loop_release_xfer(lo); 9901da177e4SLinus Torvalds if (err) 9911da177e4SLinus Torvalds return err; 9921da177e4SLinus Torvalds 9931da177e4SLinus Torvalds if (info->lo_encrypt_type) { 9941da177e4SLinus Torvalds unsigned int type = info->lo_encrypt_type; 9951da177e4SLinus Torvalds 9961da177e4SLinus Torvalds if (type >= MAX_LO_CRYPT) 9971da177e4SLinus Torvalds return -EINVAL; 9981da177e4SLinus Torvalds xfer = xfer_funcs[type]; 9991da177e4SLinus Torvalds if (xfer == NULL) 10001da177e4SLinus Torvalds return -EINVAL; 10011da177e4SLinus Torvalds } else 10021da177e4SLinus Torvalds xfer = NULL; 10031da177e4SLinus Torvalds 10041da177e4SLinus Torvalds err = loop_init_xfer(lo, xfer, info); 10051da177e4SLinus Torvalds if (err) 10061da177e4SLinus Torvalds return err; 10071da177e4SLinus Torvalds 10081da177e4SLinus Torvalds if (lo->lo_offset != info->lo_offset || 10091da177e4SLinus Torvalds lo->lo_sizelimit != info->lo_sizelimit) { 10101da177e4SLinus Torvalds lo->lo_offset = info->lo_offset; 10111da177e4SLinus Torvalds lo->lo_sizelimit = info->lo_sizelimit; 10121da177e4SLinus Torvalds if (figure_loop_size(lo)) 10131da177e4SLinus Torvalds return -EFBIG; 10141da177e4SLinus Torvalds } 10151da177e4SLinus Torvalds 10161da177e4SLinus Torvalds memcpy(lo->lo_file_name, info->lo_file_name, LO_NAME_SIZE); 10171da177e4SLinus Torvalds memcpy(lo->lo_crypt_name, info->lo_crypt_name, LO_NAME_SIZE); 10181da177e4SLinus Torvalds lo->lo_file_name[LO_NAME_SIZE-1] = 0; 10191da177e4SLinus Torvalds lo->lo_crypt_name[LO_NAME_SIZE-1] = 0; 10201da177e4SLinus Torvalds 10211da177e4SLinus Torvalds if (!xfer) 10221da177e4SLinus Torvalds xfer = &none_funcs; 10231da177e4SLinus Torvalds lo->transfer = xfer->transfer; 10241da177e4SLinus Torvalds lo->ioctl = xfer->ioctl; 10251da177e4SLinus Torvalds 102696c58655SDavid Woodhouse if ((lo->lo_flags & LO_FLAGS_AUTOCLEAR) != 102796c58655SDavid Woodhouse (info->lo_flags & LO_FLAGS_AUTOCLEAR)) 102896c58655SDavid Woodhouse lo->lo_flags ^= LO_FLAGS_AUTOCLEAR; 102996c58655SDavid Woodhouse 10301da177e4SLinus Torvalds lo->lo_encrypt_key_size = info->lo_encrypt_key_size; 10311da177e4SLinus Torvalds lo->lo_init[0] = info->lo_init[0]; 10321da177e4SLinus Torvalds lo->lo_init[1] = info->lo_init[1]; 10331da177e4SLinus Torvalds if (info->lo_encrypt_key_size) { 10341da177e4SLinus Torvalds memcpy(lo->lo_encrypt_key, info->lo_encrypt_key, 10351da177e4SLinus Torvalds info->lo_encrypt_key_size); 1036b0fafa81SDavid Howells lo->lo_key_owner = uid; 10371da177e4SLinus Torvalds } 10381da177e4SLinus Torvalds 10391da177e4SLinus Torvalds return 0; 10401da177e4SLinus Torvalds } 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds static int 10431da177e4SLinus Torvalds loop_get_status(struct loop_device *lo, struct loop_info64 *info) 10441da177e4SLinus Torvalds { 10451da177e4SLinus Torvalds struct file *file = lo->lo_backing_file; 10461da177e4SLinus Torvalds struct kstat stat; 10471da177e4SLinus Torvalds int error; 10481da177e4SLinus Torvalds 10491da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 10501da177e4SLinus Torvalds return -ENXIO; 10516c648be6SJosef Sipek error = vfs_getattr(file->f_path.mnt, file->f_path.dentry, &stat); 10521da177e4SLinus Torvalds if (error) 10531da177e4SLinus Torvalds return error; 10541da177e4SLinus Torvalds memset(info, 0, sizeof(*info)); 10551da177e4SLinus Torvalds info->lo_number = lo->lo_number; 10561da177e4SLinus Torvalds info->lo_device = huge_encode_dev(stat.dev); 10571da177e4SLinus Torvalds info->lo_inode = stat.ino; 10581da177e4SLinus Torvalds info->lo_rdevice = huge_encode_dev(lo->lo_device ? stat.rdev : stat.dev); 10591da177e4SLinus Torvalds info->lo_offset = lo->lo_offset; 10601da177e4SLinus Torvalds info->lo_sizelimit = lo->lo_sizelimit; 10611da177e4SLinus Torvalds info->lo_flags = lo->lo_flags; 10621da177e4SLinus Torvalds memcpy(info->lo_file_name, lo->lo_file_name, LO_NAME_SIZE); 10631da177e4SLinus Torvalds memcpy(info->lo_crypt_name, lo->lo_crypt_name, LO_NAME_SIZE); 10641da177e4SLinus Torvalds info->lo_encrypt_type = 10651da177e4SLinus Torvalds lo->lo_encryption ? lo->lo_encryption->number : 0; 10661da177e4SLinus Torvalds if (lo->lo_encrypt_key_size && capable(CAP_SYS_ADMIN)) { 10671da177e4SLinus Torvalds info->lo_encrypt_key_size = lo->lo_encrypt_key_size; 10681da177e4SLinus Torvalds memcpy(info->lo_encrypt_key, lo->lo_encrypt_key, 10691da177e4SLinus Torvalds lo->lo_encrypt_key_size); 10701da177e4SLinus Torvalds } 10711da177e4SLinus Torvalds return 0; 10721da177e4SLinus Torvalds } 10731da177e4SLinus Torvalds 10741da177e4SLinus Torvalds static void 10751da177e4SLinus Torvalds loop_info64_from_old(const struct loop_info *info, struct loop_info64 *info64) 10761da177e4SLinus Torvalds { 10771da177e4SLinus Torvalds memset(info64, 0, sizeof(*info64)); 10781da177e4SLinus Torvalds info64->lo_number = info->lo_number; 10791da177e4SLinus Torvalds info64->lo_device = info->lo_device; 10801da177e4SLinus Torvalds info64->lo_inode = info->lo_inode; 10811da177e4SLinus Torvalds info64->lo_rdevice = info->lo_rdevice; 10821da177e4SLinus Torvalds info64->lo_offset = info->lo_offset; 10831da177e4SLinus Torvalds info64->lo_sizelimit = 0; 10841da177e4SLinus Torvalds info64->lo_encrypt_type = info->lo_encrypt_type; 10851da177e4SLinus Torvalds info64->lo_encrypt_key_size = info->lo_encrypt_key_size; 10861da177e4SLinus Torvalds info64->lo_flags = info->lo_flags; 10871da177e4SLinus Torvalds info64->lo_init[0] = info->lo_init[0]; 10881da177e4SLinus Torvalds info64->lo_init[1] = info->lo_init[1]; 10891da177e4SLinus Torvalds if (info->lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 10901da177e4SLinus Torvalds memcpy(info64->lo_crypt_name, info->lo_name, LO_NAME_SIZE); 10911da177e4SLinus Torvalds else 10921da177e4SLinus Torvalds memcpy(info64->lo_file_name, info->lo_name, LO_NAME_SIZE); 10931da177e4SLinus Torvalds memcpy(info64->lo_encrypt_key, info->lo_encrypt_key, LO_KEY_SIZE); 10941da177e4SLinus Torvalds } 10951da177e4SLinus Torvalds 10961da177e4SLinus Torvalds static int 10971da177e4SLinus Torvalds loop_info64_to_old(const struct loop_info64 *info64, struct loop_info *info) 10981da177e4SLinus Torvalds { 10991da177e4SLinus Torvalds memset(info, 0, sizeof(*info)); 11001da177e4SLinus Torvalds info->lo_number = info64->lo_number; 11011da177e4SLinus Torvalds info->lo_device = info64->lo_device; 11021da177e4SLinus Torvalds info->lo_inode = info64->lo_inode; 11031da177e4SLinus Torvalds info->lo_rdevice = info64->lo_rdevice; 11041da177e4SLinus Torvalds info->lo_offset = info64->lo_offset; 11051da177e4SLinus Torvalds info->lo_encrypt_type = info64->lo_encrypt_type; 11061da177e4SLinus Torvalds info->lo_encrypt_key_size = info64->lo_encrypt_key_size; 11071da177e4SLinus Torvalds info->lo_flags = info64->lo_flags; 11081da177e4SLinus Torvalds info->lo_init[0] = info64->lo_init[0]; 11091da177e4SLinus Torvalds info->lo_init[1] = info64->lo_init[1]; 11101da177e4SLinus Torvalds if (info->lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 11111da177e4SLinus Torvalds memcpy(info->lo_name, info64->lo_crypt_name, LO_NAME_SIZE); 11121da177e4SLinus Torvalds else 11131da177e4SLinus Torvalds memcpy(info->lo_name, info64->lo_file_name, LO_NAME_SIZE); 11141da177e4SLinus Torvalds memcpy(info->lo_encrypt_key, info64->lo_encrypt_key, LO_KEY_SIZE); 11151da177e4SLinus Torvalds 11161da177e4SLinus Torvalds /* error in case values were truncated */ 11171da177e4SLinus Torvalds if (info->lo_device != info64->lo_device || 11181da177e4SLinus Torvalds info->lo_rdevice != info64->lo_rdevice || 11191da177e4SLinus Torvalds info->lo_inode != info64->lo_inode || 11201da177e4SLinus Torvalds info->lo_offset != info64->lo_offset) 11211da177e4SLinus Torvalds return -EOVERFLOW; 11221da177e4SLinus Torvalds 11231da177e4SLinus Torvalds return 0; 11241da177e4SLinus Torvalds } 11251da177e4SLinus Torvalds 11261da177e4SLinus Torvalds static int 11271da177e4SLinus Torvalds loop_set_status_old(struct loop_device *lo, const struct loop_info __user *arg) 11281da177e4SLinus Torvalds { 11291da177e4SLinus Torvalds struct loop_info info; 11301da177e4SLinus Torvalds struct loop_info64 info64; 11311da177e4SLinus Torvalds 11321da177e4SLinus Torvalds if (copy_from_user(&info, arg, sizeof (struct loop_info))) 11331da177e4SLinus Torvalds return -EFAULT; 11341da177e4SLinus Torvalds loop_info64_from_old(&info, &info64); 11351da177e4SLinus Torvalds return loop_set_status(lo, &info64); 11361da177e4SLinus Torvalds } 11371da177e4SLinus Torvalds 11381da177e4SLinus Torvalds static int 11391da177e4SLinus Torvalds loop_set_status64(struct loop_device *lo, const struct loop_info64 __user *arg) 11401da177e4SLinus Torvalds { 11411da177e4SLinus Torvalds struct loop_info64 info64; 11421da177e4SLinus Torvalds 11431da177e4SLinus Torvalds if (copy_from_user(&info64, arg, sizeof (struct loop_info64))) 11441da177e4SLinus Torvalds return -EFAULT; 11451da177e4SLinus Torvalds return loop_set_status(lo, &info64); 11461da177e4SLinus Torvalds } 11471da177e4SLinus Torvalds 11481da177e4SLinus Torvalds static int 11491da177e4SLinus Torvalds loop_get_status_old(struct loop_device *lo, struct loop_info __user *arg) { 11501da177e4SLinus Torvalds struct loop_info info; 11511da177e4SLinus Torvalds struct loop_info64 info64; 11521da177e4SLinus Torvalds int err = 0; 11531da177e4SLinus Torvalds 11541da177e4SLinus Torvalds if (!arg) 11551da177e4SLinus Torvalds err = -EINVAL; 11561da177e4SLinus Torvalds if (!err) 11571da177e4SLinus Torvalds err = loop_get_status(lo, &info64); 11581da177e4SLinus Torvalds if (!err) 11591da177e4SLinus Torvalds err = loop_info64_to_old(&info64, &info); 11601da177e4SLinus Torvalds if (!err && copy_to_user(arg, &info, sizeof(info))) 11611da177e4SLinus Torvalds err = -EFAULT; 11621da177e4SLinus Torvalds 11631da177e4SLinus Torvalds return err; 11641da177e4SLinus Torvalds } 11651da177e4SLinus Torvalds 11661da177e4SLinus Torvalds static int 11671da177e4SLinus Torvalds loop_get_status64(struct loop_device *lo, struct loop_info64 __user *arg) { 11681da177e4SLinus Torvalds struct loop_info64 info64; 11691da177e4SLinus Torvalds int err = 0; 11701da177e4SLinus Torvalds 11711da177e4SLinus Torvalds if (!arg) 11721da177e4SLinus Torvalds err = -EINVAL; 11731da177e4SLinus Torvalds if (!err) 11741da177e4SLinus Torvalds err = loop_get_status(lo, &info64); 11751da177e4SLinus Torvalds if (!err && copy_to_user(arg, &info64, sizeof(info64))) 11761da177e4SLinus Torvalds err = -EFAULT; 11771da177e4SLinus Torvalds 11781da177e4SLinus Torvalds return err; 11791da177e4SLinus Torvalds } 11801da177e4SLinus Torvalds 118153d66608SJ. R. Okajima static int loop_set_capacity(struct loop_device *lo, struct block_device *bdev) 118253d66608SJ. R. Okajima { 118353d66608SJ. R. Okajima int err; 118453d66608SJ. R. Okajima sector_t sec; 118553d66608SJ. R. Okajima loff_t sz; 118653d66608SJ. R. Okajima 118753d66608SJ. R. Okajima err = -ENXIO; 118853d66608SJ. R. Okajima if (unlikely(lo->lo_state != Lo_bound)) 118953d66608SJ. R. Okajima goto out; 119053d66608SJ. R. Okajima err = figure_loop_size(lo); 119153d66608SJ. R. Okajima if (unlikely(err)) 119253d66608SJ. R. Okajima goto out; 119353d66608SJ. R. Okajima sec = get_capacity(lo->lo_disk); 119453d66608SJ. R. Okajima /* the width of sector_t may be narrow for bit-shift */ 119553d66608SJ. R. Okajima sz = sec; 119653d66608SJ. R. Okajima sz <<= 9; 119753d66608SJ. R. Okajima mutex_lock(&bdev->bd_mutex); 119853d66608SJ. R. Okajima bd_set_size(bdev, sz); 1199c3473c63SDavid Zeuthen /* let user-space know about the new size */ 1200c3473c63SDavid Zeuthen kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE); 120153d66608SJ. R. Okajima mutex_unlock(&bdev->bd_mutex); 120253d66608SJ. R. Okajima 120353d66608SJ. R. Okajima out: 120453d66608SJ. R. Okajima return err; 120553d66608SJ. R. Okajima } 120653d66608SJ. R. Okajima 1207bb214884SAl Viro static int lo_ioctl(struct block_device *bdev, fmode_t mode, 12081da177e4SLinus Torvalds unsigned int cmd, unsigned long arg) 12091da177e4SLinus Torvalds { 1210bb214884SAl Viro struct loop_device *lo = bdev->bd_disk->private_data; 12111da177e4SLinus Torvalds int err; 12121da177e4SLinus Torvalds 1213f028f3b2SNikanth Karthikesan mutex_lock_nested(&lo->lo_ctl_mutex, 1); 12141da177e4SLinus Torvalds switch (cmd) { 12151da177e4SLinus Torvalds case LOOP_SET_FD: 1216bb214884SAl Viro err = loop_set_fd(lo, mode, bdev, arg); 12171da177e4SLinus Torvalds break; 12181da177e4SLinus Torvalds case LOOP_CHANGE_FD: 1219bb214884SAl Viro err = loop_change_fd(lo, bdev, arg); 12201da177e4SLinus Torvalds break; 12211da177e4SLinus Torvalds case LOOP_CLR_FD: 1222f028f3b2SNikanth Karthikesan /* loop_clr_fd would have unlocked lo_ctl_mutex on success */ 1223bb214884SAl Viro err = loop_clr_fd(lo, bdev); 1224f028f3b2SNikanth Karthikesan if (!err) 1225f028f3b2SNikanth Karthikesan goto out_unlocked; 12261da177e4SLinus Torvalds break; 12271da177e4SLinus Torvalds case LOOP_SET_STATUS: 12281da177e4SLinus Torvalds err = loop_set_status_old(lo, (struct loop_info __user *) arg); 12291da177e4SLinus Torvalds break; 12301da177e4SLinus Torvalds case LOOP_GET_STATUS: 12311da177e4SLinus Torvalds err = loop_get_status_old(lo, (struct loop_info __user *) arg); 12321da177e4SLinus Torvalds break; 12331da177e4SLinus Torvalds case LOOP_SET_STATUS64: 12341da177e4SLinus Torvalds err = loop_set_status64(lo, (struct loop_info64 __user *) arg); 12351da177e4SLinus Torvalds break; 12361da177e4SLinus Torvalds case LOOP_GET_STATUS64: 12371da177e4SLinus Torvalds err = loop_get_status64(lo, (struct loop_info64 __user *) arg); 12381da177e4SLinus Torvalds break; 123953d66608SJ. R. Okajima case LOOP_SET_CAPACITY: 124053d66608SJ. R. Okajima err = -EPERM; 124153d66608SJ. R. Okajima if ((mode & FMODE_WRITE) || capable(CAP_SYS_ADMIN)) 124253d66608SJ. R. Okajima err = loop_set_capacity(lo, bdev); 124353d66608SJ. R. Okajima break; 12441da177e4SLinus Torvalds default: 12451da177e4SLinus Torvalds err = lo->ioctl ? lo->ioctl(lo, cmd, arg) : -EINVAL; 12461da177e4SLinus Torvalds } 1247f85221ddSIngo Molnar mutex_unlock(&lo->lo_ctl_mutex); 1248f028f3b2SNikanth Karthikesan 1249f028f3b2SNikanth Karthikesan out_unlocked: 12501da177e4SLinus Torvalds return err; 12511da177e4SLinus Torvalds } 12521da177e4SLinus Torvalds 1253863d5b82SDavid Howells #ifdef CONFIG_COMPAT 1254863d5b82SDavid Howells struct compat_loop_info { 1255863d5b82SDavid Howells compat_int_t lo_number; /* ioctl r/o */ 1256863d5b82SDavid Howells compat_dev_t lo_device; /* ioctl r/o */ 1257863d5b82SDavid Howells compat_ulong_t lo_inode; /* ioctl r/o */ 1258863d5b82SDavid Howells compat_dev_t lo_rdevice; /* ioctl r/o */ 1259863d5b82SDavid Howells compat_int_t lo_offset; 1260863d5b82SDavid Howells compat_int_t lo_encrypt_type; 1261863d5b82SDavid Howells compat_int_t lo_encrypt_key_size; /* ioctl w/o */ 1262863d5b82SDavid Howells compat_int_t lo_flags; /* ioctl r/o */ 1263863d5b82SDavid Howells char lo_name[LO_NAME_SIZE]; 1264863d5b82SDavid Howells unsigned char lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */ 1265863d5b82SDavid Howells compat_ulong_t lo_init[2]; 1266863d5b82SDavid Howells char reserved[4]; 1267863d5b82SDavid Howells }; 1268863d5b82SDavid Howells 1269863d5b82SDavid Howells /* 1270863d5b82SDavid Howells * Transfer 32-bit compatibility structure in userspace to 64-bit loop info 1271863d5b82SDavid Howells * - noinlined to reduce stack space usage in main part of driver 1272863d5b82SDavid Howells */ 1273863d5b82SDavid Howells static noinline int 1274ba674cfcSAl Viro loop_info64_from_compat(const struct compat_loop_info __user *arg, 1275863d5b82SDavid Howells struct loop_info64 *info64) 1276863d5b82SDavid Howells { 1277863d5b82SDavid Howells struct compat_loop_info info; 1278863d5b82SDavid Howells 1279863d5b82SDavid Howells if (copy_from_user(&info, arg, sizeof(info))) 1280863d5b82SDavid Howells return -EFAULT; 1281863d5b82SDavid Howells 1282863d5b82SDavid Howells memset(info64, 0, sizeof(*info64)); 1283863d5b82SDavid Howells info64->lo_number = info.lo_number; 1284863d5b82SDavid Howells info64->lo_device = info.lo_device; 1285863d5b82SDavid Howells info64->lo_inode = info.lo_inode; 1286863d5b82SDavid Howells info64->lo_rdevice = info.lo_rdevice; 1287863d5b82SDavid Howells info64->lo_offset = info.lo_offset; 1288863d5b82SDavid Howells info64->lo_sizelimit = 0; 1289863d5b82SDavid Howells info64->lo_encrypt_type = info.lo_encrypt_type; 1290863d5b82SDavid Howells info64->lo_encrypt_key_size = info.lo_encrypt_key_size; 1291863d5b82SDavid Howells info64->lo_flags = info.lo_flags; 1292863d5b82SDavid Howells info64->lo_init[0] = info.lo_init[0]; 1293863d5b82SDavid Howells info64->lo_init[1] = info.lo_init[1]; 1294863d5b82SDavid Howells if (info.lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 1295863d5b82SDavid Howells memcpy(info64->lo_crypt_name, info.lo_name, LO_NAME_SIZE); 1296863d5b82SDavid Howells else 1297863d5b82SDavid Howells memcpy(info64->lo_file_name, info.lo_name, LO_NAME_SIZE); 1298863d5b82SDavid Howells memcpy(info64->lo_encrypt_key, info.lo_encrypt_key, LO_KEY_SIZE); 1299863d5b82SDavid Howells return 0; 1300863d5b82SDavid Howells } 1301863d5b82SDavid Howells 1302863d5b82SDavid Howells /* 1303863d5b82SDavid Howells * Transfer 64-bit loop info to 32-bit compatibility structure in userspace 1304863d5b82SDavid Howells * - noinlined to reduce stack space usage in main part of driver 1305863d5b82SDavid Howells */ 1306863d5b82SDavid Howells static noinline int 1307863d5b82SDavid Howells loop_info64_to_compat(const struct loop_info64 *info64, 1308863d5b82SDavid Howells struct compat_loop_info __user *arg) 1309863d5b82SDavid Howells { 1310863d5b82SDavid Howells struct compat_loop_info info; 1311863d5b82SDavid Howells 1312863d5b82SDavid Howells memset(&info, 0, sizeof(info)); 1313863d5b82SDavid Howells info.lo_number = info64->lo_number; 1314863d5b82SDavid Howells info.lo_device = info64->lo_device; 1315863d5b82SDavid Howells info.lo_inode = info64->lo_inode; 1316863d5b82SDavid Howells info.lo_rdevice = info64->lo_rdevice; 1317863d5b82SDavid Howells info.lo_offset = info64->lo_offset; 1318863d5b82SDavid Howells info.lo_encrypt_type = info64->lo_encrypt_type; 1319863d5b82SDavid Howells info.lo_encrypt_key_size = info64->lo_encrypt_key_size; 1320863d5b82SDavid Howells info.lo_flags = info64->lo_flags; 1321863d5b82SDavid Howells info.lo_init[0] = info64->lo_init[0]; 1322863d5b82SDavid Howells info.lo_init[1] = info64->lo_init[1]; 1323863d5b82SDavid Howells if (info.lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 1324863d5b82SDavid Howells memcpy(info.lo_name, info64->lo_crypt_name, LO_NAME_SIZE); 1325863d5b82SDavid Howells else 1326863d5b82SDavid Howells memcpy(info.lo_name, info64->lo_file_name, LO_NAME_SIZE); 1327863d5b82SDavid Howells memcpy(info.lo_encrypt_key, info64->lo_encrypt_key, LO_KEY_SIZE); 1328863d5b82SDavid Howells 1329863d5b82SDavid Howells /* error in case values were truncated */ 1330863d5b82SDavid Howells if (info.lo_device != info64->lo_device || 1331863d5b82SDavid Howells info.lo_rdevice != info64->lo_rdevice || 1332863d5b82SDavid Howells info.lo_inode != info64->lo_inode || 1333863d5b82SDavid Howells info.lo_offset != info64->lo_offset || 1334863d5b82SDavid Howells info.lo_init[0] != info64->lo_init[0] || 1335863d5b82SDavid Howells info.lo_init[1] != info64->lo_init[1]) 1336863d5b82SDavid Howells return -EOVERFLOW; 1337863d5b82SDavid Howells 1338863d5b82SDavid Howells if (copy_to_user(arg, &info, sizeof(info))) 1339863d5b82SDavid Howells return -EFAULT; 1340863d5b82SDavid Howells return 0; 1341863d5b82SDavid Howells } 1342863d5b82SDavid Howells 1343863d5b82SDavid Howells static int 1344863d5b82SDavid Howells loop_set_status_compat(struct loop_device *lo, 1345863d5b82SDavid Howells const struct compat_loop_info __user *arg) 1346863d5b82SDavid Howells { 1347863d5b82SDavid Howells struct loop_info64 info64; 1348863d5b82SDavid Howells int ret; 1349863d5b82SDavid Howells 1350863d5b82SDavid Howells ret = loop_info64_from_compat(arg, &info64); 1351863d5b82SDavid Howells if (ret < 0) 1352863d5b82SDavid Howells return ret; 1353863d5b82SDavid Howells return loop_set_status(lo, &info64); 1354863d5b82SDavid Howells } 1355863d5b82SDavid Howells 1356863d5b82SDavid Howells static int 1357863d5b82SDavid Howells loop_get_status_compat(struct loop_device *lo, 1358863d5b82SDavid Howells struct compat_loop_info __user *arg) 1359863d5b82SDavid Howells { 1360863d5b82SDavid Howells struct loop_info64 info64; 1361863d5b82SDavid Howells int err = 0; 1362863d5b82SDavid Howells 1363863d5b82SDavid Howells if (!arg) 1364863d5b82SDavid Howells err = -EINVAL; 1365863d5b82SDavid Howells if (!err) 1366863d5b82SDavid Howells err = loop_get_status(lo, &info64); 1367863d5b82SDavid Howells if (!err) 1368863d5b82SDavid Howells err = loop_info64_to_compat(&info64, arg); 1369863d5b82SDavid Howells return err; 1370863d5b82SDavid Howells } 1371863d5b82SDavid Howells 1372bb214884SAl Viro static int lo_compat_ioctl(struct block_device *bdev, fmode_t mode, 1373bb214884SAl Viro unsigned int cmd, unsigned long arg) 1374863d5b82SDavid Howells { 1375bb214884SAl Viro struct loop_device *lo = bdev->bd_disk->private_data; 1376863d5b82SDavid Howells int err; 1377863d5b82SDavid Howells 1378863d5b82SDavid Howells switch(cmd) { 1379863d5b82SDavid Howells case LOOP_SET_STATUS: 1380863d5b82SDavid Howells mutex_lock(&lo->lo_ctl_mutex); 1381863d5b82SDavid Howells err = loop_set_status_compat( 1382863d5b82SDavid Howells lo, (const struct compat_loop_info __user *) arg); 1383863d5b82SDavid Howells mutex_unlock(&lo->lo_ctl_mutex); 1384863d5b82SDavid Howells break; 1385863d5b82SDavid Howells case LOOP_GET_STATUS: 1386863d5b82SDavid Howells mutex_lock(&lo->lo_ctl_mutex); 1387863d5b82SDavid Howells err = loop_get_status_compat( 1388863d5b82SDavid Howells lo, (struct compat_loop_info __user *) arg); 1389863d5b82SDavid Howells mutex_unlock(&lo->lo_ctl_mutex); 1390863d5b82SDavid Howells break; 139153d66608SJ. R. Okajima case LOOP_SET_CAPACITY: 1392863d5b82SDavid Howells case LOOP_CLR_FD: 1393863d5b82SDavid Howells case LOOP_GET_STATUS64: 1394863d5b82SDavid Howells case LOOP_SET_STATUS64: 1395863d5b82SDavid Howells arg = (unsigned long) compat_ptr(arg); 1396863d5b82SDavid Howells case LOOP_SET_FD: 1397863d5b82SDavid Howells case LOOP_CHANGE_FD: 1398bb214884SAl Viro err = lo_ioctl(bdev, mode, cmd, arg); 1399863d5b82SDavid Howells break; 1400863d5b82SDavid Howells default: 1401863d5b82SDavid Howells err = -ENOIOCTLCMD; 1402863d5b82SDavid Howells break; 1403863d5b82SDavid Howells } 1404863d5b82SDavid Howells return err; 1405863d5b82SDavid Howells } 1406863d5b82SDavid Howells #endif 1407863d5b82SDavid Howells 1408bb214884SAl Viro static int lo_open(struct block_device *bdev, fmode_t mode) 14091da177e4SLinus Torvalds { 1410bb214884SAl Viro struct loop_device *lo = bdev->bd_disk->private_data; 14111da177e4SLinus Torvalds 14126e9624b8SArnd Bergmann lock_kernel(); 1413f85221ddSIngo Molnar mutex_lock(&lo->lo_ctl_mutex); 14141da177e4SLinus Torvalds lo->lo_refcnt++; 1415f85221ddSIngo Molnar mutex_unlock(&lo->lo_ctl_mutex); 14166e9624b8SArnd Bergmann unlock_kernel(); 14171da177e4SLinus Torvalds 14181da177e4SLinus Torvalds return 0; 14191da177e4SLinus Torvalds } 14201da177e4SLinus Torvalds 1421bb214884SAl Viro static int lo_release(struct gendisk *disk, fmode_t mode) 14221da177e4SLinus Torvalds { 1423bb214884SAl Viro struct loop_device *lo = disk->private_data; 1424ffcd7dcaSAlexander Beregalov int err; 14251da177e4SLinus Torvalds 14266e9624b8SArnd Bergmann lock_kernel(); 1427f85221ddSIngo Molnar mutex_lock(&lo->lo_ctl_mutex); 142896c58655SDavid Woodhouse 142914f27939SMilan Broz if (--lo->lo_refcnt) 143014f27939SMilan Broz goto out; 143114f27939SMilan Broz 143214f27939SMilan Broz if (lo->lo_flags & LO_FLAGS_AUTOCLEAR) { 143314f27939SMilan Broz /* 143414f27939SMilan Broz * In autoclear mode, stop the loop thread 143514f27939SMilan Broz * and remove configuration after last close. 143614f27939SMilan Broz */ 1437ffcd7dcaSAlexander Beregalov err = loop_clr_fd(lo, NULL); 1438ffcd7dcaSAlexander Beregalov if (!err) 1439ffcd7dcaSAlexander Beregalov goto out_unlocked; 144014f27939SMilan Broz } else { 144114f27939SMilan Broz /* 144214f27939SMilan Broz * Otherwise keep thread (if running) and config, 144314f27939SMilan Broz * but flush possible ongoing bios in thread. 144414f27939SMilan Broz */ 144514f27939SMilan Broz loop_flush(lo); 144614f27939SMilan Broz } 144796c58655SDavid Woodhouse 144814f27939SMilan Broz out: 1449f85221ddSIngo Molnar mutex_unlock(&lo->lo_ctl_mutex); 1450ffcd7dcaSAlexander Beregalov out_unlocked: 14516e9624b8SArnd Bergmann lock_kernel(); 14521da177e4SLinus Torvalds return 0; 14531da177e4SLinus Torvalds } 14541da177e4SLinus Torvalds 145583d5cde4SAlexey Dobriyan static const struct block_device_operations lo_fops = { 14561da177e4SLinus Torvalds .owner = THIS_MODULE, 1457bb214884SAl Viro .open = lo_open, 1458bb214884SAl Viro .release = lo_release, 1459bb214884SAl Viro .ioctl = lo_ioctl, 1460863d5b82SDavid Howells #ifdef CONFIG_COMPAT 1461bb214884SAl Viro .compat_ioctl = lo_compat_ioctl, 1462863d5b82SDavid Howells #endif 14631da177e4SLinus Torvalds }; 14641da177e4SLinus Torvalds 14651da177e4SLinus Torvalds /* 14661da177e4SLinus Torvalds * And now the modules code and kernel interface. 14671da177e4SLinus Torvalds */ 146873285082SKen Chen static int max_loop; 14691da177e4SLinus Torvalds module_param(max_loop, int, 0); 1470a47653fcSKen Chen MODULE_PARM_DESC(max_loop, "Maximum number of loop devices"); 1471476a4813SLaurent Vivier module_param(max_part, int, 0); 1472476a4813SLaurent Vivier MODULE_PARM_DESC(max_part, "Maximum number of partitions per loop device"); 14731da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 14741da177e4SLinus Torvalds MODULE_ALIAS_BLOCKDEV_MAJOR(LOOP_MAJOR); 14751da177e4SLinus Torvalds 14761da177e4SLinus Torvalds int loop_register_transfer(struct loop_func_table *funcs) 14771da177e4SLinus Torvalds { 14781da177e4SLinus Torvalds unsigned int n = funcs->number; 14791da177e4SLinus Torvalds 14801da177e4SLinus Torvalds if (n >= MAX_LO_CRYPT || xfer_funcs[n]) 14811da177e4SLinus Torvalds return -EINVAL; 14821da177e4SLinus Torvalds xfer_funcs[n] = funcs; 14831da177e4SLinus Torvalds return 0; 14841da177e4SLinus Torvalds } 14851da177e4SLinus Torvalds 14861da177e4SLinus Torvalds int loop_unregister_transfer(int number) 14871da177e4SLinus Torvalds { 14881da177e4SLinus Torvalds unsigned int n = number; 14891da177e4SLinus Torvalds struct loop_device *lo; 14901da177e4SLinus Torvalds struct loop_func_table *xfer; 14911da177e4SLinus Torvalds 14921da177e4SLinus Torvalds if (n == 0 || n >= MAX_LO_CRYPT || (xfer = xfer_funcs[n]) == NULL) 14931da177e4SLinus Torvalds return -EINVAL; 14941da177e4SLinus Torvalds 14951da177e4SLinus Torvalds xfer_funcs[n] = NULL; 14961da177e4SLinus Torvalds 149773285082SKen Chen list_for_each_entry(lo, &loop_devices, lo_list) { 1498f85221ddSIngo Molnar mutex_lock(&lo->lo_ctl_mutex); 14991da177e4SLinus Torvalds 15001da177e4SLinus Torvalds if (lo->lo_encryption == xfer) 15011da177e4SLinus Torvalds loop_release_xfer(lo); 15021da177e4SLinus Torvalds 1503f85221ddSIngo Molnar mutex_unlock(&lo->lo_ctl_mutex); 15041da177e4SLinus Torvalds } 15051da177e4SLinus Torvalds 15061da177e4SLinus Torvalds return 0; 15071da177e4SLinus Torvalds } 15081da177e4SLinus Torvalds 15091da177e4SLinus Torvalds EXPORT_SYMBOL(loop_register_transfer); 15101da177e4SLinus Torvalds EXPORT_SYMBOL(loop_unregister_transfer); 15111da177e4SLinus Torvalds 1512a47653fcSKen Chen static struct loop_device *loop_alloc(int i) 15131da177e4SLinus Torvalds { 151473285082SKen Chen struct loop_device *lo; 151573285082SKen Chen struct gendisk *disk; 15161da177e4SLinus Torvalds 151773285082SKen Chen lo = kzalloc(sizeof(*lo), GFP_KERNEL); 151873285082SKen Chen if (!lo) 151973285082SKen Chen goto out; 15201da177e4SLinus Torvalds 15211da177e4SLinus Torvalds lo->lo_queue = blk_alloc_queue(GFP_KERNEL); 15221da177e4SLinus Torvalds if (!lo->lo_queue) 152373285082SKen Chen goto out_free_dev; 152473285082SKen Chen 1525476a4813SLaurent Vivier disk = lo->lo_disk = alloc_disk(1 << part_shift); 152673285082SKen Chen if (!disk) 152773285082SKen Chen goto out_free_queue; 152873285082SKen Chen 1529f85221ddSIngo Molnar mutex_init(&lo->lo_ctl_mutex); 15301da177e4SLinus Torvalds lo->lo_number = i; 15316c997918SSerge E. Hallyn lo->lo_thread = NULL; 15326c997918SSerge E. Hallyn init_waitqueue_head(&lo->lo_event); 15331da177e4SLinus Torvalds spin_lock_init(&lo->lo_lock); 15341da177e4SLinus Torvalds disk->major = LOOP_MAJOR; 1535476a4813SLaurent Vivier disk->first_minor = i << part_shift; 15361da177e4SLinus Torvalds disk->fops = &lo_fops; 15371da177e4SLinus Torvalds disk->private_data = lo; 15381da177e4SLinus Torvalds disk->queue = lo->lo_queue; 153973285082SKen Chen sprintf(disk->disk_name, "loop%d", i); 154073285082SKen Chen return lo; 154173285082SKen Chen 154273285082SKen Chen out_free_queue: 154373285082SKen Chen blk_cleanup_queue(lo->lo_queue); 154473285082SKen Chen out_free_dev: 154573285082SKen Chen kfree(lo); 154673285082SKen Chen out: 154707002e99SAl Viro return NULL; 15481da177e4SLinus Torvalds } 15491da177e4SLinus Torvalds 1550a47653fcSKen Chen static void loop_free(struct loop_device *lo) 155173285082SKen Chen { 155273285082SKen Chen blk_cleanup_queue(lo->lo_queue); 155373285082SKen Chen put_disk(lo->lo_disk); 155473285082SKen Chen list_del(&lo->lo_list); 155573285082SKen Chen kfree(lo); 155673285082SKen Chen } 155773285082SKen Chen 1558a47653fcSKen Chen static struct loop_device *loop_init_one(int i) 1559a47653fcSKen Chen { 1560a47653fcSKen Chen struct loop_device *lo; 1561a47653fcSKen Chen 1562a47653fcSKen Chen list_for_each_entry(lo, &loop_devices, lo_list) { 1563a47653fcSKen Chen if (lo->lo_number == i) 1564a47653fcSKen Chen return lo; 1565a47653fcSKen Chen } 1566a47653fcSKen Chen 1567a47653fcSKen Chen lo = loop_alloc(i); 1568a47653fcSKen Chen if (lo) { 1569a47653fcSKen Chen add_disk(lo->lo_disk); 1570a47653fcSKen Chen list_add_tail(&lo->lo_list, &loop_devices); 1571a47653fcSKen Chen } 1572a47653fcSKen Chen return lo; 1573a47653fcSKen Chen } 1574a47653fcSKen Chen 1575a47653fcSKen Chen static void loop_del_one(struct loop_device *lo) 1576a47653fcSKen Chen { 1577a47653fcSKen Chen del_gendisk(lo->lo_disk); 1578a47653fcSKen Chen loop_free(lo); 1579a47653fcSKen Chen } 1580a47653fcSKen Chen 158173285082SKen Chen static struct kobject *loop_probe(dev_t dev, int *part, void *data) 158273285082SKen Chen { 1583705962ccSAl Viro struct loop_device *lo; 158407002e99SAl Viro struct kobject *kobj; 158573285082SKen Chen 1586705962ccSAl Viro mutex_lock(&loop_devices_mutex); 1587705962ccSAl Viro lo = loop_init_one(dev & MINORMASK); 158807002e99SAl Viro kobj = lo ? get_disk(lo->lo_disk) : ERR_PTR(-ENOMEM); 158973285082SKen Chen mutex_unlock(&loop_devices_mutex); 159073285082SKen Chen 159173285082SKen Chen *part = 0; 159207002e99SAl Viro return kobj; 159373285082SKen Chen } 159473285082SKen Chen 159573285082SKen Chen static int __init loop_init(void) 159673285082SKen Chen { 1597a47653fcSKen Chen int i, nr; 1598a47653fcSKen Chen unsigned long range; 1599a47653fcSKen Chen struct loop_device *lo, *next; 1600a47653fcSKen Chen 1601a47653fcSKen Chen /* 1602a47653fcSKen Chen * loop module now has a feature to instantiate underlying device 1603a47653fcSKen Chen * structure on-demand, provided that there is an access dev node. 1604a47653fcSKen Chen * However, this will not work well with user space tool that doesn't 1605a47653fcSKen Chen * know about such "feature". In order to not break any existing 1606a47653fcSKen Chen * tool, we do the following: 1607a47653fcSKen Chen * 1608a47653fcSKen Chen * (1) if max_loop is specified, create that many upfront, and this 1609a47653fcSKen Chen * also becomes a hard limit. 1610a47653fcSKen Chen * (2) if max_loop is not specified, create 8 loop device on module 1611a47653fcSKen Chen * load, user can further extend loop device by create dev node 1612a47653fcSKen Chen * themselves and have kernel automatically instantiate actual 1613a47653fcSKen Chen * device on-demand. 1614a47653fcSKen Chen */ 1615476a4813SLaurent Vivier 1616476a4813SLaurent Vivier part_shift = 0; 1617476a4813SLaurent Vivier if (max_part > 0) 1618476a4813SLaurent Vivier part_shift = fls(max_part); 1619476a4813SLaurent Vivier 1620476a4813SLaurent Vivier if (max_loop > 1UL << (MINORBITS - part_shift)) 1621a47653fcSKen Chen return -EINVAL; 162273285082SKen Chen 162373285082SKen Chen if (max_loop) { 1624a47653fcSKen Chen nr = max_loop; 1625a47653fcSKen Chen range = max_loop; 1626a47653fcSKen Chen } else { 1627a47653fcSKen Chen nr = 8; 1628476a4813SLaurent Vivier range = 1UL << (MINORBITS - part_shift); 162973285082SKen Chen } 1630a47653fcSKen Chen 1631a47653fcSKen Chen if (register_blkdev(LOOP_MAJOR, "loop")) 1632a47653fcSKen Chen return -EIO; 1633a47653fcSKen Chen 1634a47653fcSKen Chen for (i = 0; i < nr; i++) { 1635a47653fcSKen Chen lo = loop_alloc(i); 1636a47653fcSKen Chen if (!lo) 1637a47653fcSKen Chen goto Enomem; 1638a47653fcSKen Chen list_add_tail(&lo->lo_list, &loop_devices); 1639a47653fcSKen Chen } 1640a47653fcSKen Chen 1641a47653fcSKen Chen /* point of no return */ 1642a47653fcSKen Chen 1643a47653fcSKen Chen list_for_each_entry(lo, &loop_devices, lo_list) 1644a47653fcSKen Chen add_disk(lo->lo_disk); 1645a47653fcSKen Chen 1646a47653fcSKen Chen blk_register_region(MKDEV(LOOP_MAJOR, 0), range, 1647a47653fcSKen Chen THIS_MODULE, loop_probe, NULL, NULL); 1648a47653fcSKen Chen 164973285082SKen Chen printk(KERN_INFO "loop: module loaded\n"); 16501da177e4SLinus Torvalds return 0; 1651a47653fcSKen Chen 1652a47653fcSKen Chen Enomem: 1653a47653fcSKen Chen printk(KERN_INFO "loop: out of memory\n"); 1654a47653fcSKen Chen 1655a47653fcSKen Chen list_for_each_entry_safe(lo, next, &loop_devices, lo_list) 1656a47653fcSKen Chen loop_free(lo); 1657a47653fcSKen Chen 1658a47653fcSKen Chen unregister_blkdev(LOOP_MAJOR, "loop"); 1659a47653fcSKen Chen return -ENOMEM; 16601da177e4SLinus Torvalds } 16611da177e4SLinus Torvalds 166273285082SKen Chen static void __exit loop_exit(void) 16631da177e4SLinus Torvalds { 1664a47653fcSKen Chen unsigned long range; 166573285082SKen Chen struct loop_device *lo, *next; 16661da177e4SLinus Torvalds 1667476a4813SLaurent Vivier range = max_loop ? max_loop : 1UL << (MINORBITS - part_shift); 1668a47653fcSKen Chen 166973285082SKen Chen list_for_each_entry_safe(lo, next, &loop_devices, lo_list) 167073285082SKen Chen loop_del_one(lo); 167173285082SKen Chen 1672a47653fcSKen Chen blk_unregister_region(MKDEV(LOOP_MAJOR, 0), range); 167300d59405SAkinobu Mita unregister_blkdev(LOOP_MAJOR, "loop"); 16741da177e4SLinus Torvalds } 16751da177e4SLinus Torvalds 16761da177e4SLinus Torvalds module_init(loop_init); 16771da177e4SLinus Torvalds module_exit(loop_exit); 16781da177e4SLinus Torvalds 16791da177e4SLinus Torvalds #ifndef MODULE 16801da177e4SLinus Torvalds static int __init max_loop_setup(char *str) 16811da177e4SLinus Torvalds { 16821da177e4SLinus Torvalds max_loop = simple_strtol(str, NULL, 0); 16831da177e4SLinus Torvalds return 1; 16841da177e4SLinus Torvalds } 16851da177e4SLinus Torvalds 16861da177e4SLinus Torvalds __setup("max_loop=", max_loop_setup); 16871da177e4SLinus Torvalds #endif 1688