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> 702a48fc0aSArnd Bergmann #include <linux/mutex.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> 77ee862730SMilan Broz #include <linux/sysfs.h> 78770fe30aSKay Sievers #include <linux/miscdevice.h> 79dfaa2ef6SLukas Czerner #include <linux/falloc.h> 801da177e4SLinus Torvalds 811da177e4SLinus Torvalds #include <asm/uaccess.h> 821da177e4SLinus Torvalds 8334dd82afSKay Sievers static DEFINE_IDR(loop_index_idr); 8434dd82afSKay Sievers static DEFINE_MUTEX(loop_index_mutex); 851da177e4SLinus Torvalds 86476a4813SLaurent Vivier static int max_part; 87476a4813SLaurent Vivier static int part_shift; 88476a4813SLaurent Vivier 891da177e4SLinus Torvalds /* 901da177e4SLinus Torvalds * Transfer functions 911da177e4SLinus Torvalds */ 921da177e4SLinus Torvalds static int transfer_none(struct loop_device *lo, int cmd, 931da177e4SLinus Torvalds struct page *raw_page, unsigned raw_off, 941da177e4SLinus Torvalds struct page *loop_page, unsigned loop_off, 951da177e4SLinus Torvalds int size, sector_t real_block) 961da177e4SLinus Torvalds { 971da177e4SLinus Torvalds char *raw_buf = kmap_atomic(raw_page, KM_USER0) + raw_off; 981da177e4SLinus Torvalds char *loop_buf = kmap_atomic(loop_page, KM_USER1) + loop_off; 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds if (cmd == READ) 1011da177e4SLinus Torvalds memcpy(loop_buf, raw_buf, size); 1021da177e4SLinus Torvalds else 1031da177e4SLinus Torvalds memcpy(raw_buf, loop_buf, size); 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds kunmap_atomic(loop_buf, KM_USER1); 10661ecdb80SPeter Zijlstra kunmap_atomic(raw_buf, KM_USER0); 1071da177e4SLinus Torvalds cond_resched(); 1081da177e4SLinus Torvalds return 0; 1091da177e4SLinus Torvalds } 1101da177e4SLinus Torvalds 1111da177e4SLinus Torvalds static int transfer_xor(struct loop_device *lo, int cmd, 1121da177e4SLinus Torvalds struct page *raw_page, unsigned raw_off, 1131da177e4SLinus Torvalds struct page *loop_page, unsigned loop_off, 1141da177e4SLinus Torvalds int size, sector_t real_block) 1151da177e4SLinus Torvalds { 1161da177e4SLinus Torvalds char *raw_buf = kmap_atomic(raw_page, KM_USER0) + raw_off; 1171da177e4SLinus Torvalds char *loop_buf = kmap_atomic(loop_page, KM_USER1) + loop_off; 1181da177e4SLinus Torvalds char *in, *out, *key; 1191da177e4SLinus Torvalds int i, keysize; 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds if (cmd == READ) { 1221da177e4SLinus Torvalds in = raw_buf; 1231da177e4SLinus Torvalds out = loop_buf; 1241da177e4SLinus Torvalds } else { 1251da177e4SLinus Torvalds in = loop_buf; 1261da177e4SLinus Torvalds out = raw_buf; 1271da177e4SLinus Torvalds } 1281da177e4SLinus Torvalds 1291da177e4SLinus Torvalds key = lo->lo_encrypt_key; 1301da177e4SLinus Torvalds keysize = lo->lo_encrypt_key_size; 1311da177e4SLinus Torvalds for (i = 0; i < size; i++) 1321da177e4SLinus Torvalds *out++ = *in++ ^ key[(i & 511) % keysize]; 1331da177e4SLinus Torvalds 1341da177e4SLinus Torvalds kunmap_atomic(loop_buf, KM_USER1); 13561ecdb80SPeter Zijlstra kunmap_atomic(raw_buf, KM_USER0); 1361da177e4SLinus Torvalds cond_resched(); 1371da177e4SLinus Torvalds return 0; 1381da177e4SLinus Torvalds } 1391da177e4SLinus Torvalds 1401da177e4SLinus Torvalds static int xor_init(struct loop_device *lo, const struct loop_info64 *info) 1411da177e4SLinus Torvalds { 1421da177e4SLinus Torvalds if (unlikely(info->lo_encrypt_key_size <= 0)) 1431da177e4SLinus Torvalds return -EINVAL; 1441da177e4SLinus Torvalds return 0; 1451da177e4SLinus Torvalds } 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds static struct loop_func_table none_funcs = { 1481da177e4SLinus Torvalds .number = LO_CRYPT_NONE, 1491da177e4SLinus Torvalds .transfer = transfer_none, 1501da177e4SLinus Torvalds }; 1511da177e4SLinus Torvalds 1521da177e4SLinus Torvalds static struct loop_func_table xor_funcs = { 1531da177e4SLinus Torvalds .number = LO_CRYPT_XOR, 1541da177e4SLinus Torvalds .transfer = transfer_xor, 1551da177e4SLinus Torvalds .init = xor_init 1561da177e4SLinus Torvalds }; 1571da177e4SLinus Torvalds 1581da177e4SLinus Torvalds /* xfer_funcs[0] is special - its release function is never called */ 1591da177e4SLinus Torvalds static struct loop_func_table *xfer_funcs[MAX_LO_CRYPT] = { 1601da177e4SLinus Torvalds &none_funcs, 1611da177e4SLinus Torvalds &xor_funcs 1621da177e4SLinus Torvalds }; 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds static loff_t get_loop_size(struct loop_device *lo, struct file *file) 1651da177e4SLinus Torvalds { 1661da177e4SLinus Torvalds loff_t size, offset, loopsize; 1671da177e4SLinus Torvalds 1681da177e4SLinus Torvalds /* Compute loopsize in bytes */ 1691da177e4SLinus Torvalds size = i_size_read(file->f_mapping->host); 1701da177e4SLinus Torvalds offset = lo->lo_offset; 1711da177e4SLinus Torvalds loopsize = size - offset; 1721da177e4SLinus Torvalds if (lo->lo_sizelimit > 0 && lo->lo_sizelimit < loopsize) 1731da177e4SLinus Torvalds loopsize = lo->lo_sizelimit; 1741da177e4SLinus Torvalds 1751da177e4SLinus Torvalds /* 1761da177e4SLinus Torvalds * Unfortunately, if we want to do I/O on the device, 1771da177e4SLinus Torvalds * the number of 512-byte sectors has to fit into a sector_t. 1781da177e4SLinus Torvalds */ 1791da177e4SLinus Torvalds return loopsize >> 9; 1801da177e4SLinus Torvalds } 1811da177e4SLinus Torvalds 1821da177e4SLinus Torvalds static int 1831da177e4SLinus Torvalds figure_loop_size(struct loop_device *lo) 1841da177e4SLinus Torvalds { 1851da177e4SLinus Torvalds loff_t size = get_loop_size(lo, lo->lo_backing_file); 1861da177e4SLinus Torvalds sector_t x = (sector_t)size; 1871da177e4SLinus Torvalds 1881da177e4SLinus Torvalds if (unlikely((loff_t)x != size)) 1891da177e4SLinus Torvalds return -EFBIG; 1901da177e4SLinus Torvalds 19173285082SKen Chen set_capacity(lo->lo_disk, x); 1921da177e4SLinus Torvalds return 0; 1931da177e4SLinus Torvalds } 1941da177e4SLinus Torvalds 1951da177e4SLinus Torvalds static inline int 1961da177e4SLinus Torvalds lo_do_transfer(struct loop_device *lo, int cmd, 1971da177e4SLinus Torvalds struct page *rpage, unsigned roffs, 1981da177e4SLinus Torvalds struct page *lpage, unsigned loffs, 1991da177e4SLinus Torvalds int size, sector_t rblock) 2001da177e4SLinus Torvalds { 2011da177e4SLinus Torvalds if (unlikely(!lo->transfer)) 2021da177e4SLinus Torvalds return 0; 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds return lo->transfer(lo, cmd, rpage, roffs, lpage, loffs, size, rblock); 2051da177e4SLinus Torvalds } 2061da177e4SLinus Torvalds 2071da177e4SLinus Torvalds /** 2081da177e4SLinus Torvalds * __do_lo_send_write - helper for writing data to a loop device 2091da177e4SLinus Torvalds * 2101da177e4SLinus Torvalds * This helper just factors out common code between do_lo_send_direct_write() 2111da177e4SLinus Torvalds * and do_lo_send_write(). 2121da177e4SLinus Torvalds */ 213858119e1SArjan van de Ven static int __do_lo_send_write(struct file *file, 21498ae6ccdSAl Viro u8 *buf, const int len, loff_t pos) 2151da177e4SLinus Torvalds { 2161da177e4SLinus Torvalds ssize_t bw; 2171da177e4SLinus Torvalds mm_segment_t old_fs = get_fs(); 2181da177e4SLinus Torvalds 2191da177e4SLinus Torvalds set_fs(get_ds()); 2201da177e4SLinus Torvalds bw = file->f_op->write(file, buf, len, &pos); 2211da177e4SLinus Torvalds set_fs(old_fs); 2221da177e4SLinus Torvalds if (likely(bw == len)) 2231da177e4SLinus Torvalds return 0; 2241da177e4SLinus Torvalds printk(KERN_ERR "loop: Write error at byte offset %llu, length %i.\n", 2251da177e4SLinus Torvalds (unsigned long long)pos, len); 2261da177e4SLinus Torvalds if (bw >= 0) 2271da177e4SLinus Torvalds bw = -EIO; 2281da177e4SLinus Torvalds return bw; 2291da177e4SLinus Torvalds } 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds /** 2321da177e4SLinus Torvalds * do_lo_send_direct_write - helper for writing data to a loop device 2331da177e4SLinus Torvalds * 234456be148SChristoph Hellwig * This is the fast, non-transforming version that does not need double 235456be148SChristoph Hellwig * buffering. 2361da177e4SLinus Torvalds */ 2371da177e4SLinus Torvalds static int do_lo_send_direct_write(struct loop_device *lo, 238511de73fSAl Viro struct bio_vec *bvec, loff_t pos, struct page *page) 2391da177e4SLinus Torvalds { 2401da177e4SLinus Torvalds ssize_t bw = __do_lo_send_write(lo->lo_backing_file, 24198ae6ccdSAl Viro kmap(bvec->bv_page) + bvec->bv_offset, 2421da177e4SLinus Torvalds bvec->bv_len, pos); 2431da177e4SLinus Torvalds kunmap(bvec->bv_page); 2441da177e4SLinus Torvalds cond_resched(); 2451da177e4SLinus Torvalds return bw; 2461da177e4SLinus Torvalds } 2471da177e4SLinus Torvalds 2481da177e4SLinus Torvalds /** 2491da177e4SLinus Torvalds * do_lo_send_write - helper for writing data to a loop device 2501da177e4SLinus Torvalds * 251456be148SChristoph Hellwig * This is the slow, transforming version that needs to double buffer the 252456be148SChristoph Hellwig * data as it cannot do the transformations in place without having direct 253456be148SChristoph Hellwig * access to the destination pages of the backing file. 2541da177e4SLinus Torvalds */ 2551da177e4SLinus Torvalds static int do_lo_send_write(struct loop_device *lo, struct bio_vec *bvec, 256511de73fSAl Viro loff_t pos, struct page *page) 2571da177e4SLinus Torvalds { 2581da177e4SLinus Torvalds int ret = lo_do_transfer(lo, WRITE, page, 0, bvec->bv_page, 2591da177e4SLinus Torvalds bvec->bv_offset, bvec->bv_len, pos >> 9); 2601da177e4SLinus Torvalds if (likely(!ret)) 2611da177e4SLinus Torvalds return __do_lo_send_write(lo->lo_backing_file, 26298ae6ccdSAl Viro page_address(page), bvec->bv_len, 2631da177e4SLinus Torvalds pos); 2641da177e4SLinus Torvalds printk(KERN_ERR "loop: Transfer error at byte offset %llu, " 2651da177e4SLinus Torvalds "length %i.\n", (unsigned long long)pos, bvec->bv_len); 2661da177e4SLinus Torvalds if (ret > 0) 2671da177e4SLinus Torvalds ret = -EIO; 2681da177e4SLinus Torvalds return ret; 2691da177e4SLinus Torvalds } 2701da177e4SLinus Torvalds 271511de73fSAl Viro static int lo_send(struct loop_device *lo, struct bio *bio, loff_t pos) 2721da177e4SLinus Torvalds { 273511de73fSAl Viro int (*do_lo_send)(struct loop_device *, struct bio_vec *, loff_t, 2741da177e4SLinus Torvalds struct page *page); 2751da177e4SLinus Torvalds struct bio_vec *bvec; 2761da177e4SLinus Torvalds struct page *page = NULL; 2771da177e4SLinus Torvalds int i, ret = 0; 2781da177e4SLinus Torvalds 2791da177e4SLinus Torvalds if (lo->transfer != transfer_none) { 2801da177e4SLinus Torvalds page = alloc_page(GFP_NOIO | __GFP_HIGHMEM); 2811da177e4SLinus Torvalds if (unlikely(!page)) 2821da177e4SLinus Torvalds goto fail; 2831da177e4SLinus Torvalds kmap(page); 2841da177e4SLinus Torvalds do_lo_send = do_lo_send_write; 285456be148SChristoph Hellwig } else { 286456be148SChristoph Hellwig do_lo_send = do_lo_send_direct_write; 2871da177e4SLinus Torvalds } 288456be148SChristoph Hellwig 2891da177e4SLinus Torvalds bio_for_each_segment(bvec, bio, i) { 290511de73fSAl Viro ret = do_lo_send(lo, bvec, pos, page); 2911da177e4SLinus Torvalds if (ret < 0) 2921da177e4SLinus Torvalds break; 2931da177e4SLinus Torvalds pos += bvec->bv_len; 2941da177e4SLinus Torvalds } 2951da177e4SLinus Torvalds if (page) { 2961da177e4SLinus Torvalds kunmap(page); 2971da177e4SLinus Torvalds __free_page(page); 2981da177e4SLinus Torvalds } 2991da177e4SLinus Torvalds out: 3001da177e4SLinus Torvalds return ret; 3011da177e4SLinus Torvalds fail: 3021da177e4SLinus Torvalds printk(KERN_ERR "loop: Failed to allocate temporary page for write.\n"); 3031da177e4SLinus Torvalds ret = -ENOMEM; 3041da177e4SLinus Torvalds goto out; 3051da177e4SLinus Torvalds } 3061da177e4SLinus Torvalds 3071da177e4SLinus Torvalds struct lo_read_data { 3081da177e4SLinus Torvalds struct loop_device *lo; 3091da177e4SLinus Torvalds struct page *page; 3101da177e4SLinus Torvalds unsigned offset; 3111da177e4SLinus Torvalds int bsize; 3121da177e4SLinus Torvalds }; 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds static int 315fd582140SJens Axboe lo_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf, 316fd582140SJens Axboe struct splice_desc *sd) 3171da177e4SLinus Torvalds { 318fd582140SJens Axboe struct lo_read_data *p = sd->u.data; 3191da177e4SLinus Torvalds struct loop_device *lo = p->lo; 320fd582140SJens Axboe struct page *page = buf->page; 3211da177e4SLinus Torvalds sector_t IV; 3223603b8eaSJens Axboe int size; 3231da177e4SLinus Torvalds 324fd582140SJens Axboe IV = ((sector_t) page->index << (PAGE_CACHE_SHIFT - 9)) + 325fd582140SJens Axboe (buf->offset >> 9); 326fd582140SJens Axboe size = sd->len; 327fd582140SJens Axboe if (size > p->bsize) 328fd582140SJens Axboe size = p->bsize; 3291da177e4SLinus Torvalds 330fd582140SJens Axboe if (lo_do_transfer(lo, READ, page, buf->offset, p->page, p->offset, size, IV)) { 3311da177e4SLinus Torvalds printk(KERN_ERR "loop: transfer error block %ld\n", 3321da177e4SLinus Torvalds page->index); 333fd582140SJens Axboe size = -EINVAL; 3341da177e4SLinus Torvalds } 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds flush_dcache_page(p->page); 3371da177e4SLinus Torvalds 338fd582140SJens Axboe if (size > 0) 3391da177e4SLinus Torvalds p->offset += size; 340fd582140SJens Axboe 3411da177e4SLinus Torvalds return size; 3421da177e4SLinus Torvalds } 3431da177e4SLinus Torvalds 3441da177e4SLinus Torvalds static int 345fd582140SJens Axboe lo_direct_splice_actor(struct pipe_inode_info *pipe, struct splice_desc *sd) 346fd582140SJens Axboe { 347fd582140SJens Axboe return __splice_from_pipe(pipe, sd, lo_splice_actor); 348fd582140SJens Axboe } 349fd582140SJens Axboe 350fd582140SJens Axboe static int 3511da177e4SLinus Torvalds do_lo_receive(struct loop_device *lo, 3521da177e4SLinus Torvalds struct bio_vec *bvec, int bsize, loff_t pos) 3531da177e4SLinus Torvalds { 3541da177e4SLinus Torvalds struct lo_read_data cookie; 355fd582140SJens Axboe struct splice_desc sd; 3561da177e4SLinus Torvalds struct file *file; 357fd582140SJens Axboe long retval; 3581da177e4SLinus Torvalds 3591da177e4SLinus Torvalds cookie.lo = lo; 3601da177e4SLinus Torvalds cookie.page = bvec->bv_page; 3611da177e4SLinus Torvalds cookie.offset = bvec->bv_offset; 3621da177e4SLinus Torvalds cookie.bsize = bsize; 363fd582140SJens Axboe 364fd582140SJens Axboe sd.len = 0; 365fd582140SJens Axboe sd.total_len = bvec->bv_len; 366fd582140SJens Axboe sd.flags = 0; 367fd582140SJens Axboe sd.pos = pos; 368fd582140SJens Axboe sd.u.data = &cookie; 369fd582140SJens Axboe 3701da177e4SLinus Torvalds file = lo->lo_backing_file; 371fd582140SJens Axboe retval = splice_direct_to_actor(file, &sd, lo_direct_splice_actor); 372fd582140SJens Axboe 373fd582140SJens Axboe if (retval < 0) 374fd582140SJens Axboe return retval; 3753bb90682SDmitry Monakhov if (retval != bvec->bv_len) 3763bb90682SDmitry Monakhov return -EIO; 377fd582140SJens Axboe return 0; 3781da177e4SLinus Torvalds } 3791da177e4SLinus Torvalds 3801da177e4SLinus Torvalds static int 3811da177e4SLinus Torvalds lo_receive(struct loop_device *lo, struct bio *bio, int bsize, loff_t pos) 3821da177e4SLinus Torvalds { 3831da177e4SLinus Torvalds struct bio_vec *bvec; 3841da177e4SLinus Torvalds int i, ret = 0; 3851da177e4SLinus Torvalds 3861da177e4SLinus Torvalds bio_for_each_segment(bvec, bio, i) { 3871da177e4SLinus Torvalds ret = do_lo_receive(lo, bvec, bsize, pos); 3881da177e4SLinus Torvalds if (ret < 0) 3891da177e4SLinus Torvalds break; 3901da177e4SLinus Torvalds pos += bvec->bv_len; 3911da177e4SLinus Torvalds } 3921da177e4SLinus Torvalds return ret; 3931da177e4SLinus Torvalds } 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds static int do_bio_filebacked(struct loop_device *lo, struct bio *bio) 3961da177e4SLinus Torvalds { 3971da177e4SLinus Torvalds loff_t pos; 3981da177e4SLinus Torvalds int ret; 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds pos = ((loff_t) bio->bi_sector << 9) + lo->lo_offset; 40168db1961SNikanth Karthikesan 40268db1961SNikanth Karthikesan if (bio_rw(bio) == WRITE) { 40368db1961SNikanth Karthikesan struct file *file = lo->lo_backing_file; 40468db1961SNikanth Karthikesan 4056259f284STejun Heo if (bio->bi_rw & REQ_FLUSH) { 4068018ab05SChristoph Hellwig ret = vfs_fsync(file, 0); 4076259f284STejun Heo if (unlikely(ret && ret != -EINVAL)) { 40868db1961SNikanth Karthikesan ret = -EIO; 40968db1961SNikanth Karthikesan goto out; 41068db1961SNikanth Karthikesan } 41168db1961SNikanth Karthikesan } 41268db1961SNikanth Karthikesan 413dfaa2ef6SLukas Czerner /* 414dfaa2ef6SLukas Czerner * We use punch hole to reclaim the free space used by the 415dfaa2ef6SLukas Czerner * image a.k.a. discard. However we do support discard if 416dfaa2ef6SLukas Czerner * encryption is enabled, because it may give an attacker 417dfaa2ef6SLukas Czerner * useful information. 418dfaa2ef6SLukas Czerner */ 419dfaa2ef6SLukas Czerner if (bio->bi_rw & REQ_DISCARD) { 420dfaa2ef6SLukas Czerner struct file *file = lo->lo_backing_file; 421dfaa2ef6SLukas Czerner int mode = FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE; 422dfaa2ef6SLukas Czerner 423dfaa2ef6SLukas Czerner if ((!file->f_op->fallocate) || 424dfaa2ef6SLukas Czerner lo->lo_encrypt_key_size) { 425dfaa2ef6SLukas Czerner ret = -EOPNOTSUPP; 426dfaa2ef6SLukas Czerner goto out; 427dfaa2ef6SLukas Czerner } 428dfaa2ef6SLukas Czerner ret = file->f_op->fallocate(file, mode, pos, 429dfaa2ef6SLukas Czerner bio->bi_size); 430dfaa2ef6SLukas Czerner if (unlikely(ret && ret != -EINVAL && 431dfaa2ef6SLukas Czerner ret != -EOPNOTSUPP)) 432dfaa2ef6SLukas Czerner ret = -EIO; 433dfaa2ef6SLukas Czerner goto out; 434dfaa2ef6SLukas Czerner } 435dfaa2ef6SLukas Czerner 436511de73fSAl Viro ret = lo_send(lo, bio, pos); 43768db1961SNikanth Karthikesan 4386259f284STejun Heo if ((bio->bi_rw & REQ_FUA) && !ret) { 4398018ab05SChristoph Hellwig ret = vfs_fsync(file, 0); 4406259f284STejun Heo if (unlikely(ret && ret != -EINVAL)) 44168db1961SNikanth Karthikesan ret = -EIO; 44268db1961SNikanth Karthikesan } 44368db1961SNikanth Karthikesan } else 4441da177e4SLinus Torvalds ret = lo_receive(lo, bio, lo->lo_blocksize, pos); 44568db1961SNikanth Karthikesan 44668db1961SNikanth Karthikesan out: 4471da177e4SLinus Torvalds return ret; 4481da177e4SLinus Torvalds } 4491da177e4SLinus Torvalds 4501da177e4SLinus Torvalds /* 4511da177e4SLinus Torvalds * Add bio to back of pending list 4521da177e4SLinus Torvalds */ 4531da177e4SLinus Torvalds static void loop_add_bio(struct loop_device *lo, struct bio *bio) 4541da177e4SLinus Torvalds { 455e686307fSAkinobu Mita bio_list_add(&lo->lo_bio_list, bio); 4561da177e4SLinus Torvalds } 4571da177e4SLinus Torvalds 4581da177e4SLinus Torvalds /* 4591da177e4SLinus Torvalds * Grab first pending buffer 4601da177e4SLinus Torvalds */ 4611da177e4SLinus Torvalds static struct bio *loop_get_bio(struct loop_device *lo) 4621da177e4SLinus Torvalds { 463e686307fSAkinobu Mita return bio_list_pop(&lo->lo_bio_list); 4641da177e4SLinus Torvalds } 4651da177e4SLinus Torvalds 4665a7bbad2SChristoph Hellwig static void loop_make_request(struct request_queue *q, struct bio *old_bio) 4671da177e4SLinus Torvalds { 4681da177e4SLinus Torvalds struct loop_device *lo = q->queuedata; 4691da177e4SLinus Torvalds int rw = bio_rw(old_bio); 4701da177e4SLinus Torvalds 47135a82d1aSNick Piggin if (rw == READA) 47235a82d1aSNick Piggin rw = READ; 47335a82d1aSNick Piggin 47435a82d1aSNick Piggin BUG_ON(!lo || (rw != READ && rw != WRITE)); 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds spin_lock_irq(&lo->lo_lock); 4771da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 47835a82d1aSNick Piggin goto out; 47935a82d1aSNick Piggin if (unlikely(rw == WRITE && (lo->lo_flags & LO_FLAGS_READ_ONLY))) 48035a82d1aSNick Piggin goto out; 4811da177e4SLinus Torvalds loop_add_bio(lo, old_bio); 4826c997918SSerge E. Hallyn wake_up(&lo->lo_event); 48335a82d1aSNick Piggin spin_unlock_irq(&lo->lo_lock); 4845a7bbad2SChristoph Hellwig return; 48535a82d1aSNick Piggin 4861da177e4SLinus Torvalds out: 48735a82d1aSNick Piggin spin_unlock_irq(&lo->lo_lock); 4886712ecf8SNeilBrown bio_io_error(old_bio); 4891da177e4SLinus Torvalds } 4901da177e4SLinus Torvalds 4911da177e4SLinus Torvalds struct switch_request { 4921da177e4SLinus Torvalds struct file *file; 4931da177e4SLinus Torvalds struct completion wait; 4941da177e4SLinus Torvalds }; 4951da177e4SLinus Torvalds 4961da177e4SLinus Torvalds static void do_loop_switch(struct loop_device *, struct switch_request *); 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds static inline void loop_handle_bio(struct loop_device *lo, struct bio *bio) 4991da177e4SLinus Torvalds { 5001da177e4SLinus Torvalds if (unlikely(!bio->bi_bdev)) { 5011da177e4SLinus Torvalds do_loop_switch(lo, bio->bi_private); 5021da177e4SLinus Torvalds bio_put(bio); 5031da177e4SLinus Torvalds } else { 50435a82d1aSNick Piggin int ret = do_bio_filebacked(lo, bio); 5056712ecf8SNeilBrown bio_endio(bio, ret); 5061da177e4SLinus Torvalds } 5071da177e4SLinus Torvalds } 5081da177e4SLinus Torvalds 5091da177e4SLinus Torvalds /* 5101da177e4SLinus Torvalds * worker thread that handles reads/writes to file backed loop devices, 5111da177e4SLinus Torvalds * to avoid blocking in our make_request_fn. it also does loop decrypting 5121da177e4SLinus Torvalds * on reads for block backed loop, as that is too heavy to do from 5131da177e4SLinus Torvalds * b_end_io context where irqs may be disabled. 5146c997918SSerge E. Hallyn * 5156c997918SSerge E. Hallyn * Loop explanation: loop_clr_fd() sets lo_state to Lo_rundown before 5166c997918SSerge E. Hallyn * calling kthread_stop(). Therefore once kthread_should_stop() is 5176c997918SSerge E. Hallyn * true, make_request will not place any more requests. Therefore 5186c997918SSerge E. Hallyn * once kthread_should_stop() is true and lo_bio is NULL, we are 5196c997918SSerge E. Hallyn * done with the loop. 5201da177e4SLinus Torvalds */ 5211da177e4SLinus Torvalds static int loop_thread(void *data) 5221da177e4SLinus Torvalds { 5231da177e4SLinus Torvalds struct loop_device *lo = data; 5241da177e4SLinus Torvalds struct bio *bio; 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds set_user_nice(current, -20); 5271da177e4SLinus Torvalds 528e686307fSAkinobu Mita while (!kthread_should_stop() || !bio_list_empty(&lo->lo_bio_list)) { 5291da177e4SLinus Torvalds 5306c997918SSerge E. Hallyn wait_event_interruptible(lo->lo_event, 531e686307fSAkinobu Mita !bio_list_empty(&lo->lo_bio_list) || 532e686307fSAkinobu Mita kthread_should_stop()); 53309c0dc68SLinus Torvalds 534e686307fSAkinobu Mita if (bio_list_empty(&lo->lo_bio_list)) 53535a82d1aSNick Piggin continue; 53635a82d1aSNick Piggin spin_lock_irq(&lo->lo_lock); 5371da177e4SLinus Torvalds bio = loop_get_bio(lo); 53835a82d1aSNick Piggin spin_unlock_irq(&lo->lo_lock); 53935a82d1aSNick Piggin 54035a82d1aSNick Piggin BUG_ON(!bio); 5411da177e4SLinus Torvalds loop_handle_bio(lo, bio); 5421da177e4SLinus Torvalds } 5431da177e4SLinus Torvalds 5441da177e4SLinus Torvalds return 0; 5451da177e4SLinus Torvalds } 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds /* 5481da177e4SLinus Torvalds * loop_switch performs the hard work of switching a backing store. 5491da177e4SLinus Torvalds * First it needs to flush existing IO, it does this by sending a magic 5501da177e4SLinus Torvalds * BIO down the pipe. The completion of this BIO does the actual switch. 5511da177e4SLinus Torvalds */ 5521da177e4SLinus Torvalds static int loop_switch(struct loop_device *lo, struct file *file) 5531da177e4SLinus Torvalds { 5541da177e4SLinus Torvalds struct switch_request w; 555a24eab1eSJens Axboe struct bio *bio = bio_alloc(GFP_KERNEL, 0); 5561da177e4SLinus Torvalds if (!bio) 5571da177e4SLinus Torvalds return -ENOMEM; 5581da177e4SLinus Torvalds init_completion(&w.wait); 5591da177e4SLinus Torvalds w.file = file; 5601da177e4SLinus Torvalds bio->bi_private = &w; 5611da177e4SLinus Torvalds bio->bi_bdev = NULL; 5621da177e4SLinus Torvalds loop_make_request(lo->lo_queue, bio); 5631da177e4SLinus Torvalds wait_for_completion(&w.wait); 5641da177e4SLinus Torvalds return 0; 5651da177e4SLinus Torvalds } 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds /* 56814f27939SMilan Broz * Helper to flush the IOs in loop, but keeping loop thread running 56914f27939SMilan Broz */ 57014f27939SMilan Broz static int loop_flush(struct loop_device *lo) 57114f27939SMilan Broz { 57214f27939SMilan Broz /* loop not yet configured, no running thread, nothing to flush */ 57314f27939SMilan Broz if (!lo->lo_thread) 57414f27939SMilan Broz return 0; 57514f27939SMilan Broz 57614f27939SMilan Broz return loop_switch(lo, NULL); 57714f27939SMilan Broz } 57814f27939SMilan Broz 57914f27939SMilan Broz /* 5801da177e4SLinus Torvalds * Do the actual switch; called from the BIO completion routine 5811da177e4SLinus Torvalds */ 5821da177e4SLinus Torvalds static void do_loop_switch(struct loop_device *lo, struct switch_request *p) 5831da177e4SLinus Torvalds { 5841da177e4SLinus Torvalds struct file *file = p->file; 5851da177e4SLinus Torvalds struct file *old_file = lo->lo_backing_file; 58614f27939SMilan Broz struct address_space *mapping; 5871da177e4SLinus Torvalds 58814f27939SMilan Broz /* if no new file, only flush of queued bios requested */ 58914f27939SMilan Broz if (!file) 59014f27939SMilan Broz goto out; 59114f27939SMilan Broz 59214f27939SMilan Broz mapping = file->f_mapping; 5931da177e4SLinus Torvalds mapping_set_gfp_mask(old_file->f_mapping, lo->old_gfp_mask); 5941da177e4SLinus Torvalds lo->lo_backing_file = file; 595ba52de12STheodore Ts'o lo->lo_blocksize = S_ISBLK(mapping->host->i_mode) ? 596ba52de12STheodore Ts'o mapping->host->i_bdev->bd_block_size : PAGE_SIZE; 5971da177e4SLinus Torvalds lo->old_gfp_mask = mapping_gfp_mask(mapping); 5981da177e4SLinus Torvalds mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS)); 59914f27939SMilan Broz out: 6001da177e4SLinus Torvalds complete(&p->wait); 6011da177e4SLinus Torvalds } 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds /* 6051da177e4SLinus Torvalds * loop_change_fd switched the backing store of a loopback device to 6061da177e4SLinus Torvalds * a new file. This is useful for operating system installers to free up 6071da177e4SLinus Torvalds * the original file and in High Availability environments to switch to 6081da177e4SLinus Torvalds * an alternative location for the content in case of server meltdown. 6091da177e4SLinus Torvalds * This can only work if the loop device is used read-only, and if the 6101da177e4SLinus Torvalds * new backing store is the same size and type as the old backing store. 6111da177e4SLinus Torvalds */ 612bb214884SAl Viro static int loop_change_fd(struct loop_device *lo, struct block_device *bdev, 613bb214884SAl Viro unsigned int arg) 6141da177e4SLinus Torvalds { 6151da177e4SLinus Torvalds struct file *file, *old_file; 6161da177e4SLinus Torvalds struct inode *inode; 6171da177e4SLinus Torvalds int error; 6181da177e4SLinus Torvalds 6191da177e4SLinus Torvalds error = -ENXIO; 6201da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 6211da177e4SLinus Torvalds goto out; 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds /* the loop device has to be read-only */ 6241da177e4SLinus Torvalds error = -EINVAL; 6251da177e4SLinus Torvalds if (!(lo->lo_flags & LO_FLAGS_READ_ONLY)) 6261da177e4SLinus Torvalds goto out; 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds error = -EBADF; 6291da177e4SLinus Torvalds file = fget(arg); 6301da177e4SLinus Torvalds if (!file) 6311da177e4SLinus Torvalds goto out; 6321da177e4SLinus Torvalds 6331da177e4SLinus Torvalds inode = file->f_mapping->host; 6341da177e4SLinus Torvalds old_file = lo->lo_backing_file; 6351da177e4SLinus Torvalds 6361da177e4SLinus Torvalds error = -EINVAL; 6371da177e4SLinus Torvalds 6381da177e4SLinus Torvalds if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode)) 6391da177e4SLinus Torvalds goto out_putf; 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds /* size of the new backing store needs to be the same */ 6421da177e4SLinus Torvalds if (get_loop_size(lo, file) != get_loop_size(lo, old_file)) 6431da177e4SLinus Torvalds goto out_putf; 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds /* and ... switch */ 6461da177e4SLinus Torvalds error = loop_switch(lo, file); 6471da177e4SLinus Torvalds if (error) 6481da177e4SLinus Torvalds goto out_putf; 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds fput(old_file); 651e03c8dd1SKay Sievers if (lo->lo_flags & LO_FLAGS_PARTSCAN) 652476a4813SLaurent Vivier ioctl_by_bdev(bdev, BLKRRPART, 0); 6531da177e4SLinus Torvalds return 0; 6541da177e4SLinus Torvalds 6551da177e4SLinus Torvalds out_putf: 6561da177e4SLinus Torvalds fput(file); 6571da177e4SLinus Torvalds out: 6581da177e4SLinus Torvalds return error; 6591da177e4SLinus Torvalds } 6601da177e4SLinus Torvalds 6611da177e4SLinus Torvalds static inline int is_loop_device(struct file *file) 6621da177e4SLinus Torvalds { 6631da177e4SLinus Torvalds struct inode *i = file->f_mapping->host; 6641da177e4SLinus Torvalds 6651da177e4SLinus Torvalds return i && S_ISBLK(i->i_mode) && MAJOR(i->i_rdev) == LOOP_MAJOR; 6661da177e4SLinus Torvalds } 6671da177e4SLinus Torvalds 668ee862730SMilan Broz /* loop sysfs attributes */ 669ee862730SMilan Broz 670ee862730SMilan Broz static ssize_t loop_attr_show(struct device *dev, char *page, 671ee862730SMilan Broz ssize_t (*callback)(struct loop_device *, char *)) 672ee862730SMilan Broz { 67334dd82afSKay Sievers struct gendisk *disk = dev_to_disk(dev); 67434dd82afSKay Sievers struct loop_device *lo = disk->private_data; 675ee862730SMilan Broz 67634dd82afSKay Sievers return callback(lo, page); 677ee862730SMilan Broz } 678ee862730SMilan Broz 679ee862730SMilan Broz #define LOOP_ATTR_RO(_name) \ 680ee862730SMilan Broz static ssize_t loop_attr_##_name##_show(struct loop_device *, char *); \ 681ee862730SMilan Broz static ssize_t loop_attr_do_show_##_name(struct device *d, \ 682ee862730SMilan Broz struct device_attribute *attr, char *b) \ 683ee862730SMilan Broz { \ 684ee862730SMilan Broz return loop_attr_show(d, b, loop_attr_##_name##_show); \ 685ee862730SMilan Broz } \ 686ee862730SMilan Broz static struct device_attribute loop_attr_##_name = \ 687ee862730SMilan Broz __ATTR(_name, S_IRUGO, loop_attr_do_show_##_name, NULL); 688ee862730SMilan Broz 689ee862730SMilan Broz static ssize_t loop_attr_backing_file_show(struct loop_device *lo, char *buf) 690ee862730SMilan Broz { 691ee862730SMilan Broz ssize_t ret; 692ee862730SMilan Broz char *p = NULL; 693ee862730SMilan Broz 69405eb0f25SKay Sievers spin_lock_irq(&lo->lo_lock); 695ee862730SMilan Broz if (lo->lo_backing_file) 696ee862730SMilan Broz p = d_path(&lo->lo_backing_file->f_path, buf, PAGE_SIZE - 1); 69705eb0f25SKay Sievers spin_unlock_irq(&lo->lo_lock); 698ee862730SMilan Broz 699ee862730SMilan Broz if (IS_ERR_OR_NULL(p)) 700ee862730SMilan Broz ret = PTR_ERR(p); 701ee862730SMilan Broz else { 702ee862730SMilan Broz ret = strlen(p); 703ee862730SMilan Broz memmove(buf, p, ret); 704ee862730SMilan Broz buf[ret++] = '\n'; 705ee862730SMilan Broz buf[ret] = 0; 706ee862730SMilan Broz } 707ee862730SMilan Broz 708ee862730SMilan Broz return ret; 709ee862730SMilan Broz } 710ee862730SMilan Broz 711ee862730SMilan Broz static ssize_t loop_attr_offset_show(struct loop_device *lo, char *buf) 712ee862730SMilan Broz { 713ee862730SMilan Broz return sprintf(buf, "%llu\n", (unsigned long long)lo->lo_offset); 714ee862730SMilan Broz } 715ee862730SMilan Broz 716ee862730SMilan Broz static ssize_t loop_attr_sizelimit_show(struct loop_device *lo, char *buf) 717ee862730SMilan Broz { 718ee862730SMilan Broz return sprintf(buf, "%llu\n", (unsigned long long)lo->lo_sizelimit); 719ee862730SMilan Broz } 720ee862730SMilan Broz 721ee862730SMilan Broz static ssize_t loop_attr_autoclear_show(struct loop_device *lo, char *buf) 722ee862730SMilan Broz { 723ee862730SMilan Broz int autoclear = (lo->lo_flags & LO_FLAGS_AUTOCLEAR); 724ee862730SMilan Broz 725ee862730SMilan Broz return sprintf(buf, "%s\n", autoclear ? "1" : "0"); 726ee862730SMilan Broz } 727ee862730SMilan Broz 728e03c8dd1SKay Sievers static ssize_t loop_attr_partscan_show(struct loop_device *lo, char *buf) 729e03c8dd1SKay Sievers { 730e03c8dd1SKay Sievers int partscan = (lo->lo_flags & LO_FLAGS_PARTSCAN); 731e03c8dd1SKay Sievers 732e03c8dd1SKay Sievers return sprintf(buf, "%s\n", partscan ? "1" : "0"); 733e03c8dd1SKay Sievers } 734e03c8dd1SKay Sievers 735ee862730SMilan Broz LOOP_ATTR_RO(backing_file); 736ee862730SMilan Broz LOOP_ATTR_RO(offset); 737ee862730SMilan Broz LOOP_ATTR_RO(sizelimit); 738ee862730SMilan Broz LOOP_ATTR_RO(autoclear); 739e03c8dd1SKay Sievers LOOP_ATTR_RO(partscan); 740ee862730SMilan Broz 741ee862730SMilan Broz static struct attribute *loop_attrs[] = { 742ee862730SMilan Broz &loop_attr_backing_file.attr, 743ee862730SMilan Broz &loop_attr_offset.attr, 744ee862730SMilan Broz &loop_attr_sizelimit.attr, 745ee862730SMilan Broz &loop_attr_autoclear.attr, 746e03c8dd1SKay Sievers &loop_attr_partscan.attr, 747ee862730SMilan Broz NULL, 748ee862730SMilan Broz }; 749ee862730SMilan Broz 750ee862730SMilan Broz static struct attribute_group loop_attribute_group = { 751ee862730SMilan Broz .name = "loop", 752ee862730SMilan Broz .attrs= loop_attrs, 753ee862730SMilan Broz }; 754ee862730SMilan Broz 755ee862730SMilan Broz static int loop_sysfs_init(struct loop_device *lo) 756ee862730SMilan Broz { 757ee862730SMilan Broz return sysfs_create_group(&disk_to_dev(lo->lo_disk)->kobj, 758ee862730SMilan Broz &loop_attribute_group); 759ee862730SMilan Broz } 760ee862730SMilan Broz 761ee862730SMilan Broz static void loop_sysfs_exit(struct loop_device *lo) 762ee862730SMilan Broz { 763ee862730SMilan Broz sysfs_remove_group(&disk_to_dev(lo->lo_disk)->kobj, 764ee862730SMilan Broz &loop_attribute_group); 765ee862730SMilan Broz } 766ee862730SMilan Broz 767dfaa2ef6SLukas Czerner static void loop_config_discard(struct loop_device *lo) 768dfaa2ef6SLukas Czerner { 769dfaa2ef6SLukas Czerner struct file *file = lo->lo_backing_file; 770dfaa2ef6SLukas Czerner struct inode *inode = file->f_mapping->host; 771dfaa2ef6SLukas Czerner struct request_queue *q = lo->lo_queue; 772dfaa2ef6SLukas Czerner 773dfaa2ef6SLukas Czerner /* 774dfaa2ef6SLukas Czerner * We use punch hole to reclaim the free space used by the 775dfaa2ef6SLukas Czerner * image a.k.a. discard. However we do support discard if 776dfaa2ef6SLukas Czerner * encryption is enabled, because it may give an attacker 777dfaa2ef6SLukas Czerner * useful information. 778dfaa2ef6SLukas Czerner */ 779dfaa2ef6SLukas Czerner if ((!file->f_op->fallocate) || 780dfaa2ef6SLukas Czerner lo->lo_encrypt_key_size) { 781dfaa2ef6SLukas Czerner q->limits.discard_granularity = 0; 782dfaa2ef6SLukas Czerner q->limits.discard_alignment = 0; 783dfaa2ef6SLukas Czerner q->limits.max_discard_sectors = 0; 784dfaa2ef6SLukas Czerner q->limits.discard_zeroes_data = 0; 785dfaa2ef6SLukas Czerner queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, q); 786dfaa2ef6SLukas Czerner return; 787dfaa2ef6SLukas Czerner } 788dfaa2ef6SLukas Czerner 789dfaa2ef6SLukas Czerner q->limits.discard_granularity = inode->i_sb->s_blocksize; 790dfaa2ef6SLukas Czerner q->limits.discard_alignment = inode->i_sb->s_blocksize; 791dfaa2ef6SLukas Czerner q->limits.max_discard_sectors = UINT_MAX >> 9; 792dfaa2ef6SLukas Czerner q->limits.discard_zeroes_data = 1; 793dfaa2ef6SLukas Czerner queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q); 794dfaa2ef6SLukas Czerner } 795dfaa2ef6SLukas Czerner 796bb214884SAl Viro static int loop_set_fd(struct loop_device *lo, fmode_t mode, 7971da177e4SLinus Torvalds struct block_device *bdev, unsigned int arg) 7981da177e4SLinus Torvalds { 7991da177e4SLinus Torvalds struct file *file, *f; 8001da177e4SLinus Torvalds struct inode *inode; 8011da177e4SLinus Torvalds struct address_space *mapping; 8021da177e4SLinus Torvalds unsigned lo_blocksize; 8031da177e4SLinus Torvalds int lo_flags = 0; 8041da177e4SLinus Torvalds int error; 8051da177e4SLinus Torvalds loff_t size; 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds /* This is safe, since we have a reference from open(). */ 8081da177e4SLinus Torvalds __module_get(THIS_MODULE); 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds error = -EBADF; 8111da177e4SLinus Torvalds file = fget(arg); 8121da177e4SLinus Torvalds if (!file) 8131da177e4SLinus Torvalds goto out; 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds error = -EBUSY; 8161da177e4SLinus Torvalds if (lo->lo_state != Lo_unbound) 8171da177e4SLinus Torvalds goto out_putf; 8181da177e4SLinus Torvalds 8191da177e4SLinus Torvalds /* Avoid recursion */ 8201da177e4SLinus Torvalds f = file; 8211da177e4SLinus Torvalds while (is_loop_device(f)) { 8221da177e4SLinus Torvalds struct loop_device *l; 8231da177e4SLinus Torvalds 824bb214884SAl Viro if (f->f_mapping->host->i_bdev == bdev) 8251da177e4SLinus Torvalds goto out_putf; 8261da177e4SLinus Torvalds 8271da177e4SLinus Torvalds l = f->f_mapping->host->i_bdev->bd_disk->private_data; 8281da177e4SLinus Torvalds if (l->lo_state == Lo_unbound) { 8291da177e4SLinus Torvalds error = -EINVAL; 8301da177e4SLinus Torvalds goto out_putf; 8311da177e4SLinus Torvalds } 8321da177e4SLinus Torvalds f = l->lo_backing_file; 8331da177e4SLinus Torvalds } 8341da177e4SLinus Torvalds 8351da177e4SLinus Torvalds mapping = file->f_mapping; 8361da177e4SLinus Torvalds inode = mapping->host; 8371da177e4SLinus Torvalds 8381da177e4SLinus Torvalds error = -EINVAL; 839456be148SChristoph Hellwig if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode)) 840456be148SChristoph Hellwig goto out_putf; 8416818173bSMiklos Szeredi 842456be148SChristoph Hellwig if (!(file->f_mode & FMODE_WRITE) || !(mode & FMODE_WRITE) || 843456be148SChristoph Hellwig !file->f_op->write) 8441da177e4SLinus Torvalds lo_flags |= LO_FLAGS_READ_ONLY; 8451da177e4SLinus Torvalds 846ba52de12STheodore Ts'o lo_blocksize = S_ISBLK(inode->i_mode) ? 847ba52de12STheodore Ts'o inode->i_bdev->bd_block_size : PAGE_SIZE; 848ba52de12STheodore Ts'o 8491da177e4SLinus Torvalds error = -EFBIG; 850456be148SChristoph Hellwig size = get_loop_size(lo, file); 851456be148SChristoph Hellwig if ((loff_t)(sector_t)size != size) 8521da177e4SLinus Torvalds goto out_putf; 8531da177e4SLinus Torvalds 854456be148SChristoph Hellwig error = 0; 8551da177e4SLinus Torvalds 8561da177e4SLinus Torvalds set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0); 8571da177e4SLinus Torvalds 8581da177e4SLinus Torvalds lo->lo_blocksize = lo_blocksize; 8591da177e4SLinus Torvalds lo->lo_device = bdev; 8601da177e4SLinus Torvalds lo->lo_flags = lo_flags; 8611da177e4SLinus Torvalds lo->lo_backing_file = file; 862eefe85eeSConstantine Sapuntzakis lo->transfer = transfer_none; 8631da177e4SLinus Torvalds lo->ioctl = NULL; 8641da177e4SLinus Torvalds lo->lo_sizelimit = 0; 8651da177e4SLinus Torvalds lo->old_gfp_mask = mapping_gfp_mask(mapping); 8661da177e4SLinus Torvalds mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS)); 8671da177e4SLinus Torvalds 868e686307fSAkinobu Mita bio_list_init(&lo->lo_bio_list); 8691da177e4SLinus Torvalds 8701da177e4SLinus Torvalds /* 8711da177e4SLinus Torvalds * set queue make_request_fn, and add limits based on lower level 8721da177e4SLinus Torvalds * device 8731da177e4SLinus Torvalds */ 8741da177e4SLinus Torvalds blk_queue_make_request(lo->lo_queue, loop_make_request); 8751da177e4SLinus Torvalds lo->lo_queue->queuedata = lo; 8761da177e4SLinus Torvalds 87768db1961SNikanth Karthikesan if (!(lo_flags & LO_FLAGS_READ_ONLY) && file->f_op->fsync) 8784913efe4STejun Heo blk_queue_flush(lo->lo_queue, REQ_FLUSH); 87968db1961SNikanth Karthikesan 88073285082SKen Chen set_capacity(lo->lo_disk, size); 8811da177e4SLinus Torvalds bd_set_size(bdev, size << 9); 882ee862730SMilan Broz loop_sysfs_init(lo); 883c3473c63SDavid Zeuthen /* let user-space know about the new size */ 884c3473c63SDavid Zeuthen kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE); 8851da177e4SLinus Torvalds 8861da177e4SLinus Torvalds set_blocksize(bdev, lo_blocksize); 8871da177e4SLinus Torvalds 8886c997918SSerge E. Hallyn lo->lo_thread = kthread_create(loop_thread, lo, "loop%d", 8896c997918SSerge E. Hallyn lo->lo_number); 8906c997918SSerge E. Hallyn if (IS_ERR(lo->lo_thread)) { 8916c997918SSerge E. Hallyn error = PTR_ERR(lo->lo_thread); 892a7422bf8SSerge E. Hallyn goto out_clr; 8936c997918SSerge E. Hallyn } 8946c997918SSerge E. Hallyn lo->lo_state = Lo_bound; 8956c997918SSerge E. Hallyn wake_up_process(lo->lo_thread); 896e03c8dd1SKay Sievers if (part_shift) 897e03c8dd1SKay Sievers lo->lo_flags |= LO_FLAGS_PARTSCAN; 898e03c8dd1SKay Sievers if (lo->lo_flags & LO_FLAGS_PARTSCAN) 899476a4813SLaurent Vivier ioctl_by_bdev(bdev, BLKRRPART, 0); 9001da177e4SLinus Torvalds return 0; 9011da177e4SLinus Torvalds 902a7422bf8SSerge E. Hallyn out_clr: 903ee862730SMilan Broz loop_sysfs_exit(lo); 904a7422bf8SSerge E. Hallyn lo->lo_thread = NULL; 905a7422bf8SSerge E. Hallyn lo->lo_device = NULL; 906a7422bf8SSerge E. Hallyn lo->lo_backing_file = NULL; 907a7422bf8SSerge E. Hallyn lo->lo_flags = 0; 90873285082SKen Chen set_capacity(lo->lo_disk, 0); 909f98393a6SPeter Zijlstra invalidate_bdev(bdev); 910a7422bf8SSerge E. Hallyn bd_set_size(bdev, 0); 911c3473c63SDavid Zeuthen kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE); 912a7422bf8SSerge E. Hallyn mapping_set_gfp_mask(mapping, lo->old_gfp_mask); 913a7422bf8SSerge E. Hallyn lo->lo_state = Lo_unbound; 9141da177e4SLinus Torvalds out_putf: 9151da177e4SLinus Torvalds fput(file); 9161da177e4SLinus Torvalds out: 9171da177e4SLinus Torvalds /* This is safe: open() is still holding a reference. */ 9181da177e4SLinus Torvalds module_put(THIS_MODULE); 9191da177e4SLinus Torvalds return error; 9201da177e4SLinus Torvalds } 9211da177e4SLinus Torvalds 9221da177e4SLinus Torvalds static int 9231da177e4SLinus Torvalds loop_release_xfer(struct loop_device *lo) 9241da177e4SLinus Torvalds { 9251da177e4SLinus Torvalds int err = 0; 9261da177e4SLinus Torvalds struct loop_func_table *xfer = lo->lo_encryption; 9271da177e4SLinus Torvalds 9281da177e4SLinus Torvalds if (xfer) { 9291da177e4SLinus Torvalds if (xfer->release) 9301da177e4SLinus Torvalds err = xfer->release(lo); 9311da177e4SLinus Torvalds lo->transfer = NULL; 9321da177e4SLinus Torvalds lo->lo_encryption = NULL; 9331da177e4SLinus Torvalds module_put(xfer->owner); 9341da177e4SLinus Torvalds } 9351da177e4SLinus Torvalds return err; 9361da177e4SLinus Torvalds } 9371da177e4SLinus Torvalds 9381da177e4SLinus Torvalds static int 9391da177e4SLinus Torvalds loop_init_xfer(struct loop_device *lo, struct loop_func_table *xfer, 9401da177e4SLinus Torvalds const struct loop_info64 *i) 9411da177e4SLinus Torvalds { 9421da177e4SLinus Torvalds int err = 0; 9431da177e4SLinus Torvalds 9441da177e4SLinus Torvalds if (xfer) { 9451da177e4SLinus Torvalds struct module *owner = xfer->owner; 9461da177e4SLinus Torvalds 9471da177e4SLinus Torvalds if (!try_module_get(owner)) 9481da177e4SLinus Torvalds return -EINVAL; 9491da177e4SLinus Torvalds if (xfer->init) 9501da177e4SLinus Torvalds err = xfer->init(lo, i); 9511da177e4SLinus Torvalds if (err) 9521da177e4SLinus Torvalds module_put(owner); 9531da177e4SLinus Torvalds else 9541da177e4SLinus Torvalds lo->lo_encryption = xfer; 9551da177e4SLinus Torvalds } 9561da177e4SLinus Torvalds return err; 9571da177e4SLinus Torvalds } 9581da177e4SLinus Torvalds 9594c823cc3SAyan George static int loop_clr_fd(struct loop_device *lo) 9601da177e4SLinus Torvalds { 9611da177e4SLinus Torvalds struct file *filp = lo->lo_backing_file; 962b4e3ca1aSAl Viro gfp_t gfp = lo->old_gfp_mask; 9634c823cc3SAyan George struct block_device *bdev = lo->lo_device; 9641da177e4SLinus Torvalds 9651da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 9661da177e4SLinus Torvalds return -ENXIO; 9671da177e4SLinus Torvalds 9681da177e4SLinus Torvalds if (lo->lo_refcnt > 1) /* we needed one fd for the ioctl */ 9691da177e4SLinus Torvalds return -EBUSY; 9701da177e4SLinus Torvalds 9711da177e4SLinus Torvalds if (filp == NULL) 9721da177e4SLinus Torvalds return -EINVAL; 9731da177e4SLinus Torvalds 9741da177e4SLinus Torvalds spin_lock_irq(&lo->lo_lock); 9751da177e4SLinus Torvalds lo->lo_state = Lo_rundown; 9761da177e4SLinus Torvalds spin_unlock_irq(&lo->lo_lock); 9771da177e4SLinus Torvalds 9786c997918SSerge E. Hallyn kthread_stop(lo->lo_thread); 9791da177e4SLinus Torvalds 98005eb0f25SKay Sievers spin_lock_irq(&lo->lo_lock); 9811da177e4SLinus Torvalds lo->lo_backing_file = NULL; 98205eb0f25SKay Sievers spin_unlock_irq(&lo->lo_lock); 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds loop_release_xfer(lo); 9851da177e4SLinus Torvalds lo->transfer = NULL; 9861da177e4SLinus Torvalds lo->ioctl = NULL; 9871da177e4SLinus Torvalds lo->lo_device = NULL; 9881da177e4SLinus Torvalds lo->lo_encryption = NULL; 9891da177e4SLinus Torvalds lo->lo_offset = 0; 9901da177e4SLinus Torvalds lo->lo_sizelimit = 0; 9911da177e4SLinus Torvalds lo->lo_encrypt_key_size = 0; 9926c997918SSerge E. Hallyn lo->lo_thread = NULL; 9931da177e4SLinus Torvalds memset(lo->lo_encrypt_key, 0, LO_KEY_SIZE); 9941da177e4SLinus Torvalds memset(lo->lo_crypt_name, 0, LO_NAME_SIZE); 9951da177e4SLinus Torvalds memset(lo->lo_file_name, 0, LO_NAME_SIZE); 996bb214884SAl Viro if (bdev) 997f98393a6SPeter Zijlstra invalidate_bdev(bdev); 99873285082SKen Chen set_capacity(lo->lo_disk, 0); 99951a0bb0cSMilan Broz loop_sysfs_exit(lo); 1000c3473c63SDavid Zeuthen if (bdev) { 10011da177e4SLinus Torvalds bd_set_size(bdev, 0); 1002c3473c63SDavid Zeuthen /* let user-space know about this change */ 1003c3473c63SDavid Zeuthen kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE); 1004c3473c63SDavid Zeuthen } 10051da177e4SLinus Torvalds mapping_set_gfp_mask(filp->f_mapping, gfp); 10061da177e4SLinus Torvalds lo->lo_state = Lo_unbound; 10071da177e4SLinus Torvalds /* This is safe: open() is still holding a reference. */ 10081da177e4SLinus Torvalds module_put(THIS_MODULE); 1009e03c8dd1SKay Sievers if (lo->lo_flags & LO_FLAGS_PARTSCAN && bdev) 1010476a4813SLaurent Vivier ioctl_by_bdev(bdev, BLKRRPART, 0); 1011e03c8dd1SKay Sievers lo->lo_flags = 0; 1012e03c8dd1SKay Sievers if (!part_shift) 1013e03c8dd1SKay Sievers lo->lo_disk->flags |= GENHD_FL_NO_PART_SCAN; 1014f028f3b2SNikanth Karthikesan mutex_unlock(&lo->lo_ctl_mutex); 1015f028f3b2SNikanth Karthikesan /* 1016f028f3b2SNikanth Karthikesan * Need not hold lo_ctl_mutex to fput backing file. 1017f028f3b2SNikanth Karthikesan * Calling fput holding lo_ctl_mutex triggers a circular 1018f028f3b2SNikanth Karthikesan * lock dependency possibility warning as fput can take 1019f028f3b2SNikanth Karthikesan * bd_mutex which is usually taken before lo_ctl_mutex. 1020f028f3b2SNikanth Karthikesan */ 1021f028f3b2SNikanth Karthikesan fput(filp); 10221da177e4SLinus Torvalds return 0; 10231da177e4SLinus Torvalds } 10241da177e4SLinus Torvalds 10251da177e4SLinus Torvalds static int 10261da177e4SLinus Torvalds loop_set_status(struct loop_device *lo, const struct loop_info64 *info) 10271da177e4SLinus Torvalds { 10281da177e4SLinus Torvalds int err; 10291da177e4SLinus Torvalds struct loop_func_table *xfer; 1030b0fafa81SDavid Howells uid_t uid = current_uid(); 10311da177e4SLinus Torvalds 1032b0fafa81SDavid Howells if (lo->lo_encrypt_key_size && 1033b0fafa81SDavid Howells lo->lo_key_owner != uid && 10341da177e4SLinus Torvalds !capable(CAP_SYS_ADMIN)) 10351da177e4SLinus Torvalds return -EPERM; 10361da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 10371da177e4SLinus Torvalds return -ENXIO; 10381da177e4SLinus Torvalds if ((unsigned int) info->lo_encrypt_key_size > LO_KEY_SIZE) 10391da177e4SLinus Torvalds return -EINVAL; 10401da177e4SLinus Torvalds 10411da177e4SLinus Torvalds err = loop_release_xfer(lo); 10421da177e4SLinus Torvalds if (err) 10431da177e4SLinus Torvalds return err; 10441da177e4SLinus Torvalds 10451da177e4SLinus Torvalds if (info->lo_encrypt_type) { 10461da177e4SLinus Torvalds unsigned int type = info->lo_encrypt_type; 10471da177e4SLinus Torvalds 10481da177e4SLinus Torvalds if (type >= MAX_LO_CRYPT) 10491da177e4SLinus Torvalds return -EINVAL; 10501da177e4SLinus Torvalds xfer = xfer_funcs[type]; 10511da177e4SLinus Torvalds if (xfer == NULL) 10521da177e4SLinus Torvalds return -EINVAL; 10531da177e4SLinus Torvalds } else 10541da177e4SLinus Torvalds xfer = NULL; 10551da177e4SLinus Torvalds 10561da177e4SLinus Torvalds err = loop_init_xfer(lo, xfer, info); 10571da177e4SLinus Torvalds if (err) 10581da177e4SLinus Torvalds return err; 10591da177e4SLinus Torvalds 10601da177e4SLinus Torvalds if (lo->lo_offset != info->lo_offset || 10611da177e4SLinus Torvalds lo->lo_sizelimit != info->lo_sizelimit) { 10621da177e4SLinus Torvalds lo->lo_offset = info->lo_offset; 10631da177e4SLinus Torvalds lo->lo_sizelimit = info->lo_sizelimit; 10641da177e4SLinus Torvalds if (figure_loop_size(lo)) 10651da177e4SLinus Torvalds return -EFBIG; 10661da177e4SLinus Torvalds } 1067dfaa2ef6SLukas Czerner loop_config_discard(lo); 10681da177e4SLinus Torvalds 10691da177e4SLinus Torvalds memcpy(lo->lo_file_name, info->lo_file_name, LO_NAME_SIZE); 10701da177e4SLinus Torvalds memcpy(lo->lo_crypt_name, info->lo_crypt_name, LO_NAME_SIZE); 10711da177e4SLinus Torvalds lo->lo_file_name[LO_NAME_SIZE-1] = 0; 10721da177e4SLinus Torvalds lo->lo_crypt_name[LO_NAME_SIZE-1] = 0; 10731da177e4SLinus Torvalds 10741da177e4SLinus Torvalds if (!xfer) 10751da177e4SLinus Torvalds xfer = &none_funcs; 10761da177e4SLinus Torvalds lo->transfer = xfer->transfer; 10771da177e4SLinus Torvalds lo->ioctl = xfer->ioctl; 10781da177e4SLinus Torvalds 107996c58655SDavid Woodhouse if ((lo->lo_flags & LO_FLAGS_AUTOCLEAR) != 108096c58655SDavid Woodhouse (info->lo_flags & LO_FLAGS_AUTOCLEAR)) 108196c58655SDavid Woodhouse lo->lo_flags ^= LO_FLAGS_AUTOCLEAR; 108296c58655SDavid Woodhouse 1083e03c8dd1SKay Sievers if ((info->lo_flags & LO_FLAGS_PARTSCAN) && 1084e03c8dd1SKay Sievers !(lo->lo_flags & LO_FLAGS_PARTSCAN)) { 1085e03c8dd1SKay Sievers lo->lo_flags |= LO_FLAGS_PARTSCAN; 1086e03c8dd1SKay Sievers lo->lo_disk->flags &= ~GENHD_FL_NO_PART_SCAN; 1087e03c8dd1SKay Sievers ioctl_by_bdev(lo->lo_device, BLKRRPART, 0); 1088e03c8dd1SKay Sievers } 1089e03c8dd1SKay Sievers 10901da177e4SLinus Torvalds lo->lo_encrypt_key_size = info->lo_encrypt_key_size; 10911da177e4SLinus Torvalds lo->lo_init[0] = info->lo_init[0]; 10921da177e4SLinus Torvalds lo->lo_init[1] = info->lo_init[1]; 10931da177e4SLinus Torvalds if (info->lo_encrypt_key_size) { 10941da177e4SLinus Torvalds memcpy(lo->lo_encrypt_key, info->lo_encrypt_key, 10951da177e4SLinus Torvalds info->lo_encrypt_key_size); 1096b0fafa81SDavid Howells lo->lo_key_owner = uid; 10971da177e4SLinus Torvalds } 10981da177e4SLinus Torvalds 10991da177e4SLinus Torvalds return 0; 11001da177e4SLinus Torvalds } 11011da177e4SLinus Torvalds 11021da177e4SLinus Torvalds static int 11031da177e4SLinus Torvalds loop_get_status(struct loop_device *lo, struct loop_info64 *info) 11041da177e4SLinus Torvalds { 11051da177e4SLinus Torvalds struct file *file = lo->lo_backing_file; 11061da177e4SLinus Torvalds struct kstat stat; 11071da177e4SLinus Torvalds int error; 11081da177e4SLinus Torvalds 11091da177e4SLinus Torvalds if (lo->lo_state != Lo_bound) 11101da177e4SLinus Torvalds return -ENXIO; 11116c648be6SJosef Sipek error = vfs_getattr(file->f_path.mnt, file->f_path.dentry, &stat); 11121da177e4SLinus Torvalds if (error) 11131da177e4SLinus Torvalds return error; 11141da177e4SLinus Torvalds memset(info, 0, sizeof(*info)); 11151da177e4SLinus Torvalds info->lo_number = lo->lo_number; 11161da177e4SLinus Torvalds info->lo_device = huge_encode_dev(stat.dev); 11171da177e4SLinus Torvalds info->lo_inode = stat.ino; 11181da177e4SLinus Torvalds info->lo_rdevice = huge_encode_dev(lo->lo_device ? stat.rdev : stat.dev); 11191da177e4SLinus Torvalds info->lo_offset = lo->lo_offset; 11201da177e4SLinus Torvalds info->lo_sizelimit = lo->lo_sizelimit; 11211da177e4SLinus Torvalds info->lo_flags = lo->lo_flags; 11221da177e4SLinus Torvalds memcpy(info->lo_file_name, lo->lo_file_name, LO_NAME_SIZE); 11231da177e4SLinus Torvalds memcpy(info->lo_crypt_name, lo->lo_crypt_name, LO_NAME_SIZE); 11241da177e4SLinus Torvalds info->lo_encrypt_type = 11251da177e4SLinus Torvalds lo->lo_encryption ? lo->lo_encryption->number : 0; 11261da177e4SLinus Torvalds if (lo->lo_encrypt_key_size && capable(CAP_SYS_ADMIN)) { 11271da177e4SLinus Torvalds info->lo_encrypt_key_size = lo->lo_encrypt_key_size; 11281da177e4SLinus Torvalds memcpy(info->lo_encrypt_key, lo->lo_encrypt_key, 11291da177e4SLinus Torvalds lo->lo_encrypt_key_size); 11301da177e4SLinus Torvalds } 11311da177e4SLinus Torvalds return 0; 11321da177e4SLinus Torvalds } 11331da177e4SLinus Torvalds 11341da177e4SLinus Torvalds static void 11351da177e4SLinus Torvalds loop_info64_from_old(const struct loop_info *info, struct loop_info64 *info64) 11361da177e4SLinus Torvalds { 11371da177e4SLinus Torvalds memset(info64, 0, sizeof(*info64)); 11381da177e4SLinus Torvalds info64->lo_number = info->lo_number; 11391da177e4SLinus Torvalds info64->lo_device = info->lo_device; 11401da177e4SLinus Torvalds info64->lo_inode = info->lo_inode; 11411da177e4SLinus Torvalds info64->lo_rdevice = info->lo_rdevice; 11421da177e4SLinus Torvalds info64->lo_offset = info->lo_offset; 11431da177e4SLinus Torvalds info64->lo_sizelimit = 0; 11441da177e4SLinus Torvalds info64->lo_encrypt_type = info->lo_encrypt_type; 11451da177e4SLinus Torvalds info64->lo_encrypt_key_size = info->lo_encrypt_key_size; 11461da177e4SLinus Torvalds info64->lo_flags = info->lo_flags; 11471da177e4SLinus Torvalds info64->lo_init[0] = info->lo_init[0]; 11481da177e4SLinus Torvalds info64->lo_init[1] = info->lo_init[1]; 11491da177e4SLinus Torvalds if (info->lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 11501da177e4SLinus Torvalds memcpy(info64->lo_crypt_name, info->lo_name, LO_NAME_SIZE); 11511da177e4SLinus Torvalds else 11521da177e4SLinus Torvalds memcpy(info64->lo_file_name, info->lo_name, LO_NAME_SIZE); 11531da177e4SLinus Torvalds memcpy(info64->lo_encrypt_key, info->lo_encrypt_key, LO_KEY_SIZE); 11541da177e4SLinus Torvalds } 11551da177e4SLinus Torvalds 11561da177e4SLinus Torvalds static int 11571da177e4SLinus Torvalds loop_info64_to_old(const struct loop_info64 *info64, struct loop_info *info) 11581da177e4SLinus Torvalds { 11591da177e4SLinus Torvalds memset(info, 0, sizeof(*info)); 11601da177e4SLinus Torvalds info->lo_number = info64->lo_number; 11611da177e4SLinus Torvalds info->lo_device = info64->lo_device; 11621da177e4SLinus Torvalds info->lo_inode = info64->lo_inode; 11631da177e4SLinus Torvalds info->lo_rdevice = info64->lo_rdevice; 11641da177e4SLinus Torvalds info->lo_offset = info64->lo_offset; 11651da177e4SLinus Torvalds info->lo_encrypt_type = info64->lo_encrypt_type; 11661da177e4SLinus Torvalds info->lo_encrypt_key_size = info64->lo_encrypt_key_size; 11671da177e4SLinus Torvalds info->lo_flags = info64->lo_flags; 11681da177e4SLinus Torvalds info->lo_init[0] = info64->lo_init[0]; 11691da177e4SLinus Torvalds info->lo_init[1] = info64->lo_init[1]; 11701da177e4SLinus Torvalds if (info->lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 11711da177e4SLinus Torvalds memcpy(info->lo_name, info64->lo_crypt_name, LO_NAME_SIZE); 11721da177e4SLinus Torvalds else 11731da177e4SLinus Torvalds memcpy(info->lo_name, info64->lo_file_name, LO_NAME_SIZE); 11741da177e4SLinus Torvalds memcpy(info->lo_encrypt_key, info64->lo_encrypt_key, LO_KEY_SIZE); 11751da177e4SLinus Torvalds 11761da177e4SLinus Torvalds /* error in case values were truncated */ 11771da177e4SLinus Torvalds if (info->lo_device != info64->lo_device || 11781da177e4SLinus Torvalds info->lo_rdevice != info64->lo_rdevice || 11791da177e4SLinus Torvalds info->lo_inode != info64->lo_inode || 11801da177e4SLinus Torvalds info->lo_offset != info64->lo_offset) 11811da177e4SLinus Torvalds return -EOVERFLOW; 11821da177e4SLinus Torvalds 11831da177e4SLinus Torvalds return 0; 11841da177e4SLinus Torvalds } 11851da177e4SLinus Torvalds 11861da177e4SLinus Torvalds static int 11871da177e4SLinus Torvalds loop_set_status_old(struct loop_device *lo, const struct loop_info __user *arg) 11881da177e4SLinus Torvalds { 11891da177e4SLinus Torvalds struct loop_info info; 11901da177e4SLinus Torvalds struct loop_info64 info64; 11911da177e4SLinus Torvalds 11921da177e4SLinus Torvalds if (copy_from_user(&info, arg, sizeof (struct loop_info))) 11931da177e4SLinus Torvalds return -EFAULT; 11941da177e4SLinus Torvalds loop_info64_from_old(&info, &info64); 11951da177e4SLinus Torvalds return loop_set_status(lo, &info64); 11961da177e4SLinus Torvalds } 11971da177e4SLinus Torvalds 11981da177e4SLinus Torvalds static int 11991da177e4SLinus Torvalds loop_set_status64(struct loop_device *lo, const struct loop_info64 __user *arg) 12001da177e4SLinus Torvalds { 12011da177e4SLinus Torvalds struct loop_info64 info64; 12021da177e4SLinus Torvalds 12031da177e4SLinus Torvalds if (copy_from_user(&info64, arg, sizeof (struct loop_info64))) 12041da177e4SLinus Torvalds return -EFAULT; 12051da177e4SLinus Torvalds return loop_set_status(lo, &info64); 12061da177e4SLinus Torvalds } 12071da177e4SLinus Torvalds 12081da177e4SLinus Torvalds static int 12091da177e4SLinus Torvalds loop_get_status_old(struct loop_device *lo, struct loop_info __user *arg) { 12101da177e4SLinus Torvalds struct loop_info info; 12111da177e4SLinus Torvalds struct loop_info64 info64; 12121da177e4SLinus Torvalds int err = 0; 12131da177e4SLinus Torvalds 12141da177e4SLinus Torvalds if (!arg) 12151da177e4SLinus Torvalds err = -EINVAL; 12161da177e4SLinus Torvalds if (!err) 12171da177e4SLinus Torvalds err = loop_get_status(lo, &info64); 12181da177e4SLinus Torvalds if (!err) 12191da177e4SLinus Torvalds err = loop_info64_to_old(&info64, &info); 12201da177e4SLinus Torvalds if (!err && copy_to_user(arg, &info, sizeof(info))) 12211da177e4SLinus Torvalds err = -EFAULT; 12221da177e4SLinus Torvalds 12231da177e4SLinus Torvalds return err; 12241da177e4SLinus Torvalds } 12251da177e4SLinus Torvalds 12261da177e4SLinus Torvalds static int 12271da177e4SLinus Torvalds loop_get_status64(struct loop_device *lo, struct loop_info64 __user *arg) { 12281da177e4SLinus Torvalds struct loop_info64 info64; 12291da177e4SLinus Torvalds int err = 0; 12301da177e4SLinus Torvalds 12311da177e4SLinus Torvalds if (!arg) 12321da177e4SLinus Torvalds err = -EINVAL; 12331da177e4SLinus Torvalds if (!err) 12341da177e4SLinus Torvalds err = loop_get_status(lo, &info64); 12351da177e4SLinus Torvalds if (!err && copy_to_user(arg, &info64, sizeof(info64))) 12361da177e4SLinus Torvalds err = -EFAULT; 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds return err; 12391da177e4SLinus Torvalds } 12401da177e4SLinus Torvalds 124153d66608SJ. R. Okajima static int loop_set_capacity(struct loop_device *lo, struct block_device *bdev) 124253d66608SJ. R. Okajima { 124353d66608SJ. R. Okajima int err; 124453d66608SJ. R. Okajima sector_t sec; 124553d66608SJ. R. Okajima loff_t sz; 124653d66608SJ. R. Okajima 124753d66608SJ. R. Okajima err = -ENXIO; 124853d66608SJ. R. Okajima if (unlikely(lo->lo_state != Lo_bound)) 124953d66608SJ. R. Okajima goto out; 125053d66608SJ. R. Okajima err = figure_loop_size(lo); 125153d66608SJ. R. Okajima if (unlikely(err)) 125253d66608SJ. R. Okajima goto out; 125353d66608SJ. R. Okajima sec = get_capacity(lo->lo_disk); 125453d66608SJ. R. Okajima /* the width of sector_t may be narrow for bit-shift */ 125553d66608SJ. R. Okajima sz = sec; 125653d66608SJ. R. Okajima sz <<= 9; 125753d66608SJ. R. Okajima mutex_lock(&bdev->bd_mutex); 125853d66608SJ. R. Okajima bd_set_size(bdev, sz); 1259c3473c63SDavid Zeuthen /* let user-space know about the new size */ 1260c3473c63SDavid Zeuthen kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE); 126153d66608SJ. R. Okajima mutex_unlock(&bdev->bd_mutex); 126253d66608SJ. R. Okajima 126353d66608SJ. R. Okajima out: 126453d66608SJ. R. Okajima return err; 126553d66608SJ. R. Okajima } 126653d66608SJ. R. Okajima 1267bb214884SAl Viro static int lo_ioctl(struct block_device *bdev, fmode_t mode, 12681da177e4SLinus Torvalds unsigned int cmd, unsigned long arg) 12691da177e4SLinus Torvalds { 1270bb214884SAl Viro struct loop_device *lo = bdev->bd_disk->private_data; 12711da177e4SLinus Torvalds int err; 12721da177e4SLinus Torvalds 1273f028f3b2SNikanth Karthikesan mutex_lock_nested(&lo->lo_ctl_mutex, 1); 12741da177e4SLinus Torvalds switch (cmd) { 12751da177e4SLinus Torvalds case LOOP_SET_FD: 1276bb214884SAl Viro err = loop_set_fd(lo, mode, bdev, arg); 12771da177e4SLinus Torvalds break; 12781da177e4SLinus Torvalds case LOOP_CHANGE_FD: 1279bb214884SAl Viro err = loop_change_fd(lo, bdev, arg); 12801da177e4SLinus Torvalds break; 12811da177e4SLinus Torvalds case LOOP_CLR_FD: 1282f028f3b2SNikanth Karthikesan /* loop_clr_fd would have unlocked lo_ctl_mutex on success */ 12834c823cc3SAyan George err = loop_clr_fd(lo); 1284f028f3b2SNikanth Karthikesan if (!err) 1285f028f3b2SNikanth Karthikesan goto out_unlocked; 12861da177e4SLinus Torvalds break; 12871da177e4SLinus Torvalds case LOOP_SET_STATUS: 12881da177e4SLinus Torvalds err = loop_set_status_old(lo, (struct loop_info __user *) arg); 12891da177e4SLinus Torvalds break; 12901da177e4SLinus Torvalds case LOOP_GET_STATUS: 12911da177e4SLinus Torvalds err = loop_get_status_old(lo, (struct loop_info __user *) arg); 12921da177e4SLinus Torvalds break; 12931da177e4SLinus Torvalds case LOOP_SET_STATUS64: 12941da177e4SLinus Torvalds err = loop_set_status64(lo, (struct loop_info64 __user *) arg); 12951da177e4SLinus Torvalds break; 12961da177e4SLinus Torvalds case LOOP_GET_STATUS64: 12971da177e4SLinus Torvalds err = loop_get_status64(lo, (struct loop_info64 __user *) arg); 12981da177e4SLinus Torvalds break; 129953d66608SJ. R. Okajima case LOOP_SET_CAPACITY: 130053d66608SJ. R. Okajima err = -EPERM; 130153d66608SJ. R. Okajima if ((mode & FMODE_WRITE) || capable(CAP_SYS_ADMIN)) 130253d66608SJ. R. Okajima err = loop_set_capacity(lo, bdev); 130353d66608SJ. R. Okajima break; 13041da177e4SLinus Torvalds default: 13051da177e4SLinus Torvalds err = lo->ioctl ? lo->ioctl(lo, cmd, arg) : -EINVAL; 13061da177e4SLinus Torvalds } 1307f85221ddSIngo Molnar mutex_unlock(&lo->lo_ctl_mutex); 1308f028f3b2SNikanth Karthikesan 1309f028f3b2SNikanth Karthikesan out_unlocked: 13101da177e4SLinus Torvalds return err; 13111da177e4SLinus Torvalds } 13121da177e4SLinus Torvalds 1313863d5b82SDavid Howells #ifdef CONFIG_COMPAT 1314863d5b82SDavid Howells struct compat_loop_info { 1315863d5b82SDavid Howells compat_int_t lo_number; /* ioctl r/o */ 1316863d5b82SDavid Howells compat_dev_t lo_device; /* ioctl r/o */ 1317863d5b82SDavid Howells compat_ulong_t lo_inode; /* ioctl r/o */ 1318863d5b82SDavid Howells compat_dev_t lo_rdevice; /* ioctl r/o */ 1319863d5b82SDavid Howells compat_int_t lo_offset; 1320863d5b82SDavid Howells compat_int_t lo_encrypt_type; 1321863d5b82SDavid Howells compat_int_t lo_encrypt_key_size; /* ioctl w/o */ 1322863d5b82SDavid Howells compat_int_t lo_flags; /* ioctl r/o */ 1323863d5b82SDavid Howells char lo_name[LO_NAME_SIZE]; 1324863d5b82SDavid Howells unsigned char lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */ 1325863d5b82SDavid Howells compat_ulong_t lo_init[2]; 1326863d5b82SDavid Howells char reserved[4]; 1327863d5b82SDavid Howells }; 1328863d5b82SDavid Howells 1329863d5b82SDavid Howells /* 1330863d5b82SDavid Howells * Transfer 32-bit compatibility structure in userspace to 64-bit loop info 1331863d5b82SDavid Howells * - noinlined to reduce stack space usage in main part of driver 1332863d5b82SDavid Howells */ 1333863d5b82SDavid Howells static noinline int 1334ba674cfcSAl Viro loop_info64_from_compat(const struct compat_loop_info __user *arg, 1335863d5b82SDavid Howells struct loop_info64 *info64) 1336863d5b82SDavid Howells { 1337863d5b82SDavid Howells struct compat_loop_info info; 1338863d5b82SDavid Howells 1339863d5b82SDavid Howells if (copy_from_user(&info, arg, sizeof(info))) 1340863d5b82SDavid Howells return -EFAULT; 1341863d5b82SDavid Howells 1342863d5b82SDavid Howells memset(info64, 0, sizeof(*info64)); 1343863d5b82SDavid Howells info64->lo_number = info.lo_number; 1344863d5b82SDavid Howells info64->lo_device = info.lo_device; 1345863d5b82SDavid Howells info64->lo_inode = info.lo_inode; 1346863d5b82SDavid Howells info64->lo_rdevice = info.lo_rdevice; 1347863d5b82SDavid Howells info64->lo_offset = info.lo_offset; 1348863d5b82SDavid Howells info64->lo_sizelimit = 0; 1349863d5b82SDavid Howells info64->lo_encrypt_type = info.lo_encrypt_type; 1350863d5b82SDavid Howells info64->lo_encrypt_key_size = info.lo_encrypt_key_size; 1351863d5b82SDavid Howells info64->lo_flags = info.lo_flags; 1352863d5b82SDavid Howells info64->lo_init[0] = info.lo_init[0]; 1353863d5b82SDavid Howells info64->lo_init[1] = info.lo_init[1]; 1354863d5b82SDavid Howells if (info.lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 1355863d5b82SDavid Howells memcpy(info64->lo_crypt_name, info.lo_name, LO_NAME_SIZE); 1356863d5b82SDavid Howells else 1357863d5b82SDavid Howells memcpy(info64->lo_file_name, info.lo_name, LO_NAME_SIZE); 1358863d5b82SDavid Howells memcpy(info64->lo_encrypt_key, info.lo_encrypt_key, LO_KEY_SIZE); 1359863d5b82SDavid Howells return 0; 1360863d5b82SDavid Howells } 1361863d5b82SDavid Howells 1362863d5b82SDavid Howells /* 1363863d5b82SDavid Howells * Transfer 64-bit loop info to 32-bit compatibility structure in userspace 1364863d5b82SDavid Howells * - noinlined to reduce stack space usage in main part of driver 1365863d5b82SDavid Howells */ 1366863d5b82SDavid Howells static noinline int 1367863d5b82SDavid Howells loop_info64_to_compat(const struct loop_info64 *info64, 1368863d5b82SDavid Howells struct compat_loop_info __user *arg) 1369863d5b82SDavid Howells { 1370863d5b82SDavid Howells struct compat_loop_info info; 1371863d5b82SDavid Howells 1372863d5b82SDavid Howells memset(&info, 0, sizeof(info)); 1373863d5b82SDavid Howells info.lo_number = info64->lo_number; 1374863d5b82SDavid Howells info.lo_device = info64->lo_device; 1375863d5b82SDavid Howells info.lo_inode = info64->lo_inode; 1376863d5b82SDavid Howells info.lo_rdevice = info64->lo_rdevice; 1377863d5b82SDavid Howells info.lo_offset = info64->lo_offset; 1378863d5b82SDavid Howells info.lo_encrypt_type = info64->lo_encrypt_type; 1379863d5b82SDavid Howells info.lo_encrypt_key_size = info64->lo_encrypt_key_size; 1380863d5b82SDavid Howells info.lo_flags = info64->lo_flags; 1381863d5b82SDavid Howells info.lo_init[0] = info64->lo_init[0]; 1382863d5b82SDavid Howells info.lo_init[1] = info64->lo_init[1]; 1383863d5b82SDavid Howells if (info.lo_encrypt_type == LO_CRYPT_CRYPTOAPI) 1384863d5b82SDavid Howells memcpy(info.lo_name, info64->lo_crypt_name, LO_NAME_SIZE); 1385863d5b82SDavid Howells else 1386863d5b82SDavid Howells memcpy(info.lo_name, info64->lo_file_name, LO_NAME_SIZE); 1387863d5b82SDavid Howells memcpy(info.lo_encrypt_key, info64->lo_encrypt_key, LO_KEY_SIZE); 1388863d5b82SDavid Howells 1389863d5b82SDavid Howells /* error in case values were truncated */ 1390863d5b82SDavid Howells if (info.lo_device != info64->lo_device || 1391863d5b82SDavid Howells info.lo_rdevice != info64->lo_rdevice || 1392863d5b82SDavid Howells info.lo_inode != info64->lo_inode || 1393863d5b82SDavid Howells info.lo_offset != info64->lo_offset || 1394863d5b82SDavid Howells info.lo_init[0] != info64->lo_init[0] || 1395863d5b82SDavid Howells info.lo_init[1] != info64->lo_init[1]) 1396863d5b82SDavid Howells return -EOVERFLOW; 1397863d5b82SDavid Howells 1398863d5b82SDavid Howells if (copy_to_user(arg, &info, sizeof(info))) 1399863d5b82SDavid Howells return -EFAULT; 1400863d5b82SDavid Howells return 0; 1401863d5b82SDavid Howells } 1402863d5b82SDavid Howells 1403863d5b82SDavid Howells static int 1404863d5b82SDavid Howells loop_set_status_compat(struct loop_device *lo, 1405863d5b82SDavid Howells const struct compat_loop_info __user *arg) 1406863d5b82SDavid Howells { 1407863d5b82SDavid Howells struct loop_info64 info64; 1408863d5b82SDavid Howells int ret; 1409863d5b82SDavid Howells 1410863d5b82SDavid Howells ret = loop_info64_from_compat(arg, &info64); 1411863d5b82SDavid Howells if (ret < 0) 1412863d5b82SDavid Howells return ret; 1413863d5b82SDavid Howells return loop_set_status(lo, &info64); 1414863d5b82SDavid Howells } 1415863d5b82SDavid Howells 1416863d5b82SDavid Howells static int 1417863d5b82SDavid Howells loop_get_status_compat(struct loop_device *lo, 1418863d5b82SDavid Howells struct compat_loop_info __user *arg) 1419863d5b82SDavid Howells { 1420863d5b82SDavid Howells struct loop_info64 info64; 1421863d5b82SDavid Howells int err = 0; 1422863d5b82SDavid Howells 1423863d5b82SDavid Howells if (!arg) 1424863d5b82SDavid Howells err = -EINVAL; 1425863d5b82SDavid Howells if (!err) 1426863d5b82SDavid Howells err = loop_get_status(lo, &info64); 1427863d5b82SDavid Howells if (!err) 1428863d5b82SDavid Howells err = loop_info64_to_compat(&info64, arg); 1429863d5b82SDavid Howells return err; 1430863d5b82SDavid Howells } 1431863d5b82SDavid Howells 1432bb214884SAl Viro static int lo_compat_ioctl(struct block_device *bdev, fmode_t mode, 1433bb214884SAl Viro unsigned int cmd, unsigned long arg) 1434863d5b82SDavid Howells { 1435bb214884SAl Viro struct loop_device *lo = bdev->bd_disk->private_data; 1436863d5b82SDavid Howells int err; 1437863d5b82SDavid Howells 1438863d5b82SDavid Howells switch(cmd) { 1439863d5b82SDavid Howells case LOOP_SET_STATUS: 1440863d5b82SDavid Howells mutex_lock(&lo->lo_ctl_mutex); 1441863d5b82SDavid Howells err = loop_set_status_compat( 1442863d5b82SDavid Howells lo, (const struct compat_loop_info __user *) arg); 1443863d5b82SDavid Howells mutex_unlock(&lo->lo_ctl_mutex); 1444863d5b82SDavid Howells break; 1445863d5b82SDavid Howells case LOOP_GET_STATUS: 1446863d5b82SDavid Howells mutex_lock(&lo->lo_ctl_mutex); 1447863d5b82SDavid Howells err = loop_get_status_compat( 1448863d5b82SDavid Howells lo, (struct compat_loop_info __user *) arg); 1449863d5b82SDavid Howells mutex_unlock(&lo->lo_ctl_mutex); 1450863d5b82SDavid Howells break; 145153d66608SJ. R. Okajima case LOOP_SET_CAPACITY: 1452863d5b82SDavid Howells case LOOP_CLR_FD: 1453863d5b82SDavid Howells case LOOP_GET_STATUS64: 1454863d5b82SDavid Howells case LOOP_SET_STATUS64: 1455863d5b82SDavid Howells arg = (unsigned long) compat_ptr(arg); 1456863d5b82SDavid Howells case LOOP_SET_FD: 1457863d5b82SDavid Howells case LOOP_CHANGE_FD: 1458bb214884SAl Viro err = lo_ioctl(bdev, mode, cmd, arg); 1459863d5b82SDavid Howells break; 1460863d5b82SDavid Howells default: 1461863d5b82SDavid Howells err = -ENOIOCTLCMD; 1462863d5b82SDavid Howells break; 1463863d5b82SDavid Howells } 1464863d5b82SDavid Howells return err; 1465863d5b82SDavid Howells } 1466863d5b82SDavid Howells #endif 1467863d5b82SDavid Howells 1468bb214884SAl Viro static int lo_open(struct block_device *bdev, fmode_t mode) 14691da177e4SLinus Torvalds { 1470770fe30aSKay Sievers struct loop_device *lo; 1471770fe30aSKay Sievers int err = 0; 1472770fe30aSKay Sievers 1473770fe30aSKay Sievers mutex_lock(&loop_index_mutex); 1474770fe30aSKay Sievers lo = bdev->bd_disk->private_data; 1475770fe30aSKay Sievers if (!lo) { 1476770fe30aSKay Sievers err = -ENXIO; 1477770fe30aSKay Sievers goto out; 1478770fe30aSKay Sievers } 14791da177e4SLinus Torvalds 1480f85221ddSIngo Molnar mutex_lock(&lo->lo_ctl_mutex); 14811da177e4SLinus Torvalds lo->lo_refcnt++; 1482f85221ddSIngo Molnar mutex_unlock(&lo->lo_ctl_mutex); 1483770fe30aSKay Sievers out: 1484770fe30aSKay Sievers mutex_unlock(&loop_index_mutex); 1485770fe30aSKay Sievers return err; 14861da177e4SLinus Torvalds } 14871da177e4SLinus Torvalds 1488bb214884SAl Viro static int lo_release(struct gendisk *disk, fmode_t mode) 14891da177e4SLinus Torvalds { 1490bb214884SAl Viro struct loop_device *lo = disk->private_data; 1491ffcd7dcaSAlexander Beregalov int err; 14921da177e4SLinus Torvalds 1493f85221ddSIngo Molnar mutex_lock(&lo->lo_ctl_mutex); 149496c58655SDavid Woodhouse 149514f27939SMilan Broz if (--lo->lo_refcnt) 149614f27939SMilan Broz goto out; 149714f27939SMilan Broz 149814f27939SMilan Broz if (lo->lo_flags & LO_FLAGS_AUTOCLEAR) { 149914f27939SMilan Broz /* 150014f27939SMilan Broz * In autoclear mode, stop the loop thread 150114f27939SMilan Broz * and remove configuration after last close. 150214f27939SMilan Broz */ 15034c823cc3SAyan George err = loop_clr_fd(lo); 1504ffcd7dcaSAlexander Beregalov if (!err) 1505ffcd7dcaSAlexander Beregalov goto out_unlocked; 150614f27939SMilan Broz } else { 150714f27939SMilan Broz /* 150814f27939SMilan Broz * Otherwise keep thread (if running) and config, 150914f27939SMilan Broz * but flush possible ongoing bios in thread. 151014f27939SMilan Broz */ 151114f27939SMilan Broz loop_flush(lo); 151214f27939SMilan Broz } 151396c58655SDavid Woodhouse 151414f27939SMilan Broz out: 1515f85221ddSIngo Molnar mutex_unlock(&lo->lo_ctl_mutex); 1516ffcd7dcaSAlexander Beregalov out_unlocked: 15171da177e4SLinus Torvalds return 0; 15181da177e4SLinus Torvalds } 15191da177e4SLinus Torvalds 152083d5cde4SAlexey Dobriyan static const struct block_device_operations lo_fops = { 15211da177e4SLinus Torvalds .owner = THIS_MODULE, 1522bb214884SAl Viro .open = lo_open, 1523bb214884SAl Viro .release = lo_release, 1524bb214884SAl Viro .ioctl = lo_ioctl, 1525863d5b82SDavid Howells #ifdef CONFIG_COMPAT 1526bb214884SAl Viro .compat_ioctl = lo_compat_ioctl, 1527863d5b82SDavid Howells #endif 15281da177e4SLinus Torvalds }; 15291da177e4SLinus Torvalds 15301da177e4SLinus Torvalds /* 15311da177e4SLinus Torvalds * And now the modules code and kernel interface. 15321da177e4SLinus Torvalds */ 153373285082SKen Chen static int max_loop; 1534ac04fee0SNamhyung Kim module_param(max_loop, int, S_IRUGO); 1535a47653fcSKen Chen MODULE_PARM_DESC(max_loop, "Maximum number of loop devices"); 1536ac04fee0SNamhyung Kim module_param(max_part, int, S_IRUGO); 1537476a4813SLaurent Vivier MODULE_PARM_DESC(max_part, "Maximum number of partitions per loop device"); 15381da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 15391da177e4SLinus Torvalds MODULE_ALIAS_BLOCKDEV_MAJOR(LOOP_MAJOR); 15401da177e4SLinus Torvalds 15411da177e4SLinus Torvalds int loop_register_transfer(struct loop_func_table *funcs) 15421da177e4SLinus Torvalds { 15431da177e4SLinus Torvalds unsigned int n = funcs->number; 15441da177e4SLinus Torvalds 15451da177e4SLinus Torvalds if (n >= MAX_LO_CRYPT || xfer_funcs[n]) 15461da177e4SLinus Torvalds return -EINVAL; 15471da177e4SLinus Torvalds xfer_funcs[n] = funcs; 15481da177e4SLinus Torvalds return 0; 15491da177e4SLinus Torvalds } 15501da177e4SLinus Torvalds 155134dd82afSKay Sievers static int unregister_transfer_cb(int id, void *ptr, void *data) 155234dd82afSKay Sievers { 155334dd82afSKay Sievers struct loop_device *lo = ptr; 155434dd82afSKay Sievers struct loop_func_table *xfer = data; 155534dd82afSKay Sievers 155634dd82afSKay Sievers mutex_lock(&lo->lo_ctl_mutex); 155734dd82afSKay Sievers if (lo->lo_encryption == xfer) 155834dd82afSKay Sievers loop_release_xfer(lo); 155934dd82afSKay Sievers mutex_unlock(&lo->lo_ctl_mutex); 156034dd82afSKay Sievers return 0; 156134dd82afSKay Sievers } 156234dd82afSKay Sievers 15631da177e4SLinus Torvalds int loop_unregister_transfer(int number) 15641da177e4SLinus Torvalds { 15651da177e4SLinus Torvalds unsigned int n = number; 15661da177e4SLinus Torvalds struct loop_func_table *xfer; 15671da177e4SLinus Torvalds 15681da177e4SLinus Torvalds if (n == 0 || n >= MAX_LO_CRYPT || (xfer = xfer_funcs[n]) == NULL) 15691da177e4SLinus Torvalds return -EINVAL; 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds xfer_funcs[n] = NULL; 157234dd82afSKay Sievers idr_for_each(&loop_index_idr, &unregister_transfer_cb, xfer); 15731da177e4SLinus Torvalds return 0; 15741da177e4SLinus Torvalds } 15751da177e4SLinus Torvalds 15761da177e4SLinus Torvalds EXPORT_SYMBOL(loop_register_transfer); 15771da177e4SLinus Torvalds EXPORT_SYMBOL(loop_unregister_transfer); 15781da177e4SLinus Torvalds 157934dd82afSKay Sievers static int loop_add(struct loop_device **l, int i) 15801da177e4SLinus Torvalds { 158173285082SKen Chen struct loop_device *lo; 158273285082SKen Chen struct gendisk *disk; 158334dd82afSKay Sievers int err; 15841da177e4SLinus Torvalds 158573285082SKen Chen lo = kzalloc(sizeof(*lo), GFP_KERNEL); 158634dd82afSKay Sievers if (!lo) { 158734dd82afSKay Sievers err = -ENOMEM; 158873285082SKen Chen goto out; 158934dd82afSKay Sievers } 159034dd82afSKay Sievers 159134dd82afSKay Sievers err = idr_pre_get(&loop_index_idr, GFP_KERNEL); 159234dd82afSKay Sievers if (err < 0) 159334dd82afSKay Sievers goto out_free_dev; 159434dd82afSKay Sievers 159534dd82afSKay Sievers if (i >= 0) { 159634dd82afSKay Sievers int m; 159734dd82afSKay Sievers 159834dd82afSKay Sievers /* create specific i in the index */ 159934dd82afSKay Sievers err = idr_get_new_above(&loop_index_idr, lo, i, &m); 160034dd82afSKay Sievers if (err >= 0 && i != m) { 160134dd82afSKay Sievers idr_remove(&loop_index_idr, m); 160234dd82afSKay Sievers err = -EEXIST; 160334dd82afSKay Sievers } 1604770fe30aSKay Sievers } else if (i == -1) { 1605770fe30aSKay Sievers int m; 1606770fe30aSKay Sievers 1607770fe30aSKay Sievers /* get next free nr */ 1608770fe30aSKay Sievers err = idr_get_new(&loop_index_idr, lo, &m); 1609770fe30aSKay Sievers if (err >= 0) 1610770fe30aSKay Sievers i = m; 161134dd82afSKay Sievers } else { 161234dd82afSKay Sievers err = -EINVAL; 161334dd82afSKay Sievers } 161434dd82afSKay Sievers if (err < 0) 161534dd82afSKay Sievers goto out_free_dev; 16161da177e4SLinus Torvalds 16171da177e4SLinus Torvalds lo->lo_queue = blk_alloc_queue(GFP_KERNEL); 16181da177e4SLinus Torvalds if (!lo->lo_queue) 161973285082SKen Chen goto out_free_dev; 162073285082SKen Chen 1621476a4813SLaurent Vivier disk = lo->lo_disk = alloc_disk(1 << part_shift); 162273285082SKen Chen if (!disk) 162373285082SKen Chen goto out_free_queue; 162473285082SKen Chen 1625e03c8dd1SKay Sievers /* 1626e03c8dd1SKay Sievers * Disable partition scanning by default. The in-kernel partition 1627e03c8dd1SKay Sievers * scanning can be requested individually per-device during its 1628e03c8dd1SKay Sievers * setup. Userspace can always add and remove partitions from all 1629e03c8dd1SKay Sievers * devices. The needed partition minors are allocated from the 1630e03c8dd1SKay Sievers * extended minor space, the main loop device numbers will continue 1631e03c8dd1SKay Sievers * to match the loop minors, regardless of the number of partitions 1632e03c8dd1SKay Sievers * used. 1633e03c8dd1SKay Sievers * 1634e03c8dd1SKay Sievers * If max_part is given, partition scanning is globally enabled for 1635e03c8dd1SKay Sievers * all loop devices. The minors for the main loop devices will be 1636e03c8dd1SKay Sievers * multiples of max_part. 1637e03c8dd1SKay Sievers * 1638e03c8dd1SKay Sievers * Note: Global-for-all-devices, set-only-at-init, read-only module 1639e03c8dd1SKay Sievers * parameteters like 'max_loop' and 'max_part' make things needlessly 1640e03c8dd1SKay Sievers * complicated, are too static, inflexible and may surprise 1641e03c8dd1SKay Sievers * userspace tools. Parameters like this in general should be avoided. 1642e03c8dd1SKay Sievers */ 1643e03c8dd1SKay Sievers if (!part_shift) 1644e03c8dd1SKay Sievers disk->flags |= GENHD_FL_NO_PART_SCAN; 1645e03c8dd1SKay Sievers disk->flags |= GENHD_FL_EXT_DEVT; 1646f85221ddSIngo Molnar mutex_init(&lo->lo_ctl_mutex); 16471da177e4SLinus Torvalds lo->lo_number = i; 16486c997918SSerge E. Hallyn lo->lo_thread = NULL; 16496c997918SSerge E. Hallyn init_waitqueue_head(&lo->lo_event); 16501da177e4SLinus Torvalds spin_lock_init(&lo->lo_lock); 16511da177e4SLinus Torvalds disk->major = LOOP_MAJOR; 1652476a4813SLaurent Vivier disk->first_minor = i << part_shift; 16531da177e4SLinus Torvalds disk->fops = &lo_fops; 16541da177e4SLinus Torvalds disk->private_data = lo; 16551da177e4SLinus Torvalds disk->queue = lo->lo_queue; 165673285082SKen Chen sprintf(disk->disk_name, "loop%d", i); 165734dd82afSKay Sievers add_disk(disk); 165834dd82afSKay Sievers *l = lo; 165934dd82afSKay Sievers return lo->lo_number; 166073285082SKen Chen 166173285082SKen Chen out_free_queue: 166273285082SKen Chen blk_cleanup_queue(lo->lo_queue); 166373285082SKen Chen out_free_dev: 166473285082SKen Chen kfree(lo); 166573285082SKen Chen out: 166634dd82afSKay Sievers return err; 16671da177e4SLinus Torvalds } 16681da177e4SLinus Torvalds 166934dd82afSKay Sievers static void loop_remove(struct loop_device *lo) 167073285082SKen Chen { 167134dd82afSKay Sievers del_gendisk(lo->lo_disk); 167273285082SKen Chen blk_cleanup_queue(lo->lo_queue); 167373285082SKen Chen put_disk(lo->lo_disk); 167473285082SKen Chen kfree(lo); 167573285082SKen Chen } 167673285082SKen Chen 1677770fe30aSKay Sievers static int find_free_cb(int id, void *ptr, void *data) 1678770fe30aSKay Sievers { 1679770fe30aSKay Sievers struct loop_device *lo = ptr; 1680770fe30aSKay Sievers struct loop_device **l = data; 1681770fe30aSKay Sievers 1682770fe30aSKay Sievers if (lo->lo_state == Lo_unbound) { 1683770fe30aSKay Sievers *l = lo; 1684770fe30aSKay Sievers return 1; 1685770fe30aSKay Sievers } 1686770fe30aSKay Sievers return 0; 1687770fe30aSKay Sievers } 1688770fe30aSKay Sievers 168934dd82afSKay Sievers static int loop_lookup(struct loop_device **l, int i) 1690a47653fcSKen Chen { 1691a47653fcSKen Chen struct loop_device *lo; 169234dd82afSKay Sievers int ret = -ENODEV; 1693a47653fcSKen Chen 1694770fe30aSKay Sievers if (i < 0) { 1695770fe30aSKay Sievers int err; 1696770fe30aSKay Sievers 1697770fe30aSKay Sievers err = idr_for_each(&loop_index_idr, &find_free_cb, &lo); 1698770fe30aSKay Sievers if (err == 1) { 1699770fe30aSKay Sievers *l = lo; 1700770fe30aSKay Sievers ret = lo->lo_number; 1701770fe30aSKay Sievers } 1702770fe30aSKay Sievers goto out; 1703a47653fcSKen Chen } 1704a47653fcSKen Chen 1705770fe30aSKay Sievers /* lookup and return a specific i */ 170634dd82afSKay Sievers lo = idr_find(&loop_index_idr, i); 1707a47653fcSKen Chen if (lo) { 170834dd82afSKay Sievers *l = lo; 170934dd82afSKay Sievers ret = lo->lo_number; 1710a47653fcSKen Chen } 1711770fe30aSKay Sievers out: 171234dd82afSKay Sievers return ret; 1713a47653fcSKen Chen } 1714a47653fcSKen Chen 171573285082SKen Chen static struct kobject *loop_probe(dev_t dev, int *part, void *data) 171673285082SKen Chen { 1717705962ccSAl Viro struct loop_device *lo; 171807002e99SAl Viro struct kobject *kobj; 171934dd82afSKay Sievers int err; 172073285082SKen Chen 172134dd82afSKay Sievers mutex_lock(&loop_index_mutex); 172234dd82afSKay Sievers err = loop_lookup(&lo, MINOR(dev) >> part_shift); 172334dd82afSKay Sievers if (err < 0) 172434dd82afSKay Sievers err = loop_add(&lo, MINOR(dev) >> part_shift); 172534dd82afSKay Sievers if (err < 0) 172634dd82afSKay Sievers kobj = ERR_PTR(err); 172734dd82afSKay Sievers else 172834dd82afSKay Sievers kobj = get_disk(lo->lo_disk); 172934dd82afSKay Sievers mutex_unlock(&loop_index_mutex); 173073285082SKen Chen 173173285082SKen Chen *part = 0; 173207002e99SAl Viro return kobj; 173373285082SKen Chen } 173473285082SKen Chen 1735770fe30aSKay Sievers static long loop_control_ioctl(struct file *file, unsigned int cmd, 1736770fe30aSKay Sievers unsigned long parm) 1737770fe30aSKay Sievers { 1738770fe30aSKay Sievers struct loop_device *lo; 1739770fe30aSKay Sievers int ret = -ENOSYS; 1740770fe30aSKay Sievers 1741770fe30aSKay Sievers mutex_lock(&loop_index_mutex); 1742770fe30aSKay Sievers switch (cmd) { 1743770fe30aSKay Sievers case LOOP_CTL_ADD: 1744770fe30aSKay Sievers ret = loop_lookup(&lo, parm); 1745770fe30aSKay Sievers if (ret >= 0) { 1746770fe30aSKay Sievers ret = -EEXIST; 1747770fe30aSKay Sievers break; 1748770fe30aSKay Sievers } 1749770fe30aSKay Sievers ret = loop_add(&lo, parm); 1750770fe30aSKay Sievers break; 1751770fe30aSKay Sievers case LOOP_CTL_REMOVE: 1752770fe30aSKay Sievers ret = loop_lookup(&lo, parm); 1753770fe30aSKay Sievers if (ret < 0) 1754770fe30aSKay Sievers break; 1755770fe30aSKay Sievers mutex_lock(&lo->lo_ctl_mutex); 1756770fe30aSKay Sievers if (lo->lo_state != Lo_unbound) { 1757770fe30aSKay Sievers ret = -EBUSY; 1758770fe30aSKay Sievers mutex_unlock(&lo->lo_ctl_mutex); 1759770fe30aSKay Sievers break; 1760770fe30aSKay Sievers } 1761770fe30aSKay Sievers if (lo->lo_refcnt > 0) { 1762770fe30aSKay Sievers ret = -EBUSY; 1763770fe30aSKay Sievers mutex_unlock(&lo->lo_ctl_mutex); 1764770fe30aSKay Sievers break; 1765770fe30aSKay Sievers } 1766770fe30aSKay Sievers lo->lo_disk->private_data = NULL; 1767770fe30aSKay Sievers mutex_unlock(&lo->lo_ctl_mutex); 1768770fe30aSKay Sievers idr_remove(&loop_index_idr, lo->lo_number); 1769770fe30aSKay Sievers loop_remove(lo); 1770770fe30aSKay Sievers break; 1771770fe30aSKay Sievers case LOOP_CTL_GET_FREE: 1772770fe30aSKay Sievers ret = loop_lookup(&lo, -1); 1773770fe30aSKay Sievers if (ret >= 0) 1774770fe30aSKay Sievers break; 1775770fe30aSKay Sievers ret = loop_add(&lo, -1); 1776770fe30aSKay Sievers } 1777770fe30aSKay Sievers mutex_unlock(&loop_index_mutex); 1778770fe30aSKay Sievers 1779770fe30aSKay Sievers return ret; 1780770fe30aSKay Sievers } 1781770fe30aSKay Sievers 1782770fe30aSKay Sievers static const struct file_operations loop_ctl_fops = { 1783770fe30aSKay Sievers .open = nonseekable_open, 1784770fe30aSKay Sievers .unlocked_ioctl = loop_control_ioctl, 1785770fe30aSKay Sievers .compat_ioctl = loop_control_ioctl, 1786770fe30aSKay Sievers .owner = THIS_MODULE, 1787770fe30aSKay Sievers .llseek = noop_llseek, 1788770fe30aSKay Sievers }; 1789770fe30aSKay Sievers 1790770fe30aSKay Sievers static struct miscdevice loop_misc = { 1791770fe30aSKay Sievers .minor = LOOP_CTRL_MINOR, 1792770fe30aSKay Sievers .name = "loop-control", 1793770fe30aSKay Sievers .fops = &loop_ctl_fops, 1794770fe30aSKay Sievers }; 1795770fe30aSKay Sievers 1796770fe30aSKay Sievers MODULE_ALIAS_MISCDEV(LOOP_CTRL_MINOR); 1797770fe30aSKay Sievers MODULE_ALIAS("devname:loop-control"); 1798770fe30aSKay Sievers 179973285082SKen Chen static int __init loop_init(void) 180073285082SKen Chen { 1801a47653fcSKen Chen int i, nr; 1802a47653fcSKen Chen unsigned long range; 180334dd82afSKay Sievers struct loop_device *lo; 1804770fe30aSKay Sievers int err; 1805a47653fcSKen Chen 1806770fe30aSKay Sievers err = misc_register(&loop_misc); 1807770fe30aSKay Sievers if (err < 0) 1808770fe30aSKay Sievers return err; 1809476a4813SLaurent Vivier 1810476a4813SLaurent Vivier part_shift = 0; 1811ac04fee0SNamhyung Kim if (max_part > 0) { 1812476a4813SLaurent Vivier part_shift = fls(max_part); 1813476a4813SLaurent Vivier 1814ac04fee0SNamhyung Kim /* 1815ac04fee0SNamhyung Kim * Adjust max_part according to part_shift as it is exported 1816ac04fee0SNamhyung Kim * to user space so that user can decide correct minor number 1817ac04fee0SNamhyung Kim * if [s]he want to create more devices. 1818ac04fee0SNamhyung Kim * 1819ac04fee0SNamhyung Kim * Note that -1 is required because partition 0 is reserved 1820ac04fee0SNamhyung Kim * for the whole disk. 1821ac04fee0SNamhyung Kim */ 1822ac04fee0SNamhyung Kim max_part = (1UL << part_shift) - 1; 1823ac04fee0SNamhyung Kim } 1824ac04fee0SNamhyung Kim 182578f4bb36SNamhyung Kim if ((1UL << part_shift) > DISK_MAX_PARTS) 182678f4bb36SNamhyung Kim return -EINVAL; 182778f4bb36SNamhyung Kim 1828476a4813SLaurent Vivier if (max_loop > 1UL << (MINORBITS - part_shift)) 1829a47653fcSKen Chen return -EINVAL; 183073285082SKen Chen 1831d134b00bSKay Sievers /* 1832d134b00bSKay Sievers * If max_loop is specified, create that many devices upfront. 1833d134b00bSKay Sievers * This also becomes a hard limit. If max_loop is not specified, 1834d134b00bSKay Sievers * create CONFIG_BLK_DEV_LOOP_MIN_COUNT loop devices at module 1835d134b00bSKay Sievers * init time. Loop devices can be requested on-demand with the 1836d134b00bSKay Sievers * /dev/loop-control interface, or be instantiated by accessing 1837d134b00bSKay Sievers * a 'dead' device node. 1838d134b00bSKay Sievers */ 183973285082SKen Chen if (max_loop) { 1840a47653fcSKen Chen nr = max_loop; 1841a1c15c59SNamhyung Kim range = max_loop << part_shift; 1842a47653fcSKen Chen } else { 1843d134b00bSKay Sievers nr = CONFIG_BLK_DEV_LOOP_MIN_COUNT; 1844a1c15c59SNamhyung Kim range = 1UL << MINORBITS; 184573285082SKen Chen } 1846a47653fcSKen Chen 1847a47653fcSKen Chen if (register_blkdev(LOOP_MAJOR, "loop")) 1848a47653fcSKen Chen return -EIO; 1849a47653fcSKen Chen 1850a47653fcSKen Chen blk_register_region(MKDEV(LOOP_MAJOR, 0), range, 1851a47653fcSKen Chen THIS_MODULE, loop_probe, NULL, NULL); 1852a47653fcSKen Chen 1853d134b00bSKay Sievers /* pre-create number of devices given by config or max_loop */ 185434dd82afSKay Sievers mutex_lock(&loop_index_mutex); 185534dd82afSKay Sievers for (i = 0; i < nr; i++) 185634dd82afSKay Sievers loop_add(&lo, i); 185734dd82afSKay Sievers mutex_unlock(&loop_index_mutex); 185834dd82afSKay Sievers 185973285082SKen Chen printk(KERN_INFO "loop: module loaded\n"); 18601da177e4SLinus Torvalds return 0; 186134dd82afSKay Sievers } 1862a47653fcSKen Chen 186334dd82afSKay Sievers static int loop_exit_cb(int id, void *ptr, void *data) 186434dd82afSKay Sievers { 186534dd82afSKay Sievers struct loop_device *lo = ptr; 1866a47653fcSKen Chen 186734dd82afSKay Sievers loop_remove(lo); 186834dd82afSKay Sievers return 0; 18691da177e4SLinus Torvalds } 18701da177e4SLinus Torvalds 187173285082SKen Chen static void __exit loop_exit(void) 18721da177e4SLinus Torvalds { 1873a47653fcSKen Chen unsigned long range; 18741da177e4SLinus Torvalds 1875a1c15c59SNamhyung Kim range = max_loop ? max_loop << part_shift : 1UL << MINORBITS; 1876a47653fcSKen Chen 187734dd82afSKay Sievers idr_for_each(&loop_index_idr, &loop_exit_cb, NULL); 187834dd82afSKay Sievers idr_remove_all(&loop_index_idr); 187934dd82afSKay Sievers idr_destroy(&loop_index_idr); 188073285082SKen Chen 1881a47653fcSKen Chen blk_unregister_region(MKDEV(LOOP_MAJOR, 0), range); 188200d59405SAkinobu Mita unregister_blkdev(LOOP_MAJOR, "loop"); 1883770fe30aSKay Sievers 1884770fe30aSKay Sievers misc_deregister(&loop_misc); 18851da177e4SLinus Torvalds } 18861da177e4SLinus Torvalds 18871da177e4SLinus Torvalds module_init(loop_init); 18881da177e4SLinus Torvalds module_exit(loop_exit); 18891da177e4SLinus Torvalds 18901da177e4SLinus Torvalds #ifndef MODULE 18911da177e4SLinus Torvalds static int __init max_loop_setup(char *str) 18921da177e4SLinus Torvalds { 18931da177e4SLinus Torvalds max_loop = simple_strtol(str, NULL, 0); 18941da177e4SLinus Torvalds return 1; 18951da177e4SLinus Torvalds } 18961da177e4SLinus Torvalds 18971da177e4SLinus Torvalds __setup("max_loop=", max_loop_setup); 18981da177e4SLinus Torvalds #endif 1899