LCOV - code coverage report
Current view: top level - drivers/block - loop.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 72 870 8.3 %
Date: 2020-09-30 20:25:40 Functions: 5 74 6.8 %
Branches: 22 547 4.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  *  linux/drivers/block/loop.c
       3                 :            :  *
       4                 :            :  *  Written by Theodore Ts'o, 3/29/93
       5                 :            :  *
       6                 :            :  * Copyright 1993 by Theodore Ts'o.  Redistribution of this file is
       7                 :            :  * permitted under the GNU General Public License.
       8                 :            :  *
       9                 :            :  * DES encryption plus some minor changes by Werner Almesberger, 30-MAY-1993
      10                 :            :  * more DES encryption plus IDEA encryption by Nicholas J. Leon, June 20, 1996
      11                 :            :  *
      12                 :            :  * Modularized and updated for 1.1.16 kernel - Mitch Dsouza 28th May 1994
      13                 :            :  * Adapted for 1.3.59 kernel - Andries Brouwer, 1 Feb 1996
      14                 :            :  *
      15                 :            :  * Fixed do_loop_request() re-entrancy - Vincent.Renardias@waw.com Mar 20, 1997
      16                 :            :  *
      17                 :            :  * Added devfs support - Richard Gooch <rgooch@atnf.csiro.au> 16-Jan-1998
      18                 :            :  *
      19                 :            :  * Handle sparse backing files correctly - Kenn Humborg, Jun 28, 1998
      20                 :            :  *
      21                 :            :  * Loadable modules and other fixes by AK, 1998
      22                 :            :  *
      23                 :            :  * Make real block number available to downstream transfer functions, enables
      24                 :            :  * CBC (and relatives) mode encryption requiring unique IVs per data block.
      25                 :            :  * Reed H. Petty, rhp@draper.net
      26                 :            :  *
      27                 :            :  * Maximum number of loop devices now dynamic via max_loop module parameter.
      28                 :            :  * Russell Kroll <rkroll@exploits.org> 19990701
      29                 :            :  *
      30                 :            :  * Maximum number of loop devices when compiled-in now selectable by passing
      31                 :            :  * max_loop=<1-255> to the kernel on boot.
      32                 :            :  * Erik I. Bolsø, <eriki@himolde.no>, Oct 31, 1999
      33                 :            :  *
      34                 :            :  * Completely rewrite request handling to be make_request_fn style and
      35                 :            :  * non blocking, pushing work to a helper thread. Lots of fixes from
      36                 :            :  * Al Viro too.
      37                 :            :  * Jens Axboe <axboe@suse.de>, Nov 2000
      38                 :            :  *
      39                 :            :  * Support up to 256 loop devices
      40                 :            :  * Heinz Mauelshagen <mge@sistina.com>, Feb 2002
      41                 :            :  *
      42                 :            :  * Support for falling back on the write file operation when the address space
      43                 :            :  * operations write_begin is not available on the backing filesystem.
      44                 :            :  * Anton Altaparmakov, 16 Feb 2005
      45                 :            :  *
      46                 :            :  * Still To Fix:
      47                 :            :  * - Advisory locking is ignored here.
      48                 :            :  * - Should use an own CAP_* category instead of CAP_SYS_ADMIN
      49                 :            :  *
      50                 :            :  */
      51                 :            : 
      52                 :            : #include <linux/module.h>
      53                 :            : #include <linux/moduleparam.h>
      54                 :            : #include <linux/sched.h>
      55                 :            : #include <linux/fs.h>
      56                 :            : #include <linux/file.h>
      57                 :            : #include <linux/stat.h>
      58                 :            : #include <linux/errno.h>
      59                 :            : #include <linux/major.h>
      60                 :            : #include <linux/wait.h>
      61                 :            : #include <linux/blkdev.h>
      62                 :            : #include <linux/blkpg.h>
      63                 :            : #include <linux/init.h>
      64                 :            : #include <linux/swap.h>
      65                 :            : #include <linux/slab.h>
      66                 :            : #include <linux/compat.h>
      67                 :            : #include <linux/suspend.h>
      68                 :            : #include <linux/freezer.h>
      69                 :            : #include <linux/mutex.h>
      70                 :            : #include <linux/writeback.h>
      71                 :            : #include <linux/completion.h>
      72                 :            : #include <linux/highmem.h>
      73                 :            : #include <linux/kthread.h>
      74                 :            : #include <linux/splice.h>
      75                 :            : #include <linux/sysfs.h>
      76                 :            : #include <linux/miscdevice.h>
      77                 :            : #include <linux/falloc.h>
      78                 :            : #include <linux/uio.h>
      79                 :            : #include <linux/ioprio.h>
      80                 :            : #include <linux/blk-cgroup.h>
      81                 :            : 
      82                 :            : #include "loop.h"
      83                 :            : 
      84                 :            : #include <linux/uaccess.h>
      85                 :            : 
      86                 :            : static DEFINE_IDR(loop_index_idr);
      87                 :            : static DEFINE_MUTEX(loop_ctl_mutex);
      88                 :            : 
      89                 :            : static int max_part;
      90                 :            : static int part_shift;
      91                 :            : 
      92                 :          0 : static int transfer_xor(struct loop_device *lo, int cmd,
      93                 :            :                         struct page *raw_page, unsigned raw_off,
      94                 :            :                         struct page *loop_page, unsigned loop_off,
      95                 :            :                         int size, sector_t real_block)
      96                 :            : {
      97                 :          0 :         char *raw_buf = kmap_atomic(raw_page) + raw_off;
      98                 :          0 :         char *loop_buf = kmap_atomic(loop_page) + loop_off;
      99                 :            :         char *in, *out, *key;
     100                 :            :         int i, keysize;
     101                 :            : 
     102         [ #  # ]:          0 :         if (cmd == READ) {
     103                 :            :                 in = raw_buf;
     104                 :            :                 out = loop_buf;
     105                 :            :         } else {
     106                 :            :                 in = loop_buf;
     107                 :            :                 out = raw_buf;
     108                 :            :         }
     109                 :            : 
     110                 :          0 :         key = lo->lo_encrypt_key;
     111                 :          0 :         keysize = lo->lo_encrypt_key_size;
     112         [ #  # ]:          0 :         for (i = 0; i < size; i++)
     113                 :          0 :                 *out++ = *in++ ^ key[(i & 511) % keysize];
     114                 :            : 
     115                 :            :         kunmap_atomic(loop_buf);
     116                 :            :         kunmap_atomic(raw_buf);
     117                 :          0 :         cond_resched();
     118                 :          0 :         return 0;
     119                 :            : }
     120                 :            : 
     121                 :          0 : static int xor_init(struct loop_device *lo, const struct loop_info64 *info)
     122                 :            : {
     123         [ #  # ]:          0 :         if (unlikely(info->lo_encrypt_key_size <= 0))
     124                 :            :                 return -EINVAL;
     125                 :          0 :         return 0;
     126                 :            : }
     127                 :            : 
     128                 :            : static struct loop_func_table none_funcs = {
     129                 :            :         .number = LO_CRYPT_NONE,
     130                 :            : }; 
     131                 :            : 
     132                 :            : static struct loop_func_table xor_funcs = {
     133                 :            :         .number = LO_CRYPT_XOR,
     134                 :            :         .transfer = transfer_xor,
     135                 :            :         .init = xor_init
     136                 :            : }; 
     137                 :            : 
     138                 :            : /* xfer_funcs[0] is special - its release function is never called */
     139                 :            : static struct loop_func_table *xfer_funcs[MAX_LO_CRYPT] = {
     140                 :            :         &none_funcs,
     141                 :            :         &xor_funcs
     142                 :            : };
     143                 :            : 
     144                 :          0 : static loff_t get_size(loff_t offset, loff_t sizelimit, struct file *file)
     145                 :            : {
     146                 :            :         loff_t loopsize;
     147                 :            : 
     148                 :            :         /* Compute loopsize in bytes */
     149                 :          0 :         loopsize = i_size_read(file->f_mapping->host);
     150         [ #  # ]:          0 :         if (offset > 0)
     151                 :          0 :                 loopsize -= offset;
     152                 :            :         /* offset is beyond i_size, weird but possible */
     153         [ #  # ]:          0 :         if (loopsize < 0)
     154                 :            :                 return 0;
     155                 :            : 
     156         [ #  # ]:          0 :         if (sizelimit > 0 && sizelimit < loopsize)
     157                 :            :                 loopsize = sizelimit;
     158                 :            :         /*
     159                 :            :          * Unfortunately, if we want to do I/O on the device,
     160                 :            :          * the number of 512-byte sectors has to fit into a sector_t.
     161                 :            :          */
     162                 :          0 :         return loopsize >> 9;
     163                 :            : }
     164                 :            : 
     165                 :            : static loff_t get_loop_size(struct loop_device *lo, struct file *file)
     166                 :            : {
     167                 :          0 :         return get_size(lo->lo_offset, lo->lo_sizelimit, file);
     168                 :            : }
     169                 :            : 
     170                 :          0 : static void __loop_update_dio(struct loop_device *lo, bool dio)
     171                 :            : {
     172                 :          0 :         struct file *file = lo->lo_backing_file;
     173                 :          0 :         struct address_space *mapping = file->f_mapping;
     174                 :          0 :         struct inode *inode = mapping->host;
     175                 :            :         unsigned short sb_bsize = 0;
     176                 :            :         unsigned dio_align = 0;
     177                 :            :         bool use_dio;
     178                 :            : 
     179         [ #  # ]:          0 :         if (inode->i_sb->s_bdev) {
     180                 :          0 :                 sb_bsize = bdev_logical_block_size(inode->i_sb->s_bdev);
     181                 :          0 :                 dio_align = sb_bsize - 1;
     182                 :            :         }
     183                 :            : 
     184                 :            :         /*
     185                 :            :          * We support direct I/O only if lo_offset is aligned with the
     186                 :            :          * logical I/O size of backing device, and the logical block
     187                 :            :          * size of loop is bigger than the backing device's and the loop
     188                 :            :          * needn't transform transfer.
     189                 :            :          *
     190                 :            :          * TODO: the above condition may be loosed in the future, and
     191                 :            :          * direct I/O may be switched runtime at that time because most
     192                 :            :          * of requests in sane applications should be PAGE_SIZE aligned
     193                 :            :          */
     194         [ #  # ]:          0 :         if (dio) {
     195   [ #  #  #  # ]:          0 :                 if (queue_logical_block_size(lo->lo_queue) >= sb_bsize &&
     196         [ #  # ]:          0 :                                 !(lo->lo_offset & dio_align) &&
     197         [ #  # ]:          0 :                                 mapping->a_ops->direct_IO &&
     198                 :          0 :                                 !lo->transfer)
     199                 :            :                         use_dio = true;
     200                 :            :                 else
     201                 :            :                         use_dio = false;
     202                 :            :         } else {
     203                 :            :                 use_dio = false;
     204                 :            :         }
     205                 :            : 
     206         [ #  # ]:          0 :         if (lo->use_dio == use_dio)
     207                 :          0 :                 return;
     208                 :            : 
     209                 :            :         /* flush dirty pages before changing direct IO */
     210                 :          0 :         vfs_fsync(file, 0);
     211                 :            : 
     212                 :            :         /*
     213                 :            :          * The flag of LO_FLAGS_DIRECT_IO is handled similarly with
     214                 :            :          * LO_FLAGS_READ_ONLY, both are set from kernel, and losetup
     215                 :            :          * will get updated by ioctl(LOOP_GET_STATUS)
     216                 :            :          */
     217                 :          0 :         blk_mq_freeze_queue(lo->lo_queue);
     218                 :          0 :         lo->use_dio = use_dio;
     219         [ #  # ]:          0 :         if (use_dio) {
     220                 :          0 :                 blk_queue_flag_clear(QUEUE_FLAG_NOMERGES, lo->lo_queue);
     221                 :          0 :                 lo->lo_flags |= LO_FLAGS_DIRECT_IO;
     222                 :            :         } else {
     223                 :          0 :                 blk_queue_flag_set(QUEUE_FLAG_NOMERGES, lo->lo_queue);
     224                 :          0 :                 lo->lo_flags &= ~LO_FLAGS_DIRECT_IO;
     225                 :            :         }
     226                 :          0 :         blk_mq_unfreeze_queue(lo->lo_queue);
     227                 :            : }
     228                 :            : 
     229                 :            : static int
     230                 :          0 : figure_loop_size(struct loop_device *lo, loff_t offset, loff_t sizelimit)
     231                 :            : {
     232                 :          0 :         loff_t size = get_size(offset, sizelimit, lo->lo_backing_file);
     233                 :          0 :         sector_t x = (sector_t)size;
     234                 :          0 :         struct block_device *bdev = lo->lo_device;
     235                 :            : 
     236         [ #  # ]:          0 :         if (unlikely((loff_t)x != size))
     237                 :            :                 return -EFBIG;
     238         [ #  # ]:          0 :         if (lo->lo_offset != offset)
     239                 :          0 :                 lo->lo_offset = offset;
     240         [ #  # ]:          0 :         if (lo->lo_sizelimit != sizelimit)
     241                 :          0 :                 lo->lo_sizelimit = sizelimit;
     242                 :          0 :         set_capacity(lo->lo_disk, x);
     243                 :          0 :         bd_set_size(bdev, (loff_t)get_capacity(bdev->bd_disk) << 9);
     244                 :            :         /* let user-space know about the new size */
     245                 :          0 :         kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);
     246                 :          0 :         return 0;
     247                 :            : }
     248                 :            : 
     249                 :            : static inline int
     250                 :          0 : lo_do_transfer(struct loop_device *lo, int cmd,
     251                 :            :                struct page *rpage, unsigned roffs,
     252                 :            :                struct page *lpage, unsigned loffs,
     253                 :            :                int size, sector_t rblock)
     254                 :            : {
     255                 :            :         int ret;
     256                 :            : 
     257                 :          0 :         ret = lo->transfer(lo, cmd, rpage, roffs, lpage, loffs, size, rblock);
     258         [ #  # ]:          0 :         if (likely(!ret))
     259                 :            :                 return 0;
     260                 :            : 
     261         [ #  # ]:          0 :         printk_ratelimited(KERN_ERR
     262                 :            :                 "loop: Transfer error at byte offset %llu, length %i.\n",
     263                 :            :                 (unsigned long long)rblock << 9, size);
     264                 :          0 :         return ret;
     265                 :            : }
     266                 :            : 
     267                 :          0 : static int lo_write_bvec(struct file *file, struct bio_vec *bvec, loff_t *ppos)
     268                 :            : {
     269                 :            :         struct iov_iter i;
     270                 :            :         ssize_t bw;
     271                 :            : 
     272                 :          0 :         iov_iter_bvec(&i, WRITE, bvec, 1, bvec->bv_len);
     273                 :            : 
     274                 :          0 :         file_start_write(file);
     275                 :          0 :         bw = vfs_iter_write(file, &i, ppos, 0);
     276                 :          0 :         file_end_write(file);
     277                 :            : 
     278         [ #  # ]:          0 :         if (likely(bw ==  bvec->bv_len))
     279                 :            :                 return 0;
     280                 :            : 
     281         [ #  # ]:          0 :         printk_ratelimited(KERN_ERR
     282                 :            :                 "loop: Write error at byte offset %llu, length %i.\n",
     283                 :            :                 (unsigned long long)*ppos, bvec->bv_len);
     284         [ #  # ]:          0 :         if (bw >= 0)
     285                 :            :                 bw = -EIO;
     286                 :          0 :         return bw;
     287                 :            : }
     288                 :            : 
     289                 :          0 : static int lo_write_simple(struct loop_device *lo, struct request *rq,
     290                 :            :                 loff_t pos)
     291                 :            : {
     292                 :            :         struct bio_vec bvec;
     293                 :            :         struct req_iterator iter;
     294                 :            :         int ret = 0;
     295                 :            : 
     296   [ #  #  #  #  :          0 :         rq_for_each_segment(bvec, rq, iter) {
                   #  # ]
     297                 :          0 :                 ret = lo_write_bvec(lo->lo_backing_file, &bvec, &pos);
     298         [ #  # ]:          0 :                 if (ret < 0)
     299                 :            :                         break;
     300                 :          0 :                 cond_resched();
     301                 :            :         }
     302                 :            : 
     303                 :          0 :         return ret;
     304                 :            : }
     305                 :            : 
     306                 :            : /*
     307                 :            :  * This is the slow, transforming version that needs to double buffer the
     308                 :            :  * data as it cannot do the transformations in place without having direct
     309                 :            :  * access to the destination pages of the backing file.
     310                 :            :  */
     311                 :          0 : static int lo_write_transfer(struct loop_device *lo, struct request *rq,
     312                 :            :                 loff_t pos)
     313                 :            : {
     314                 :            :         struct bio_vec bvec, b;
     315                 :            :         struct req_iterator iter;
     316                 :            :         struct page *page;
     317                 :            :         int ret = 0;
     318                 :            : 
     319                 :            :         page = alloc_page(GFP_NOIO);
     320         [ #  # ]:          0 :         if (unlikely(!page))
     321                 :            :                 return -ENOMEM;
     322                 :            : 
     323   [ #  #  #  #  :          0 :         rq_for_each_segment(bvec, rq, iter) {
                   #  # ]
     324                 :          0 :                 ret = lo_do_transfer(lo, WRITE, page, 0, bvec.bv_page,
     325                 :          0 :                         bvec.bv_offset, bvec.bv_len, pos >> 9);
     326         [ #  # ]:          0 :                 if (unlikely(ret))
     327                 :            :                         break;
     328                 :            : 
     329                 :          0 :                 b.bv_page = page;
     330                 :          0 :                 b.bv_offset = 0;
     331                 :          0 :                 b.bv_len = bvec.bv_len;
     332                 :          0 :                 ret = lo_write_bvec(lo->lo_backing_file, &b, &pos);
     333         [ #  # ]:          0 :                 if (ret < 0)
     334                 :            :                         break;
     335                 :            :         }
     336                 :            : 
     337                 :          0 :         __free_page(page);
     338                 :          0 :         return ret;
     339                 :            : }
     340                 :            : 
     341                 :          0 : static int lo_read_simple(struct loop_device *lo, struct request *rq,
     342                 :            :                 loff_t pos)
     343                 :            : {
     344                 :            :         struct bio_vec bvec;
     345                 :            :         struct req_iterator iter;
     346                 :            :         struct iov_iter i;
     347                 :            :         ssize_t len;
     348                 :            : 
     349   [ #  #  #  #  :          0 :         rq_for_each_segment(bvec, rq, iter) {
                   #  # ]
     350                 :          0 :                 iov_iter_bvec(&i, READ, &bvec, 1, bvec.bv_len);
     351                 :          0 :                 len = vfs_iter_read(lo->lo_backing_file, &i, &pos, 0);
     352         [ #  # ]:          0 :                 if (len < 0)
     353                 :          0 :                         return len;
     354                 :            : 
     355                 :          0 :                 flush_dcache_page(bvec.bv_page);
     356                 :            : 
     357         [ #  # ]:          0 :                 if (len != bvec.bv_len) {
     358                 :            :                         struct bio *bio;
     359                 :            : 
     360   [ #  #  #  # ]:          0 :                         __rq_for_each_bio(bio, rq)
     361                 :            :                                 zero_fill_bio(bio);
     362                 :            :                         break;
     363                 :            :                 }
     364                 :          0 :                 cond_resched();
     365                 :            :         }
     366                 :            : 
     367                 :            :         return 0;
     368                 :            : }
     369                 :            : 
     370                 :          0 : static int lo_read_transfer(struct loop_device *lo, struct request *rq,
     371                 :            :                 loff_t pos)
     372                 :            : {
     373                 :            :         struct bio_vec bvec, b;
     374                 :            :         struct req_iterator iter;
     375                 :            :         struct iov_iter i;
     376                 :            :         struct page *page;
     377                 :            :         ssize_t len;
     378                 :            :         int ret = 0;
     379                 :            : 
     380                 :            :         page = alloc_page(GFP_NOIO);
     381         [ #  # ]:          0 :         if (unlikely(!page))
     382                 :            :                 return -ENOMEM;
     383                 :            : 
     384   [ #  #  #  #  :          0 :         rq_for_each_segment(bvec, rq, iter) {
                   #  # ]
     385                 :          0 :                 loff_t offset = pos;
     386                 :            : 
     387                 :          0 :                 b.bv_page = page;
     388                 :          0 :                 b.bv_offset = 0;
     389                 :          0 :                 b.bv_len = bvec.bv_len;
     390                 :            : 
     391                 :          0 :                 iov_iter_bvec(&i, READ, &b, 1, b.bv_len);
     392                 :          0 :                 len = vfs_iter_read(lo->lo_backing_file, &i, &pos, 0);
     393         [ #  # ]:          0 :                 if (len < 0) {
     394                 :          0 :                         ret = len;
     395                 :          0 :                         goto out_free_page;
     396                 :            :                 }
     397                 :            : 
     398                 :          0 :                 ret = lo_do_transfer(lo, READ, page, 0, bvec.bv_page,
     399                 :          0 :                         bvec.bv_offset, len, offset >> 9);
     400         [ #  # ]:          0 :                 if (ret)
     401                 :            :                         goto out_free_page;
     402                 :            : 
     403                 :          0 :                 flush_dcache_page(bvec.bv_page);
     404                 :            : 
     405         [ #  # ]:          0 :                 if (len != bvec.bv_len) {
     406                 :            :                         struct bio *bio;
     407                 :            : 
     408   [ #  #  #  # ]:          0 :                         __rq_for_each_bio(bio, rq)
     409                 :            :                                 zero_fill_bio(bio);
     410                 :            :                         break;
     411                 :            :                 }
     412                 :            :         }
     413                 :            : 
     414                 :            :         ret = 0;
     415                 :            : out_free_page:
     416                 :          0 :         __free_page(page);
     417                 :          0 :         return ret;
     418                 :            : }
     419                 :            : 
     420                 :          0 : static int lo_fallocate(struct loop_device *lo, struct request *rq, loff_t pos,
     421                 :            :                         int mode)
     422                 :            : {
     423                 :            :         /*
     424                 :            :          * We use fallocate to manipulate the space mappings used by the image
     425                 :            :          * a.k.a. discard/zerorange. However we do not support this if
     426                 :            :          * encryption is enabled, because it may give an attacker useful
     427                 :            :          * information.
     428                 :            :          */
     429                 :          0 :         struct file *file = lo->lo_backing_file;
     430                 :          0 :         struct request_queue *q = lo->lo_queue;
     431                 :            :         int ret;
     432                 :            : 
     433                 :          0 :         mode |= FALLOC_FL_KEEP_SIZE;
     434                 :            : 
     435         [ #  # ]:          0 :         if (!blk_queue_discard(q)) {
     436                 :            :                 ret = -EOPNOTSUPP;
     437                 :            :                 goto out;
     438                 :            :         }
     439                 :            : 
     440                 :          0 :         ret = file->f_op->fallocate(file, mode, pos, blk_rq_bytes(rq));
     441   [ #  #  #  # ]:          0 :         if (unlikely(ret && ret != -EINVAL && ret != -EOPNOTSUPP))
     442                 :            :                 ret = -EIO;
     443                 :            :  out:
     444                 :          0 :         return ret;
     445                 :            : }
     446                 :            : 
     447                 :          0 : static int lo_req_flush(struct loop_device *lo, struct request *rq)
     448                 :            : {
     449                 :          0 :         struct file *file = lo->lo_backing_file;
     450                 :          0 :         int ret = vfs_fsync(file, 0);
     451         [ #  # ]:          0 :         if (unlikely(ret && ret != -EINVAL))
     452                 :            :                 ret = -EIO;
     453                 :            : 
     454                 :          0 :         return ret;
     455                 :            : }
     456                 :            : 
     457                 :          0 : static void lo_complete_rq(struct request *rq)
     458                 :            : {
     459                 :            :         struct loop_cmd *cmd = blk_mq_rq_to_pdu(rq);
     460                 :            :         blk_status_t ret = BLK_STS_OK;
     461                 :            : 
     462   [ #  #  #  #  :          0 :         if (!cmd->use_aio || cmd->ret < 0 || cmd->ret == blk_rq_bytes(rq) ||
             #  #  #  # ]
     463                 :          0 :             req_op(rq) != REQ_OP_READ) {
     464         [ #  # ]:          0 :                 if (cmd->ret < 0)
     465                 :            :                         ret = BLK_STS_IOERR;
     466                 :            :                 goto end_io;
     467                 :            :         }
     468                 :            : 
     469                 :            :         /*
     470                 :            :          * Short READ - if we got some data, advance our request and
     471                 :            :          * retry it. If we got no data, end the rest with EIO.
     472                 :            :          */
     473         [ #  # ]:          0 :         if (cmd->ret) {
     474                 :          0 :                 blk_update_request(rq, BLK_STS_OK, cmd->ret);
     475                 :          0 :                 cmd->ret = 0;
     476                 :          0 :                 blk_mq_requeue_request(rq, true);
     477                 :            :         } else {
     478         [ #  # ]:          0 :                 if (cmd->use_aio) {
     479                 :          0 :                         struct bio *bio = rq->bio;
     480                 :            : 
     481         [ #  # ]:          0 :                         while (bio) {
     482                 :            :                                 zero_fill_bio(bio);
     483                 :          0 :                                 bio = bio->bi_next;
     484                 :            :                         }
     485                 :            :                 }
     486                 :            :                 ret = BLK_STS_IOERR;
     487                 :            : end_io:
     488                 :          0 :                 blk_mq_end_request(rq, ret);
     489                 :            :         }
     490                 :          0 : }
     491                 :            : 
     492                 :          0 : static void lo_rw_aio_do_completion(struct loop_cmd *cmd)
     493                 :            : {
     494                 :            :         struct request *rq = blk_mq_rq_from_pdu(cmd);
     495                 :            : 
     496         [ #  # ]:          0 :         if (!atomic_dec_and_test(&cmd->ref))
     497                 :          0 :                 return;
     498                 :          0 :         kfree(cmd->bvec);
     499                 :          0 :         cmd->bvec = NULL;
     500                 :          0 :         blk_mq_complete_request(rq);
     501                 :            : }
     502                 :            : 
     503                 :          0 : static void lo_rw_aio_complete(struct kiocb *iocb, long ret, long ret2)
     504                 :            : {
     505                 :          0 :         struct loop_cmd *cmd = container_of(iocb, struct loop_cmd, iocb);
     506                 :            : 
     507         [ #  # ]:          0 :         if (cmd->css)
     508                 :            :                 css_put(cmd->css);
     509                 :          0 :         cmd->ret = ret;
     510                 :          0 :         lo_rw_aio_do_completion(cmd);
     511                 :          0 : }
     512                 :            : 
     513                 :          0 : static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd,
     514                 :            :                      loff_t pos, bool rw)
     515                 :            : {
     516                 :            :         struct iov_iter iter;
     517                 :            :         struct req_iterator rq_iter;
     518                 :            :         struct bio_vec *bvec;
     519                 :            :         struct request *rq = blk_mq_rq_from_pdu(cmd);
     520                 :          0 :         struct bio *bio = rq->bio;
     521                 :          0 :         struct file *file = lo->lo_backing_file;
     522                 :            :         struct bio_vec tmp;
     523                 :            :         unsigned int offset;
     524                 :            :         int nr_bvec = 0;
     525                 :            :         int ret;
     526                 :            : 
     527   [ #  #  #  #  :          0 :         rq_for_each_bvec(tmp, rq, rq_iter)
                   #  # ]
     528                 :          0 :                 nr_bvec++;
     529                 :            : 
     530         [ #  # ]:          0 :         if (rq->bio != rq->biotail) {
     531                 :            : 
     532                 :          0 :                 bvec = kmalloc_array(nr_bvec, sizeof(struct bio_vec),
     533                 :            :                                      GFP_NOIO);
     534         [ #  # ]:          0 :                 if (!bvec)
     535                 :            :                         return -EIO;
     536                 :          0 :                 cmd->bvec = bvec;
     537                 :            : 
     538                 :            :                 /*
     539                 :            :                  * The bios of the request may be started from the middle of
     540                 :            :                  * the 'bvec' because of bio splitting, so we can't directly
     541                 :            :                  * copy bio->bi_iov_vec to new bvec. The rq_for_each_bvec
     542                 :            :                  * API will take care of all details for us.
     543                 :            :                  */
     544   [ #  #  #  #  :          0 :                 rq_for_each_bvec(tmp, rq, rq_iter) {
                   #  # ]
     545                 :          0 :                         *bvec = tmp;
     546                 :          0 :                         bvec++;
     547                 :            :                 }
     548                 :          0 :                 bvec = cmd->bvec;
     549                 :            :                 offset = 0;
     550                 :            :         } else {
     551                 :            :                 /*
     552                 :            :                  * Same here, this bio may be started from the middle of the
     553                 :            :                  * 'bvec' because of bio splitting, so offset from the bvec
     554                 :            :                  * must be passed to iov iterator
     555                 :            :                  */
     556                 :          0 :                 offset = bio->bi_iter.bi_bvec_done;
     557                 :          0 :                 bvec = __bvec_iter_bvec(bio->bi_io_vec, bio->bi_iter);
     558                 :            :         }
     559                 :            :         atomic_set(&cmd->ref, 2);
     560                 :            : 
     561                 :          0 :         iov_iter_bvec(&iter, rw, bvec, nr_bvec, blk_rq_bytes(rq));
     562                 :          0 :         iter.iov_offset = offset;
     563                 :            : 
     564                 :          0 :         cmd->iocb.ki_pos = pos;
     565                 :          0 :         cmd->iocb.ki_filp = file;
     566                 :          0 :         cmd->iocb.ki_complete = lo_rw_aio_complete;
     567                 :          0 :         cmd->iocb.ki_flags = IOCB_DIRECT;
     568                 :          0 :         cmd->iocb.ki_ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE, 0);
     569         [ #  # ]:          0 :         if (cmd->css)
     570                 :          0 :                 kthread_associate_blkcg(cmd->css);
     571                 :            : 
     572         [ #  # ]:          0 :         if (rw == WRITE)
     573                 :          0 :                 ret = call_write_iter(file, &cmd->iocb, &iter);
     574                 :            :         else
     575                 :          0 :                 ret = call_read_iter(file, &cmd->iocb, &iter);
     576                 :            : 
     577                 :          0 :         lo_rw_aio_do_completion(cmd);
     578                 :          0 :         kthread_associate_blkcg(NULL);
     579                 :            : 
     580         [ #  # ]:          0 :         if (ret != -EIOCBQUEUED)
     581                 :          0 :                 cmd->iocb.ki_complete(&cmd->iocb, ret, 0);
     582                 :            :         return 0;
     583                 :            : }
     584                 :            : 
     585                 :          0 : static int do_req_filebacked(struct loop_device *lo, struct request *rq)
     586                 :            : {
     587                 :            :         struct loop_cmd *cmd = blk_mq_rq_to_pdu(rq);
     588                 :          0 :         loff_t pos = ((loff_t) blk_rq_pos(rq) << 9) + lo->lo_offset;
     589                 :            : 
     590                 :            :         /*
     591                 :            :          * lo_write_simple and lo_read_simple should have been covered
     592                 :            :          * by io submit style function like lo_rw_aio(), one blocker
     593                 :            :          * is that lo_read_simple() need to call flush_dcache_page after
     594                 :            :          * the page is written from kernel, and it isn't easy to handle
     595                 :            :          * this in io submit style function which submits all segments
     596                 :            :          * of the req at one time. And direct read IO doesn't need to
     597                 :            :          * run flush_dcache_page().
     598                 :            :          */
     599   [ #  #  #  #  :          0 :         switch (req_op(rq)) {
                   #  # ]
     600                 :            :         case REQ_OP_FLUSH:
     601                 :          0 :                 return lo_req_flush(lo, rq);
     602                 :            :         case REQ_OP_WRITE_ZEROES:
     603                 :            :                 /*
     604                 :            :                  * If the caller doesn't want deallocation, call zeroout to
     605                 :            :                  * write zeroes the range.  Otherwise, punch them out.
     606                 :            :                  */
     607         [ #  # ]:          0 :                 return lo_fallocate(lo, rq, pos,
     608                 :          0 :                         (rq->cmd_flags & REQ_NOUNMAP) ?
     609                 :            :                                 FALLOC_FL_ZERO_RANGE :
     610                 :            :                                 FALLOC_FL_PUNCH_HOLE);
     611                 :            :         case REQ_OP_DISCARD:
     612                 :          0 :                 return lo_fallocate(lo, rq, pos, FALLOC_FL_PUNCH_HOLE);
     613                 :            :         case REQ_OP_WRITE:
     614         [ #  # ]:          0 :                 if (lo->transfer)
     615                 :          0 :                         return lo_write_transfer(lo, rq, pos);
     616         [ #  # ]:          0 :                 else if (cmd->use_aio)
     617                 :          0 :                         return lo_rw_aio(lo, cmd, pos, WRITE);
     618                 :            :                 else
     619                 :          0 :                         return lo_write_simple(lo, rq, pos);
     620                 :            :         case REQ_OP_READ:
     621         [ #  # ]:          0 :                 if (lo->transfer)
     622                 :          0 :                         return lo_read_transfer(lo, rq, pos);
     623         [ #  # ]:          0 :                 else if (cmd->use_aio)
     624                 :          0 :                         return lo_rw_aio(lo, cmd, pos, READ);
     625                 :            :                 else
     626                 :          0 :                         return lo_read_simple(lo, rq, pos);
     627                 :            :         default:
     628         [ #  # ]:          0 :                 WARN_ON_ONCE(1);
     629                 :            :                 return -EIO;
     630                 :            :         }
     631                 :            : }
     632                 :            : 
     633                 :          0 : static inline void loop_update_dio(struct loop_device *lo)
     634                 :            : {
     635                 :          0 :         __loop_update_dio(lo, io_is_direct(lo->lo_backing_file) |
     636                 :          0 :                         lo->use_dio);
     637                 :          0 : }
     638                 :            : 
     639                 :          0 : static void loop_reread_partitions(struct loop_device *lo,
     640                 :            :                                    struct block_device *bdev)
     641                 :            : {
     642                 :            :         int rc;
     643                 :            : 
     644                 :          0 :         rc = blkdev_reread_part(bdev);
     645         [ #  # ]:          0 :         if (rc)
     646                 :          0 :                 pr_warn("%s: partition scan of loop%d (%s) failed (rc=%d)\n",
     647                 :            :                         __func__, lo->lo_number, lo->lo_file_name, rc);
     648                 :          0 : }
     649                 :            : 
     650                 :            : static inline int is_loop_device(struct file *file)
     651                 :            : {
     652                 :          0 :         struct inode *i = file->f_mapping->host;
     653                 :            : 
     654   [ #  #  #  #  :          0 :         return i && S_ISBLK(i->i_mode) && MAJOR(i->i_rdev) == LOOP_MAJOR;
                   #  # ]
     655                 :            : }
     656                 :            : 
     657                 :          0 : static int loop_validate_file(struct file *file, struct block_device *bdev)
     658                 :            : {
     659                 :          0 :         struct inode    *inode = file->f_mapping->host;
     660                 :            :         struct file     *f = file;
     661                 :            : 
     662                 :            :         /* Avoid recursion */
     663         [ #  # ]:          0 :         while (is_loop_device(f)) {
     664                 :            :                 struct loop_device *l;
     665                 :            : 
     666         [ #  # ]:          0 :                 if (f->f_mapping->host->i_bdev == bdev)
     667                 :            :                         return -EBADF;
     668                 :            : 
     669                 :          0 :                 l = f->f_mapping->host->i_bdev->bd_disk->private_data;
     670         [ #  # ]:          0 :                 if (l->lo_state != Lo_bound) {
     671                 :            :                         return -EINVAL;
     672                 :            :                 }
     673                 :          0 :                 f = l->lo_backing_file;
     674                 :            :         }
     675         [ #  # ]:          0 :         if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
     676                 :            :                 return -EINVAL;
     677                 :          0 :         return 0;
     678                 :            : }
     679                 :            : 
     680                 :            : /*
     681                 :            :  * loop_change_fd switched the backing store of a loopback device to
     682                 :            :  * a new file. This is useful for operating system installers to free up
     683                 :            :  * the original file and in High Availability environments to switch to
     684                 :            :  * an alternative location for the content in case of server meltdown.
     685                 :            :  * This can only work if the loop device is used read-only, and if the
     686                 :            :  * new backing store is the same size and type as the old backing store.
     687                 :            :  */
     688                 :          0 : static int loop_change_fd(struct loop_device *lo, struct block_device *bdev,
     689                 :            :                           unsigned int arg)
     690                 :            : {
     691                 :            :         struct file     *file = NULL, *old_file;
     692                 :            :         int             error;
     693                 :            :         bool            partscan;
     694                 :            : 
     695                 :          0 :         error = mutex_lock_killable(&loop_ctl_mutex);
     696         [ #  # ]:          0 :         if (error)
     697                 :            :                 return error;
     698                 :            :         error = -ENXIO;
     699         [ #  # ]:          0 :         if (lo->lo_state != Lo_bound)
     700                 :            :                 goto out_err;
     701                 :            : 
     702                 :            :         /* the loop device has to be read-only */
     703                 :            :         error = -EINVAL;
     704         [ #  # ]:          0 :         if (!(lo->lo_flags & LO_FLAGS_READ_ONLY))
     705                 :            :                 goto out_err;
     706                 :            : 
     707                 :            :         error = -EBADF;
     708                 :          0 :         file = fget(arg);
     709         [ #  # ]:          0 :         if (!file)
     710                 :            :                 goto out_err;
     711                 :            : 
     712                 :          0 :         error = loop_validate_file(file, bdev);
     713         [ #  # ]:          0 :         if (error)
     714                 :            :                 goto out_err;
     715                 :            : 
     716                 :          0 :         old_file = lo->lo_backing_file;
     717                 :            : 
     718                 :            :         error = -EINVAL;
     719                 :            : 
     720                 :            :         /* size of the new backing store needs to be the same */
     721         [ #  # ]:          0 :         if (get_loop_size(lo, file) != get_loop_size(lo, old_file))
     722                 :            :                 goto out_err;
     723                 :            : 
     724                 :            :         /* and ... switch */
     725                 :          0 :         blk_mq_freeze_queue(lo->lo_queue);
     726                 :          0 :         mapping_set_gfp_mask(old_file->f_mapping, lo->old_gfp_mask);
     727                 :          0 :         lo->lo_backing_file = file;
     728                 :          0 :         lo->old_gfp_mask = mapping_gfp_mask(file->f_mapping);
     729                 :          0 :         mapping_set_gfp_mask(file->f_mapping,
     730                 :            :                              lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS));
     731                 :          0 :         loop_update_dio(lo);
     732                 :          0 :         blk_mq_unfreeze_queue(lo->lo_queue);
     733                 :          0 :         partscan = lo->lo_flags & LO_FLAGS_PARTSCAN;
     734                 :          0 :         mutex_unlock(&loop_ctl_mutex);
     735                 :            :         /*
     736                 :            :          * We must drop file reference outside of loop_ctl_mutex as dropping
     737                 :            :          * the file ref can take bd_mutex which creates circular locking
     738                 :            :          * dependency.
     739                 :            :          */
     740                 :          0 :         fput(old_file);
     741         [ #  # ]:          0 :         if (partscan)
     742                 :          0 :                 loop_reread_partitions(lo, bdev);
     743                 :            :         return 0;
     744                 :            : 
     745                 :            : out_err:
     746                 :          0 :         mutex_unlock(&loop_ctl_mutex);
     747         [ #  # ]:          0 :         if (file)
     748                 :          0 :                 fput(file);
     749                 :          0 :         return error;
     750                 :            : }
     751                 :            : 
     752                 :            : /* loop sysfs attributes */
     753                 :            : 
     754                 :            : static ssize_t loop_attr_show(struct device *dev, char *page,
     755                 :            :                               ssize_t (*callback)(struct loop_device *, char *))
     756                 :            : {
     757                 :            :         struct gendisk *disk = dev_to_disk(dev);
     758                 :          0 :         struct loop_device *lo = disk->private_data;
     759                 :            : 
     760                 :          0 :         return callback(lo, page);
     761                 :            : }
     762                 :            : 
     763                 :            : #define LOOP_ATTR_RO(_name)                                             \
     764                 :            : static ssize_t loop_attr_##_name##_show(struct loop_device *, char *);  \
     765                 :            : static ssize_t loop_attr_do_show_##_name(struct device *d,              \
     766                 :            :                                 struct device_attribute *attr, char *b) \
     767                 :            : {                                                                       \
     768                 :            :         return loop_attr_show(d, b, loop_attr_##_name##_show);          \
     769                 :            : }                                                                       \
     770                 :            : static struct device_attribute loop_attr_##_name =                      \
     771                 :            :         __ATTR(_name, 0444, loop_attr_do_show_##_name, NULL);
     772                 :            : 
     773                 :          0 : static ssize_t loop_attr_backing_file_show(struct loop_device *lo, char *buf)
     774                 :            : {
     775                 :            :         ssize_t ret;
     776                 :            :         char *p = NULL;
     777                 :            : 
     778                 :            :         spin_lock_irq(&lo->lo_lock);
     779         [ #  # ]:          0 :         if (lo->lo_backing_file)
     780                 :          0 :                 p = file_path(lo->lo_backing_file, buf, PAGE_SIZE - 1);
     781                 :            :         spin_unlock_irq(&lo->lo_lock);
     782                 :            : 
     783         [ #  # ]:          0 :         if (IS_ERR_OR_NULL(p))
     784                 :            :                 ret = PTR_ERR(p);
     785                 :            :         else {
     786                 :          0 :                 ret = strlen(p);
     787                 :          0 :                 memmove(buf, p, ret);
     788                 :          0 :                 buf[ret++] = '\n';
     789                 :          0 :                 buf[ret] = 0;
     790                 :            :         }
     791                 :            : 
     792                 :          0 :         return ret;
     793                 :            : }
     794                 :            : 
     795                 :          0 : static ssize_t loop_attr_offset_show(struct loop_device *lo, char *buf)
     796                 :            : {
     797                 :          0 :         return sprintf(buf, "%llu\n", (unsigned long long)lo->lo_offset);
     798                 :            : }
     799                 :            : 
     800                 :          0 : static ssize_t loop_attr_sizelimit_show(struct loop_device *lo, char *buf)
     801                 :            : {
     802                 :          0 :         return sprintf(buf, "%llu\n", (unsigned long long)lo->lo_sizelimit);
     803                 :            : }
     804                 :            : 
     805                 :          0 : static ssize_t loop_attr_autoclear_show(struct loop_device *lo, char *buf)
     806                 :            : {
     807                 :          0 :         int autoclear = (lo->lo_flags & LO_FLAGS_AUTOCLEAR);
     808                 :            : 
     809         [ #  # ]:          0 :         return sprintf(buf, "%s\n", autoclear ? "1" : "0");
     810                 :            : }
     811                 :            : 
     812                 :          0 : static ssize_t loop_attr_partscan_show(struct loop_device *lo, char *buf)
     813                 :            : {
     814                 :          0 :         int partscan = (lo->lo_flags & LO_FLAGS_PARTSCAN);
     815                 :            : 
     816         [ #  # ]:          0 :         return sprintf(buf, "%s\n", partscan ? "1" : "0");
     817                 :            : }
     818                 :            : 
     819                 :          0 : static ssize_t loop_attr_dio_show(struct loop_device *lo, char *buf)
     820                 :            : {
     821                 :          0 :         int dio = (lo->lo_flags & LO_FLAGS_DIRECT_IO);
     822                 :            : 
     823         [ #  # ]:          0 :         return sprintf(buf, "%s\n", dio ? "1" : "0");
     824                 :            : }
     825                 :            : 
     826                 :          0 : LOOP_ATTR_RO(backing_file);
     827                 :          0 : LOOP_ATTR_RO(offset);
     828                 :          0 : LOOP_ATTR_RO(sizelimit);
     829                 :          0 : LOOP_ATTR_RO(autoclear);
     830                 :          0 : LOOP_ATTR_RO(partscan);
     831                 :          0 : LOOP_ATTR_RO(dio);
     832                 :            : 
     833                 :            : static struct attribute *loop_attrs[] = {
     834                 :            :         &loop_attr_backing_file.attr,
     835                 :            :         &loop_attr_offset.attr,
     836                 :            :         &loop_attr_sizelimit.attr,
     837                 :            :         &loop_attr_autoclear.attr,
     838                 :            :         &loop_attr_partscan.attr,
     839                 :            :         &loop_attr_dio.attr,
     840                 :            :         NULL,
     841                 :            : };
     842                 :            : 
     843                 :            : static struct attribute_group loop_attribute_group = {
     844                 :            :         .name = "loop",
     845                 :            :         .attrs= loop_attrs,
     846                 :            : };
     847                 :            : 
     848                 :            : static void loop_sysfs_init(struct loop_device *lo)
     849                 :            : {
     850                 :          0 :         lo->sysfs_inited = !sysfs_create_group(&disk_to_dev(lo->lo_disk)->kobj,
     851                 :            :                                                 &loop_attribute_group);
     852                 :            : }
     853                 :            : 
     854                 :            : static void loop_sysfs_exit(struct loop_device *lo)
     855                 :            : {
     856         [ #  # ]:          0 :         if (lo->sysfs_inited)
     857                 :          0 :                 sysfs_remove_group(&disk_to_dev(lo->lo_disk)->kobj,
     858                 :            :                                    &loop_attribute_group);
     859                 :            : }
     860                 :            : 
     861                 :          0 : static void loop_config_discard(struct loop_device *lo)
     862                 :            : {
     863                 :          0 :         struct file *file = lo->lo_backing_file;
     864                 :          0 :         struct inode *inode = file->f_mapping->host;
     865                 :          0 :         struct request_queue *q = lo->lo_queue;
     866                 :            : 
     867                 :            :         /*
     868                 :            :          * If the backing device is a block device, mirror its zeroing
     869                 :            :          * capability. Set the discard sectors to the block device's zeroing
     870                 :            :          * capabilities because loop discards result in blkdev_issue_zeroout(),
     871                 :            :          * not blkdev_issue_discard(). This maintains consistent behavior with
     872                 :            :          * file-backed loop devices: discarded regions read back as zero.
     873                 :            :          */
     874   [ #  #  #  # ]:          0 :         if (S_ISBLK(inode->i_mode) && !lo->lo_encrypt_key_size) {
     875                 :            :                 struct request_queue *backingq;
     876                 :            : 
     877                 :          0 :                 backingq = bdev_get_queue(inode->i_bdev);
     878                 :          0 :                 blk_queue_max_discard_sectors(q,
     879                 :            :                         backingq->limits.max_write_zeroes_sectors);
     880                 :            : 
     881                 :          0 :                 blk_queue_max_write_zeroes_sectors(q,
     882                 :            :                         backingq->limits.max_write_zeroes_sectors);
     883                 :            : 
     884                 :            :         /*
     885                 :            :          * We use punch hole to reclaim the free space used by the
     886                 :            :          * image a.k.a. discard. However we do not support discard if
     887                 :            :          * encryption is enabled, because it may give an attacker
     888                 :            :          * useful information.
     889                 :            :          */
     890   [ #  #  #  # ]:          0 :         } else if (!file->f_op->fallocate || lo->lo_encrypt_key_size) {
     891                 :          0 :                 q->limits.discard_granularity = 0;
     892                 :          0 :                 q->limits.discard_alignment = 0;
     893                 :          0 :                 blk_queue_max_discard_sectors(q, 0);
     894                 :          0 :                 blk_queue_max_write_zeroes_sectors(q, 0);
     895                 :            : 
     896                 :            :         } else {
     897                 :          0 :                 q->limits.discard_granularity = inode->i_sb->s_blocksize;
     898                 :          0 :                 q->limits.discard_alignment = 0;
     899                 :            : 
     900                 :          0 :                 blk_queue_max_discard_sectors(q, UINT_MAX >> 9);
     901                 :          0 :                 blk_queue_max_write_zeroes_sectors(q, UINT_MAX >> 9);
     902                 :            :         }
     903                 :            : 
     904         [ #  # ]:          0 :         if (q->limits.max_write_zeroes_sectors)
     905                 :          0 :                 blk_queue_flag_set(QUEUE_FLAG_DISCARD, q);
     906                 :            :         else
     907                 :          0 :                 blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q);
     908                 :          0 : }
     909                 :            : 
     910                 :            : static void loop_unprepare_queue(struct loop_device *lo)
     911                 :            : {
     912                 :          0 :         kthread_flush_worker(&lo->worker);
     913                 :          0 :         kthread_stop(lo->worker_task);
     914                 :            : }
     915                 :            : 
     916                 :          0 : static int loop_kthread_worker_fn(void *worker_ptr)
     917                 :            : {
     918                 :          0 :         current->flags |= PF_LESS_THROTTLE | PF_MEMALLOC_NOIO;
     919                 :          0 :         return kthread_worker_fn(worker_ptr);
     920                 :            : }
     921                 :            : 
     922                 :          0 : static int loop_prepare_queue(struct loop_device *lo)
     923                 :            : {
     924                 :          0 :         kthread_init_worker(&lo->worker);
     925         [ #  # ]:          0 :         lo->worker_task = kthread_run(loop_kthread_worker_fn,
     926                 :            :                         &lo->worker, "loop%d", lo->lo_number);
     927         [ #  # ]:          0 :         if (IS_ERR(lo->worker_task))
     928                 :            :                 return -ENOMEM;
     929                 :          0 :         set_user_nice(lo->worker_task, MIN_NICE);
     930                 :          0 :         return 0;
     931                 :            : }
     932                 :            : 
     933                 :          0 : static void loop_update_rotational(struct loop_device *lo)
     934                 :            : {
     935                 :          0 :         struct file *file = lo->lo_backing_file;
     936                 :          0 :         struct inode *file_inode = file->f_mapping->host;
     937                 :          0 :         struct block_device *file_bdev = file_inode->i_sb->s_bdev;
     938                 :          0 :         struct request_queue *q = lo->lo_queue;
     939                 :            :         bool nonrot = true;
     940                 :            : 
     941                 :            :         /* not all filesystems (e.g. tmpfs) have a sb->s_bdev */
     942         [ #  # ]:          0 :         if (file_bdev)
     943                 :          0 :                 nonrot = blk_queue_nonrot(bdev_get_queue(file_bdev));
     944                 :            : 
     945         [ #  # ]:          0 :         if (nonrot)
     946                 :          0 :                 blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
     947                 :            :         else
     948                 :          0 :                 blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
     949                 :          0 : }
     950                 :            : 
     951                 :          0 : static int loop_set_fd(struct loop_device *lo, fmode_t mode,
     952                 :            :                        struct block_device *bdev, unsigned int arg)
     953                 :            : {
     954                 :            :         struct file     *file;
     955                 :            :         struct inode    *inode;
     956                 :            :         struct address_space *mapping;
     957                 :            :         struct block_device *claimed_bdev = NULL;
     958                 :            :         int             lo_flags = 0;
     959                 :            :         int             error;
     960                 :            :         loff_t          size;
     961                 :            :         bool            partscan;
     962                 :            : 
     963                 :            :         /* This is safe, since we have a reference from open(). */
     964                 :          0 :         __module_get(THIS_MODULE);
     965                 :            : 
     966                 :            :         error = -EBADF;
     967                 :          0 :         file = fget(arg);
     968         [ #  # ]:          0 :         if (!file)
     969                 :            :                 goto out;
     970                 :            : 
     971                 :            :         /*
     972                 :            :          * If we don't hold exclusive handle for the device, upgrade to it
     973                 :            :          * here to avoid changing device under exclusive owner.
     974                 :            :          */
     975         [ #  # ]:          0 :         if (!(mode & FMODE_EXCL)) {
     976                 :          0 :                 claimed_bdev = bd_start_claiming(bdev, loop_set_fd);
     977         [ #  # ]:          0 :                 if (IS_ERR(claimed_bdev)) {
     978                 :            :                         error = PTR_ERR(claimed_bdev);
     979                 :          0 :                         goto out_putf;
     980                 :            :                 }
     981                 :            :         }
     982                 :            : 
     983                 :          0 :         error = mutex_lock_killable(&loop_ctl_mutex);
     984         [ #  # ]:          0 :         if (error)
     985                 :            :                 goto out_bdev;
     986                 :            : 
     987                 :            :         error = -EBUSY;
     988         [ #  # ]:          0 :         if (lo->lo_state != Lo_unbound)
     989                 :            :                 goto out_unlock;
     990                 :            : 
     991                 :          0 :         error = loop_validate_file(file, bdev);
     992         [ #  # ]:          0 :         if (error)
     993                 :            :                 goto out_unlock;
     994                 :            : 
     995                 :          0 :         mapping = file->f_mapping;
     996                 :          0 :         inode = mapping->host;
     997                 :            : 
     998   [ #  #  #  #  :          0 :         if (!(file->f_mode & FMODE_WRITE) || !(mode & FMODE_WRITE) ||
                   #  # ]
     999                 :          0 :             !file->f_op->write_iter)
    1000                 :            :                 lo_flags |= LO_FLAGS_READ_ONLY;
    1001                 :            : 
    1002                 :            :         error = -EFBIG;
    1003                 :            :         size = get_loop_size(lo, file);
    1004                 :            :         if ((loff_t)(sector_t)size != size)
    1005                 :            :                 goto out_unlock;
    1006                 :          0 :         error = loop_prepare_queue(lo);
    1007         [ #  # ]:          0 :         if (error)
    1008                 :            :                 goto out_unlock;
    1009                 :            : 
    1010                 :            :         error = 0;
    1011                 :            : 
    1012                 :          0 :         set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0);
    1013                 :            : 
    1014                 :          0 :         lo->use_dio = false;
    1015                 :          0 :         lo->lo_device = bdev;
    1016                 :          0 :         lo->lo_flags = lo_flags;
    1017                 :          0 :         lo->lo_backing_file = file;
    1018                 :          0 :         lo->transfer = NULL;
    1019                 :          0 :         lo->ioctl = NULL;
    1020                 :          0 :         lo->lo_sizelimit = 0;
    1021                 :          0 :         lo->old_gfp_mask = mapping_gfp_mask(mapping);
    1022                 :          0 :         mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS));
    1023                 :            : 
    1024   [ #  #  #  # ]:          0 :         if (!(lo_flags & LO_FLAGS_READ_ONLY) && file->f_op->fsync)
    1025                 :          0 :                 blk_queue_write_cache(lo->lo_queue, true, false);
    1026                 :            : 
    1027   [ #  #  #  # ]:          0 :         if (io_is_direct(lo->lo_backing_file) && inode->i_sb->s_bdev) {
    1028                 :            :                 /* In case of direct I/O, match underlying block size */
    1029                 :            :                 unsigned short bsize = bdev_logical_block_size(
    1030                 :            :                         inode->i_sb->s_bdev);
    1031                 :            : 
    1032                 :          0 :                 blk_queue_logical_block_size(lo->lo_queue, bsize);
    1033                 :          0 :                 blk_queue_physical_block_size(lo->lo_queue, bsize);
    1034                 :          0 :                 blk_queue_io_min(lo->lo_queue, bsize);
    1035                 :            :         }
    1036                 :            : 
    1037                 :          0 :         loop_update_rotational(lo);
    1038                 :          0 :         loop_update_dio(lo);
    1039                 :          0 :         set_capacity(lo->lo_disk, size);
    1040                 :          0 :         bd_set_size(bdev, size << 9);
    1041                 :            :         loop_sysfs_init(lo);
    1042                 :            :         /* let user-space know about the new size */
    1043                 :          0 :         kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);
    1044                 :            : 
    1045         [ #  # ]:          0 :         set_blocksize(bdev, S_ISBLK(inode->i_mode) ?
    1046                 :          0 :                       block_size(inode->i_bdev) : PAGE_SIZE);
    1047                 :            : 
    1048                 :          0 :         lo->lo_state = Lo_bound;
    1049         [ #  # ]:          0 :         if (part_shift)
    1050                 :          0 :                 lo->lo_flags |= LO_FLAGS_PARTSCAN;
    1051                 :          0 :         partscan = lo->lo_flags & LO_FLAGS_PARTSCAN;
    1052                 :            : 
    1053                 :            :         /* Grab the block_device to prevent its destruction after we
    1054                 :            :          * put /dev/loopXX inode. Later in __loop_clr_fd() we bdput(bdev).
    1055                 :            :          */
    1056                 :          0 :         bdgrab(bdev);
    1057                 :          0 :         mutex_unlock(&loop_ctl_mutex);
    1058         [ #  # ]:          0 :         if (partscan)
    1059                 :          0 :                 loop_reread_partitions(lo, bdev);
    1060         [ #  # ]:          0 :         if (claimed_bdev)
    1061                 :          0 :                 bd_abort_claiming(bdev, claimed_bdev, loop_set_fd);
    1062                 :            :         return 0;
    1063                 :            : 
    1064                 :            : out_unlock:
    1065                 :          0 :         mutex_unlock(&loop_ctl_mutex);
    1066                 :            : out_bdev:
    1067         [ #  # ]:          0 :         if (claimed_bdev)
    1068                 :          0 :                 bd_abort_claiming(bdev, claimed_bdev, loop_set_fd);
    1069                 :            : out_putf:
    1070                 :          0 :         fput(file);
    1071                 :            : out:
    1072                 :            :         /* This is safe: open() is still holding a reference. */
    1073                 :          0 :         module_put(THIS_MODULE);
    1074                 :          0 :         return error;
    1075                 :            : }
    1076                 :            : 
    1077                 :            : static int
    1078                 :          0 : loop_release_xfer(struct loop_device *lo)
    1079                 :            : {
    1080                 :            :         int err = 0;
    1081                 :          0 :         struct loop_func_table *xfer = lo->lo_encryption;
    1082                 :            : 
    1083         [ #  # ]:          0 :         if (xfer) {
    1084         [ #  # ]:          0 :                 if (xfer->release)
    1085                 :          0 :                         err = xfer->release(lo);
    1086                 :          0 :                 lo->transfer = NULL;
    1087                 :          0 :                 lo->lo_encryption = NULL;
    1088                 :          0 :                 module_put(xfer->owner);
    1089                 :            :         }
    1090                 :          0 :         return err;
    1091                 :            : }
    1092                 :            : 
    1093                 :            : static int
    1094                 :          0 : loop_init_xfer(struct loop_device *lo, struct loop_func_table *xfer,
    1095                 :            :                const struct loop_info64 *i)
    1096                 :            : {
    1097                 :            :         int err = 0;
    1098                 :            : 
    1099         [ #  # ]:          0 :         if (xfer) {
    1100                 :          0 :                 struct module *owner = xfer->owner;
    1101                 :            : 
    1102         [ #  # ]:          0 :                 if (!try_module_get(owner))
    1103                 :            :                         return -EINVAL;
    1104         [ #  # ]:          0 :                 if (xfer->init)
    1105                 :          0 :                         err = xfer->init(lo, i);
    1106         [ #  # ]:          0 :                 if (err)
    1107                 :          0 :                         module_put(owner);
    1108                 :            :                 else
    1109                 :          0 :                         lo->lo_encryption = xfer;
    1110                 :            :         }
    1111                 :          0 :         return err;
    1112                 :            : }
    1113                 :            : 
    1114                 :          0 : static int __loop_clr_fd(struct loop_device *lo, bool release)
    1115                 :            : {
    1116                 :            :         struct file *filp = NULL;
    1117                 :          0 :         gfp_t gfp = lo->old_gfp_mask;
    1118                 :          0 :         struct block_device *bdev = lo->lo_device;
    1119                 :            :         int err = 0;
    1120                 :            :         bool partscan = false;
    1121                 :            :         int lo_number;
    1122                 :            : 
    1123                 :          0 :         mutex_lock(&loop_ctl_mutex);
    1124   [ #  #  #  #  :          0 :         if (WARN_ON_ONCE(lo->lo_state != Lo_rundown)) {
                   #  # ]
    1125                 :            :                 err = -ENXIO;
    1126                 :            :                 goto out_unlock;
    1127                 :            :         }
    1128                 :            : 
    1129                 :          0 :         filp = lo->lo_backing_file;
    1130         [ #  # ]:          0 :         if (filp == NULL) {
    1131                 :            :                 err = -EINVAL;
    1132                 :            :                 goto out_unlock;
    1133                 :            :         }
    1134                 :            : 
    1135                 :            :         /* freeze request queue during the transition */
    1136                 :          0 :         blk_mq_freeze_queue(lo->lo_queue);
    1137                 :            : 
    1138                 :            :         spin_lock_irq(&lo->lo_lock);
    1139                 :          0 :         lo->lo_backing_file = NULL;
    1140                 :            :         spin_unlock_irq(&lo->lo_lock);
    1141                 :            : 
    1142                 :          0 :         loop_release_xfer(lo);
    1143                 :          0 :         lo->transfer = NULL;
    1144                 :          0 :         lo->ioctl = NULL;
    1145                 :          0 :         lo->lo_device = NULL;
    1146                 :          0 :         lo->lo_encryption = NULL;
    1147                 :          0 :         lo->lo_offset = 0;
    1148                 :          0 :         lo->lo_sizelimit = 0;
    1149                 :          0 :         lo->lo_encrypt_key_size = 0;
    1150                 :          0 :         memset(lo->lo_encrypt_key, 0, LO_KEY_SIZE);
    1151                 :          0 :         memset(lo->lo_crypt_name, 0, LO_NAME_SIZE);
    1152                 :          0 :         memset(lo->lo_file_name, 0, LO_NAME_SIZE);
    1153                 :          0 :         blk_queue_logical_block_size(lo->lo_queue, 512);
    1154                 :          0 :         blk_queue_physical_block_size(lo->lo_queue, 512);
    1155                 :          0 :         blk_queue_io_min(lo->lo_queue, 512);
    1156         [ #  # ]:          0 :         if (bdev) {
    1157                 :          0 :                 bdput(bdev);
    1158                 :          0 :                 invalidate_bdev(bdev);
    1159                 :          0 :                 bdev->bd_inode->i_mapping->wb_err = 0;
    1160                 :            :         }
    1161                 :          0 :         set_capacity(lo->lo_disk, 0);
    1162                 :            :         loop_sysfs_exit(lo);
    1163         [ #  # ]:          0 :         if (bdev) {
    1164                 :          0 :                 bd_set_size(bdev, 0);
    1165                 :            :                 /* let user-space know about this change */
    1166                 :          0 :                 kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);
    1167                 :            :         }
    1168                 :          0 :         mapping_set_gfp_mask(filp->f_mapping, gfp);
    1169                 :            :         /* This is safe: open() is still holding a reference. */
    1170                 :          0 :         module_put(THIS_MODULE);
    1171                 :          0 :         blk_mq_unfreeze_queue(lo->lo_queue);
    1172                 :            : 
    1173   [ #  #  #  # ]:          0 :         partscan = lo->lo_flags & LO_FLAGS_PARTSCAN && bdev;
    1174                 :          0 :         lo_number = lo->lo_number;
    1175                 :            :         loop_unprepare_queue(lo);
    1176                 :            : out_unlock:
    1177                 :          0 :         mutex_unlock(&loop_ctl_mutex);
    1178         [ #  # ]:          0 :         if (partscan) {
    1179                 :            :                 /*
    1180                 :            :                  * bd_mutex has been held already in release path, so don't
    1181                 :            :                  * acquire it if this function is called in such case.
    1182                 :            :                  *
    1183                 :            :                  * If the reread partition isn't from release path, lo_refcnt
    1184                 :            :                  * must be at least one and it can only become zero when the
    1185                 :            :                  * current holder is released.
    1186                 :            :                  */
    1187         [ #  # ]:          0 :                 if (release)
    1188                 :          0 :                         err = __blkdev_reread_part(bdev);
    1189                 :            :                 else
    1190                 :          0 :                         err = blkdev_reread_part(bdev);
    1191         [ #  # ]:          0 :                 if (err)
    1192                 :          0 :                         pr_warn("%s: partition scan of loop%d failed (rc=%d)\n",
    1193                 :            :                                 __func__, lo_number, err);
    1194                 :            :                 /* Device is gone, no point in returning error */
    1195                 :            :                 err = 0;
    1196                 :            :         }
    1197                 :            : 
    1198                 :            :         /*
    1199                 :            :          * lo->lo_state is set to Lo_unbound here after above partscan has
    1200                 :            :          * finished.
    1201                 :            :          *
    1202                 :            :          * There cannot be anybody else entering __loop_clr_fd() as
    1203                 :            :          * lo->lo_backing_file is already cleared and Lo_rundown state
    1204                 :            :          * protects us from all the other places trying to change the 'lo'
    1205                 :            :          * device.
    1206                 :            :          */
    1207                 :          0 :         mutex_lock(&loop_ctl_mutex);
    1208                 :          0 :         lo->lo_flags = 0;
    1209         [ #  # ]:          0 :         if (!part_shift)
    1210                 :          0 :                 lo->lo_disk->flags |= GENHD_FL_NO_PART_SCAN;
    1211                 :          0 :         lo->lo_state = Lo_unbound;
    1212                 :          0 :         mutex_unlock(&loop_ctl_mutex);
    1213                 :            : 
    1214                 :            :         /*
    1215                 :            :          * Need not hold loop_ctl_mutex to fput backing file.
    1216                 :            :          * Calling fput holding loop_ctl_mutex triggers a circular
    1217                 :            :          * lock dependency possibility warning as fput can take
    1218                 :            :          * bd_mutex which is usually taken before loop_ctl_mutex.
    1219                 :            :          */
    1220         [ #  # ]:          0 :         if (filp)
    1221                 :          0 :                 fput(filp);
    1222                 :          0 :         return err;
    1223                 :            : }
    1224                 :            : 
    1225                 :          0 : static int loop_clr_fd(struct loop_device *lo)
    1226                 :            : {
    1227                 :            :         int err;
    1228                 :            : 
    1229                 :          0 :         err = mutex_lock_killable(&loop_ctl_mutex);
    1230         [ #  # ]:          0 :         if (err)
    1231                 :            :                 return err;
    1232         [ #  # ]:          0 :         if (lo->lo_state != Lo_bound) {
    1233                 :          0 :                 mutex_unlock(&loop_ctl_mutex);
    1234                 :          0 :                 return -ENXIO;
    1235                 :            :         }
    1236                 :            :         /*
    1237                 :            :          * If we've explicitly asked to tear down the loop device,
    1238                 :            :          * and it has an elevated reference count, set it for auto-teardown when
    1239                 :            :          * the last reference goes away. This stops $!~#$@ udev from
    1240                 :            :          * preventing teardown because it decided that it needs to run blkid on
    1241                 :            :          * the loopback device whenever they appear. xfstests is notorious for
    1242                 :            :          * failing tests because blkid via udev races with a losetup
    1243                 :            :          * <dev>/do something like mkfs/losetup -d <dev> causing the losetup -d
    1244                 :            :          * command to fail with EBUSY.
    1245                 :            :          */
    1246         [ #  # ]:          0 :         if (atomic_read(&lo->lo_refcnt) > 1) {
    1247                 :          0 :                 lo->lo_flags |= LO_FLAGS_AUTOCLEAR;
    1248                 :          0 :                 mutex_unlock(&loop_ctl_mutex);
    1249                 :          0 :                 return 0;
    1250                 :            :         }
    1251                 :          0 :         lo->lo_state = Lo_rundown;
    1252                 :          0 :         mutex_unlock(&loop_ctl_mutex);
    1253                 :            : 
    1254                 :          0 :         return __loop_clr_fd(lo, false);
    1255                 :            : }
    1256                 :            : 
    1257                 :            : static int
    1258                 :          0 : loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
    1259                 :            : {
    1260                 :            :         int err;
    1261                 :            :         struct loop_func_table *xfer;
    1262                 :          0 :         kuid_t uid = current_uid();
    1263                 :            :         struct block_device *bdev;
    1264                 :            :         bool partscan = false;
    1265                 :            : 
    1266                 :          0 :         err = mutex_lock_killable(&loop_ctl_mutex);
    1267         [ #  # ]:          0 :         if (err)
    1268                 :            :                 return err;
    1269   [ #  #  #  # ]:          0 :         if (lo->lo_encrypt_key_size &&
    1270         [ #  # ]:          0 :             !uid_eq(lo->lo_key_owner, uid) &&
    1271                 :          0 :             !capable(CAP_SYS_ADMIN)) {
    1272                 :            :                 err = -EPERM;
    1273                 :            :                 goto out_unlock;
    1274                 :            :         }
    1275         [ #  # ]:          0 :         if (lo->lo_state != Lo_bound) {
    1276                 :            :                 err = -ENXIO;
    1277                 :            :                 goto out_unlock;
    1278                 :            :         }
    1279         [ #  # ]:          0 :         if ((unsigned int) info->lo_encrypt_key_size > LO_KEY_SIZE) {
    1280                 :            :                 err = -EINVAL;
    1281                 :            :                 goto out_unlock;
    1282                 :            :         }
    1283                 :            : 
    1284   [ #  #  #  # ]:          0 :         if (lo->lo_offset != info->lo_offset ||
    1285                 :          0 :             lo->lo_sizelimit != info->lo_sizelimit) {
    1286                 :          0 :                 sync_blockdev(lo->lo_device);
    1287                 :          0 :                 invalidate_bdev(lo->lo_device);
    1288                 :            :         }
    1289                 :            : 
    1290                 :            :         /* I/O need to be drained during transfer transition */
    1291                 :          0 :         blk_mq_freeze_queue(lo->lo_queue);
    1292                 :            : 
    1293                 :          0 :         err = loop_release_xfer(lo);
    1294         [ #  # ]:          0 :         if (err)
    1295                 :            :                 goto out_unfreeze;
    1296                 :            : 
    1297         [ #  # ]:          0 :         if (info->lo_encrypt_type) {
    1298                 :            :                 unsigned int type = info->lo_encrypt_type;
    1299                 :            : 
    1300         [ #  # ]:          0 :                 if (type >= MAX_LO_CRYPT) {
    1301                 :            :                         err = -EINVAL;
    1302                 :            :                         goto out_unfreeze;
    1303                 :            :                 }
    1304                 :          0 :                 xfer = xfer_funcs[type];
    1305         [ #  # ]:          0 :                 if (xfer == NULL) {
    1306                 :            :                         err = -EINVAL;
    1307                 :            :                         goto out_unfreeze;
    1308                 :            :                 }
    1309                 :            :         } else
    1310                 :            :                 xfer = NULL;
    1311                 :            : 
    1312                 :          0 :         err = loop_init_xfer(lo, xfer, info);
    1313         [ #  # ]:          0 :         if (err)
    1314                 :            :                 goto out_unfreeze;
    1315                 :            : 
    1316   [ #  #  #  # ]:          0 :         if (lo->lo_offset != info->lo_offset ||
    1317                 :          0 :             lo->lo_sizelimit != info->lo_sizelimit) {
    1318                 :            :                 /* kill_bdev should have truncated all the pages */
    1319         [ #  # ]:          0 :                 if (lo->lo_device->bd_inode->i_mapping->nrpages) {
    1320                 :            :                         err = -EAGAIN;
    1321                 :          0 :                         pr_warn("%s: loop%d (%s) has still dirty pages (nrpages=%lu)\n",
    1322                 :            :                                 __func__, lo->lo_number, lo->lo_file_name,
    1323                 :            :                                 lo->lo_device->bd_inode->i_mapping->nrpages);
    1324                 :          0 :                         goto out_unfreeze;
    1325                 :            :                 }
    1326         [ #  # ]:          0 :                 if (figure_loop_size(lo, info->lo_offset, info->lo_sizelimit)) {
    1327                 :            :                         err = -EFBIG;
    1328                 :            :                         goto out_unfreeze;
    1329                 :            :                 }
    1330                 :            :         }
    1331                 :            : 
    1332                 :          0 :         loop_config_discard(lo);
    1333                 :            : 
    1334                 :          0 :         memcpy(lo->lo_file_name, info->lo_file_name, LO_NAME_SIZE);
    1335                 :          0 :         memcpy(lo->lo_crypt_name, info->lo_crypt_name, LO_NAME_SIZE);
    1336                 :          0 :         lo->lo_file_name[LO_NAME_SIZE-1] = 0;
    1337                 :          0 :         lo->lo_crypt_name[LO_NAME_SIZE-1] = 0;
    1338                 :            : 
    1339         [ #  # ]:          0 :         if (!xfer)
    1340                 :            :                 xfer = &none_funcs;
    1341                 :          0 :         lo->transfer = xfer->transfer;
    1342                 :          0 :         lo->ioctl = xfer->ioctl;
    1343                 :            : 
    1344         [ #  # ]:          0 :         if ((lo->lo_flags & LO_FLAGS_AUTOCLEAR) !=
    1345                 :          0 :              (info->lo_flags & LO_FLAGS_AUTOCLEAR))
    1346                 :          0 :                 lo->lo_flags ^= LO_FLAGS_AUTOCLEAR;
    1347                 :            : 
    1348                 :          0 :         lo->lo_encrypt_key_size = info->lo_encrypt_key_size;
    1349                 :          0 :         lo->lo_init[0] = info->lo_init[0];
    1350                 :          0 :         lo->lo_init[1] = info->lo_init[1];
    1351         [ #  # ]:          0 :         if (info->lo_encrypt_key_size) {
    1352                 :          0 :                 memcpy(lo->lo_encrypt_key, info->lo_encrypt_key,
    1353                 :            :                        info->lo_encrypt_key_size);
    1354                 :          0 :                 lo->lo_key_owner = uid;
    1355                 :            :         }
    1356                 :            : 
    1357                 :            :         /* update dio if lo_offset or transfer is changed */
    1358                 :          0 :         __loop_update_dio(lo, lo->use_dio);
    1359                 :            : 
    1360                 :            : out_unfreeze:
    1361                 :          0 :         blk_mq_unfreeze_queue(lo->lo_queue);
    1362                 :            : 
    1363   [ #  #  #  #  :          0 :         if (!err && (info->lo_flags & LO_FLAGS_PARTSCAN) &&
                   #  # ]
    1364                 :          0 :              !(lo->lo_flags & LO_FLAGS_PARTSCAN)) {
    1365                 :          0 :                 lo->lo_flags |= LO_FLAGS_PARTSCAN;
    1366                 :          0 :                 lo->lo_disk->flags &= ~GENHD_FL_NO_PART_SCAN;
    1367                 :          0 :                 bdev = lo->lo_device;
    1368                 :            :                 partscan = true;
    1369                 :            :         }
    1370                 :            : out_unlock:
    1371                 :          0 :         mutex_unlock(&loop_ctl_mutex);
    1372         [ #  # ]:          0 :         if (partscan)
    1373                 :          0 :                 loop_reread_partitions(lo, bdev);
    1374                 :            : 
    1375                 :          0 :         return err;
    1376                 :            : }
    1377                 :            : 
    1378                 :            : static int
    1379                 :          0 : loop_get_status(struct loop_device *lo, struct loop_info64 *info)
    1380                 :            : {
    1381                 :            :         struct path path;
    1382                 :            :         struct kstat stat;
    1383                 :            :         int ret;
    1384                 :            : 
    1385                 :          0 :         ret = mutex_lock_killable(&loop_ctl_mutex);
    1386         [ #  # ]:          0 :         if (ret)
    1387                 :            :                 return ret;
    1388         [ #  # ]:          0 :         if (lo->lo_state != Lo_bound) {
    1389                 :          0 :                 mutex_unlock(&loop_ctl_mutex);
    1390                 :          0 :                 return -ENXIO;
    1391                 :            :         }
    1392                 :            : 
    1393                 :          0 :         memset(info, 0, sizeof(*info));
    1394                 :          0 :         info->lo_number = lo->lo_number;
    1395                 :          0 :         info->lo_offset = lo->lo_offset;
    1396                 :          0 :         info->lo_sizelimit = lo->lo_sizelimit;
    1397                 :          0 :         info->lo_flags = lo->lo_flags;
    1398                 :          0 :         memcpy(info->lo_file_name, lo->lo_file_name, LO_NAME_SIZE);
    1399                 :          0 :         memcpy(info->lo_crypt_name, lo->lo_crypt_name, LO_NAME_SIZE);
    1400         [ #  # ]:          0 :         info->lo_encrypt_type =
    1401                 :          0 :                 lo->lo_encryption ? lo->lo_encryption->number : 0;
    1402   [ #  #  #  # ]:          0 :         if (lo->lo_encrypt_key_size && capable(CAP_SYS_ADMIN)) {
    1403                 :          0 :                 info->lo_encrypt_key_size = lo->lo_encrypt_key_size;
    1404                 :          0 :                 memcpy(info->lo_encrypt_key, lo->lo_encrypt_key,
    1405                 :          0 :                        lo->lo_encrypt_key_size);
    1406                 :            :         }
    1407                 :            : 
    1408                 :            :         /* Drop loop_ctl_mutex while we call into the filesystem. */
    1409                 :          0 :         path = lo->lo_backing_file->f_path;
    1410                 :          0 :         path_get(&path);
    1411                 :          0 :         mutex_unlock(&loop_ctl_mutex);
    1412                 :          0 :         ret = vfs_getattr(&path, &stat, STATX_INO, AT_STATX_SYNC_AS_STAT);
    1413         [ #  # ]:          0 :         if (!ret) {
    1414                 :          0 :                 info->lo_device = huge_encode_dev(stat.dev);
    1415                 :          0 :                 info->lo_inode = stat.ino;
    1416                 :          0 :                 info->lo_rdevice = huge_encode_dev(stat.rdev);
    1417                 :            :         }
    1418                 :          0 :         path_put(&path);
    1419                 :          0 :         return ret;
    1420                 :            : }
    1421                 :            : 
    1422                 :            : static void
    1423                 :          0 : loop_info64_from_old(const struct loop_info *info, struct loop_info64 *info64)
    1424                 :            : {
    1425                 :          0 :         memset(info64, 0, sizeof(*info64));
    1426                 :          0 :         info64->lo_number = info->lo_number;
    1427                 :          0 :         info64->lo_device = info->lo_device;
    1428                 :          0 :         info64->lo_inode = info->lo_inode;
    1429                 :          0 :         info64->lo_rdevice = info->lo_rdevice;
    1430                 :          0 :         info64->lo_offset = info->lo_offset;
    1431                 :          0 :         info64->lo_sizelimit = 0;
    1432                 :          0 :         info64->lo_encrypt_type = info->lo_encrypt_type;
    1433                 :          0 :         info64->lo_encrypt_key_size = info->lo_encrypt_key_size;
    1434                 :          0 :         info64->lo_flags = info->lo_flags;
    1435                 :          0 :         info64->lo_init[0] = info->lo_init[0];
    1436                 :          0 :         info64->lo_init[1] = info->lo_init[1];
    1437         [ #  # ]:          0 :         if (info->lo_encrypt_type == LO_CRYPT_CRYPTOAPI)
    1438                 :          0 :                 memcpy(info64->lo_crypt_name, info->lo_name, LO_NAME_SIZE);
    1439                 :            :         else
    1440                 :          0 :                 memcpy(info64->lo_file_name, info->lo_name, LO_NAME_SIZE);
    1441                 :          0 :         memcpy(info64->lo_encrypt_key, info->lo_encrypt_key, LO_KEY_SIZE);
    1442                 :          0 : }
    1443                 :            : 
    1444                 :            : static int
    1445                 :          0 : loop_info64_to_old(const struct loop_info64 *info64, struct loop_info *info)
    1446                 :            : {
    1447                 :          0 :         memset(info, 0, sizeof(*info));
    1448                 :          0 :         info->lo_number = info64->lo_number;
    1449                 :          0 :         info->lo_device = info64->lo_device;
    1450                 :          0 :         info->lo_inode = info64->lo_inode;
    1451                 :          0 :         info->lo_rdevice = info64->lo_rdevice;
    1452                 :          0 :         info->lo_offset = info64->lo_offset;
    1453                 :          0 :         info->lo_encrypt_type = info64->lo_encrypt_type;
    1454                 :          0 :         info->lo_encrypt_key_size = info64->lo_encrypt_key_size;
    1455                 :          0 :         info->lo_flags = info64->lo_flags;
    1456                 :          0 :         info->lo_init[0] = info64->lo_init[0];
    1457                 :          0 :         info->lo_init[1] = info64->lo_init[1];
    1458         [ #  # ]:          0 :         if (info->lo_encrypt_type == LO_CRYPT_CRYPTOAPI)
    1459                 :          0 :                 memcpy(info->lo_name, info64->lo_crypt_name, LO_NAME_SIZE);
    1460                 :            :         else
    1461                 :          0 :                 memcpy(info->lo_name, info64->lo_file_name, LO_NAME_SIZE);
    1462                 :          0 :         memcpy(info->lo_encrypt_key, info64->lo_encrypt_key, LO_KEY_SIZE);
    1463                 :            : 
    1464                 :            :         /* error in case values were truncated */
    1465   [ #  #  #  # ]:          0 :         if (info->lo_device != info64->lo_device ||
    1466         [ #  # ]:          0 :             info->lo_rdevice != info64->lo_rdevice ||
    1467         [ #  # ]:          0 :             info->lo_inode != info64->lo_inode ||
    1468                 :          0 :             info->lo_offset != info64->lo_offset)
    1469                 :            :                 return -EOVERFLOW;
    1470                 :            : 
    1471                 :          0 :         return 0;
    1472                 :            : }
    1473                 :            : 
    1474                 :            : static int
    1475                 :          0 : loop_set_status_old(struct loop_device *lo, const struct loop_info __user *arg)
    1476                 :            : {
    1477                 :            :         struct loop_info info;
    1478                 :            :         struct loop_info64 info64;
    1479                 :            : 
    1480         [ #  # ]:          0 :         if (copy_from_user(&info, arg, sizeof (struct loop_info)))
    1481                 :            :                 return -EFAULT;
    1482                 :          0 :         loop_info64_from_old(&info, &info64);
    1483                 :          0 :         return loop_set_status(lo, &info64);
    1484                 :            : }
    1485                 :            : 
    1486                 :            : static int
    1487                 :          0 : loop_set_status64(struct loop_device *lo, const struct loop_info64 __user *arg)
    1488                 :            : {
    1489                 :            :         struct loop_info64 info64;
    1490                 :            : 
    1491         [ #  # ]:          0 :         if (copy_from_user(&info64, arg, sizeof (struct loop_info64)))
    1492                 :            :                 return -EFAULT;
    1493                 :          0 :         return loop_set_status(lo, &info64);
    1494                 :            : }
    1495                 :            : 
    1496                 :            : static int
    1497                 :          0 : loop_get_status_old(struct loop_device *lo, struct loop_info __user *arg) {
    1498                 :            :         struct loop_info info;
    1499                 :            :         struct loop_info64 info64;
    1500                 :            :         int err;
    1501                 :            : 
    1502         [ #  # ]:          0 :         if (!arg)
    1503                 :            :                 return -EINVAL;
    1504                 :          0 :         err = loop_get_status(lo, &info64);
    1505         [ #  # ]:          0 :         if (!err)
    1506                 :          0 :                 err = loop_info64_to_old(&info64, &info);
    1507   [ #  #  #  # ]:          0 :         if (!err && copy_to_user(arg, &info, sizeof(info)))
    1508                 :            :                 err = -EFAULT;
    1509                 :            : 
    1510                 :          0 :         return err;
    1511                 :            : }
    1512                 :            : 
    1513                 :            : static int
    1514                 :          0 : loop_get_status64(struct loop_device *lo, struct loop_info64 __user *arg) {
    1515                 :            :         struct loop_info64 info64;
    1516                 :            :         int err;
    1517                 :            : 
    1518         [ #  # ]:          0 :         if (!arg)
    1519                 :            :                 return -EINVAL;
    1520                 :          0 :         err = loop_get_status(lo, &info64);
    1521   [ #  #  #  # ]:          0 :         if (!err && copy_to_user(arg, &info64, sizeof(info64)))
    1522                 :            :                 err = -EFAULT;
    1523                 :            : 
    1524                 :          0 :         return err;
    1525                 :            : }
    1526                 :            : 
    1527                 :          0 : static int loop_set_capacity(struct loop_device *lo)
    1528                 :            : {
    1529         [ #  # ]:          0 :         if (unlikely(lo->lo_state != Lo_bound))
    1530                 :            :                 return -ENXIO;
    1531                 :            : 
    1532                 :          0 :         return figure_loop_size(lo, lo->lo_offset, lo->lo_sizelimit);
    1533                 :            : }
    1534                 :            : 
    1535                 :            : static int loop_set_dio(struct loop_device *lo, unsigned long arg)
    1536                 :            : {
    1537                 :            :         int error = -ENXIO;
    1538         [ #  # ]:          0 :         if (lo->lo_state != Lo_bound)
    1539                 :            :                 goto out;
    1540                 :            : 
    1541                 :          0 :         __loop_update_dio(lo, !!arg);
    1542         [ #  # ]:          0 :         if (lo->use_dio == !!arg)
    1543                 :            :                 return 0;
    1544                 :            :         error = -EINVAL;
    1545                 :            :  out:
    1546                 :            :         return error;
    1547                 :            : }
    1548                 :            : 
    1549                 :          0 : static int loop_set_block_size(struct loop_device *lo, unsigned long arg)
    1550                 :            : {
    1551                 :            :         int err = 0;
    1552                 :            : 
    1553         [ #  # ]:          0 :         if (lo->lo_state != Lo_bound)
    1554                 :            :                 return -ENXIO;
    1555                 :            : 
    1556   [ #  #  #  # ]:          0 :         if (arg < 512 || arg > PAGE_SIZE || !is_power_of_2(arg))
    1557                 :            :                 return -EINVAL;
    1558                 :            : 
    1559         [ #  # ]:          0 :         if (lo->lo_queue->limits.logical_block_size != arg) {
    1560                 :          0 :                 sync_blockdev(lo->lo_device);
    1561                 :          0 :                 invalidate_bdev(lo->lo_device);
    1562                 :            :         }
    1563                 :            : 
    1564                 :          0 :         blk_mq_freeze_queue(lo->lo_queue);
    1565                 :            : 
    1566                 :            :         /* invalidate_bdev should have truncated all the pages */
    1567   [ #  #  #  # ]:          0 :         if (lo->lo_queue->limits.logical_block_size != arg &&
    1568                 :          0 :                         lo->lo_device->bd_inode->i_mapping->nrpages) {
    1569                 :            :                 err = -EAGAIN;
    1570                 :          0 :                 pr_warn("%s: loop%d (%s) has still dirty pages (nrpages=%lu)\n",
    1571                 :            :                         __func__, lo->lo_number, lo->lo_file_name,
    1572                 :            :                         lo->lo_device->bd_inode->i_mapping->nrpages);
    1573                 :          0 :                 goto out_unfreeze;
    1574                 :            :         }
    1575                 :            : 
    1576                 :          0 :         blk_queue_logical_block_size(lo->lo_queue, arg);
    1577                 :          0 :         blk_queue_physical_block_size(lo->lo_queue, arg);
    1578                 :          0 :         blk_queue_io_min(lo->lo_queue, arg);
    1579                 :          0 :         loop_update_dio(lo);
    1580                 :            : out_unfreeze:
    1581                 :          0 :         blk_mq_unfreeze_queue(lo->lo_queue);
    1582                 :            : 
    1583                 :          0 :         return err;
    1584                 :            : }
    1585                 :            : 
    1586                 :          0 : static int lo_simple_ioctl(struct loop_device *lo, unsigned int cmd,
    1587                 :            :                            unsigned long arg)
    1588                 :            : {
    1589                 :            :         int err;
    1590                 :            : 
    1591                 :          0 :         err = mutex_lock_killable(&loop_ctl_mutex);
    1592         [ #  # ]:          0 :         if (err)
    1593                 :            :                 return err;
    1594   [ #  #  #  # ]:          0 :         switch (cmd) {
    1595                 :            :         case LOOP_SET_CAPACITY:
    1596                 :          0 :                 err = loop_set_capacity(lo);
    1597                 :          0 :                 break;
    1598                 :            :         case LOOP_SET_DIRECT_IO:
    1599                 :            :                 err = loop_set_dio(lo, arg);
    1600                 :          0 :                 break;
    1601                 :            :         case LOOP_SET_BLOCK_SIZE:
    1602                 :          0 :                 err = loop_set_block_size(lo, arg);
    1603                 :          0 :                 break;
    1604                 :            :         default:
    1605         [ #  # ]:          0 :                 err = lo->ioctl ? lo->ioctl(lo, cmd, arg) : -EINVAL;
    1606                 :            :         }
    1607                 :          0 :         mutex_unlock(&loop_ctl_mutex);
    1608                 :          0 :         return err;
    1609                 :            : }
    1610                 :            : 
    1611                 :          0 : static int lo_ioctl(struct block_device *bdev, fmode_t mode,
    1612                 :            :         unsigned int cmd, unsigned long arg)
    1613                 :            : {
    1614                 :          0 :         struct loop_device *lo = bdev->bd_disk->private_data;
    1615                 :            :         int err;
    1616                 :            : 
    1617   [ #  #  #  #  :          0 :         switch (cmd) {
             #  #  #  #  
                      # ]
    1618                 :            :         case LOOP_SET_FD:
    1619                 :          0 :                 return loop_set_fd(lo, mode, bdev, arg);
    1620                 :            :         case LOOP_CHANGE_FD:
    1621                 :          0 :                 return loop_change_fd(lo, bdev, arg);
    1622                 :            :         case LOOP_CLR_FD:
    1623                 :          0 :                 return loop_clr_fd(lo);
    1624                 :            :         case LOOP_SET_STATUS:
    1625                 :            :                 err = -EPERM;
    1626   [ #  #  #  # ]:          0 :                 if ((mode & FMODE_WRITE) || capable(CAP_SYS_ADMIN)) {
    1627                 :          0 :                         err = loop_set_status_old(lo,
    1628                 :            :                                         (struct loop_info __user *)arg);
    1629                 :            :                 }
    1630                 :            :                 break;
    1631                 :            :         case LOOP_GET_STATUS:
    1632                 :          0 :                 return loop_get_status_old(lo, (struct loop_info __user *) arg);
    1633                 :            :         case LOOP_SET_STATUS64:
    1634                 :            :                 err = -EPERM;
    1635   [ #  #  #  # ]:          0 :                 if ((mode & FMODE_WRITE) || capable(CAP_SYS_ADMIN)) {
    1636                 :          0 :                         err = loop_set_status64(lo,
    1637                 :            :                                         (struct loop_info64 __user *) arg);
    1638                 :            :                 }
    1639                 :            :                 break;
    1640                 :            :         case LOOP_GET_STATUS64:
    1641                 :          0 :                 return loop_get_status64(lo, (struct loop_info64 __user *) arg);
    1642                 :            :         case LOOP_SET_CAPACITY:
    1643                 :            :         case LOOP_SET_DIRECT_IO:
    1644                 :            :         case LOOP_SET_BLOCK_SIZE:
    1645   [ #  #  #  # ]:          0 :                 if (!(mode & FMODE_WRITE) && !capable(CAP_SYS_ADMIN))
    1646                 :            :                         return -EPERM;
    1647                 :            :                 /* Fall through */
    1648                 :            :         default:
    1649                 :          0 :                 err = lo_simple_ioctl(lo, cmd, arg);
    1650                 :          0 :                 break;
    1651                 :            :         }
    1652                 :            : 
    1653                 :          0 :         return err;
    1654                 :            : }
    1655                 :            : 
    1656                 :            : #ifdef CONFIG_COMPAT
    1657                 :            : struct compat_loop_info {
    1658                 :            :         compat_int_t    lo_number;      /* ioctl r/o */
    1659                 :            :         compat_dev_t    lo_device;      /* ioctl r/o */
    1660                 :            :         compat_ulong_t  lo_inode;       /* ioctl r/o */
    1661                 :            :         compat_dev_t    lo_rdevice;     /* ioctl r/o */
    1662                 :            :         compat_int_t    lo_offset;
    1663                 :            :         compat_int_t    lo_encrypt_type;
    1664                 :            :         compat_int_t    lo_encrypt_key_size;    /* ioctl w/o */
    1665                 :            :         compat_int_t    lo_flags;       /* ioctl r/o */
    1666                 :            :         char            lo_name[LO_NAME_SIZE];
    1667                 :            :         unsigned char   lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */
    1668                 :            :         compat_ulong_t  lo_init[2];
    1669                 :            :         char            reserved[4];
    1670                 :            : };
    1671                 :            : 
    1672                 :            : /*
    1673                 :            :  * Transfer 32-bit compatibility structure in userspace to 64-bit loop info
    1674                 :            :  * - noinlined to reduce stack space usage in main part of driver
    1675                 :            :  */
    1676                 :            : static noinline int
    1677                 :            : loop_info64_from_compat(const struct compat_loop_info __user *arg,
    1678                 :            :                         struct loop_info64 *info64)
    1679                 :            : {
    1680                 :            :         struct compat_loop_info info;
    1681                 :            : 
    1682                 :            :         if (copy_from_user(&info, arg, sizeof(info)))
    1683                 :            :                 return -EFAULT;
    1684                 :            : 
    1685                 :            :         memset(info64, 0, sizeof(*info64));
    1686                 :            :         info64->lo_number = info.lo_number;
    1687                 :            :         info64->lo_device = info.lo_device;
    1688                 :            :         info64->lo_inode = info.lo_inode;
    1689                 :            :         info64->lo_rdevice = info.lo_rdevice;
    1690                 :            :         info64->lo_offset = info.lo_offset;
    1691                 :            :         info64->lo_sizelimit = 0;
    1692                 :            :         info64->lo_encrypt_type = info.lo_encrypt_type;
    1693                 :            :         info64->lo_encrypt_key_size = info.lo_encrypt_key_size;
    1694                 :            :         info64->lo_flags = info.lo_flags;
    1695                 :            :         info64->lo_init[0] = info.lo_init[0];
    1696                 :            :         info64->lo_init[1] = info.lo_init[1];
    1697                 :            :         if (info.lo_encrypt_type == LO_CRYPT_CRYPTOAPI)
    1698                 :            :                 memcpy(info64->lo_crypt_name, info.lo_name, LO_NAME_SIZE);
    1699                 :            :         else
    1700                 :            :                 memcpy(info64->lo_file_name, info.lo_name, LO_NAME_SIZE);
    1701                 :            :         memcpy(info64->lo_encrypt_key, info.lo_encrypt_key, LO_KEY_SIZE);
    1702                 :            :         return 0;
    1703                 :            : }
    1704                 :            : 
    1705                 :            : /*
    1706                 :            :  * Transfer 64-bit loop info to 32-bit compatibility structure in userspace
    1707                 :            :  * - noinlined to reduce stack space usage in main part of driver
    1708                 :            :  */
    1709                 :            : static noinline int
    1710                 :            : loop_info64_to_compat(const struct loop_info64 *info64,
    1711                 :            :                       struct compat_loop_info __user *arg)
    1712                 :            : {
    1713                 :            :         struct compat_loop_info info;
    1714                 :            : 
    1715                 :            :         memset(&info, 0, sizeof(info));
    1716                 :            :         info.lo_number = info64->lo_number;
    1717                 :            :         info.lo_device = info64->lo_device;
    1718                 :            :         info.lo_inode = info64->lo_inode;
    1719                 :            :         info.lo_rdevice = info64->lo_rdevice;
    1720                 :            :         info.lo_offset = info64->lo_offset;
    1721                 :            :         info.lo_encrypt_type = info64->lo_encrypt_type;
    1722                 :            :         info.lo_encrypt_key_size = info64->lo_encrypt_key_size;
    1723                 :            :         info.lo_flags = info64->lo_flags;
    1724                 :            :         info.lo_init[0] = info64->lo_init[0];
    1725                 :            :         info.lo_init[1] = info64->lo_init[1];
    1726                 :            :         if (info.lo_encrypt_type == LO_CRYPT_CRYPTOAPI)
    1727                 :            :                 memcpy(info.lo_name, info64->lo_crypt_name, LO_NAME_SIZE);
    1728                 :            :         else
    1729                 :            :                 memcpy(info.lo_name, info64->lo_file_name, LO_NAME_SIZE);
    1730                 :            :         memcpy(info.lo_encrypt_key, info64->lo_encrypt_key, LO_KEY_SIZE);
    1731                 :            : 
    1732                 :            :         /* error in case values were truncated */
    1733                 :            :         if (info.lo_device != info64->lo_device ||
    1734                 :            :             info.lo_rdevice != info64->lo_rdevice ||
    1735                 :            :             info.lo_inode != info64->lo_inode ||
    1736                 :            :             info.lo_offset != info64->lo_offset ||
    1737                 :            :             info.lo_init[0] != info64->lo_init[0] ||
    1738                 :            :             info.lo_init[1] != info64->lo_init[1])
    1739                 :            :                 return -EOVERFLOW;
    1740                 :            : 
    1741                 :            :         if (copy_to_user(arg, &info, sizeof(info)))
    1742                 :            :                 return -EFAULT;
    1743                 :            :         return 0;
    1744                 :            : }
    1745                 :            : 
    1746                 :            : static int
    1747                 :            : loop_set_status_compat(struct loop_device *lo,
    1748                 :            :                        const struct compat_loop_info __user *arg)
    1749                 :            : {
    1750                 :            :         struct loop_info64 info64;
    1751                 :            :         int ret;
    1752                 :            : 
    1753                 :            :         ret = loop_info64_from_compat(arg, &info64);
    1754                 :            :         if (ret < 0)
    1755                 :            :                 return ret;
    1756                 :            :         return loop_set_status(lo, &info64);
    1757                 :            : }
    1758                 :            : 
    1759                 :            : static int
    1760                 :            : loop_get_status_compat(struct loop_device *lo,
    1761                 :            :                        struct compat_loop_info __user *arg)
    1762                 :            : {
    1763                 :            :         struct loop_info64 info64;
    1764                 :            :         int err;
    1765                 :            : 
    1766                 :            :         if (!arg)
    1767                 :            :                 return -EINVAL;
    1768                 :            :         err = loop_get_status(lo, &info64);
    1769                 :            :         if (!err)
    1770                 :            :                 err = loop_info64_to_compat(&info64, arg);
    1771                 :            :         return err;
    1772                 :            : }
    1773                 :            : 
    1774                 :            : static int lo_compat_ioctl(struct block_device *bdev, fmode_t mode,
    1775                 :            :                            unsigned int cmd, unsigned long arg)
    1776                 :            : {
    1777                 :            :         struct loop_device *lo = bdev->bd_disk->private_data;
    1778                 :            :         int err;
    1779                 :            : 
    1780                 :            :         switch(cmd) {
    1781                 :            :         case LOOP_SET_STATUS:
    1782                 :            :                 err = loop_set_status_compat(lo,
    1783                 :            :                              (const struct compat_loop_info __user *)arg);
    1784                 :            :                 break;
    1785                 :            :         case LOOP_GET_STATUS:
    1786                 :            :                 err = loop_get_status_compat(lo,
    1787                 :            :                                      (struct compat_loop_info __user *)arg);
    1788                 :            :                 break;
    1789                 :            :         case LOOP_SET_CAPACITY:
    1790                 :            :         case LOOP_CLR_FD:
    1791                 :            :         case LOOP_GET_STATUS64:
    1792                 :            :         case LOOP_SET_STATUS64:
    1793                 :            :                 arg = (unsigned long) compat_ptr(arg);
    1794                 :            :                 /* fall through */
    1795                 :            :         case LOOP_SET_FD:
    1796                 :            :         case LOOP_CHANGE_FD:
    1797                 :            :         case LOOP_SET_BLOCK_SIZE:
    1798                 :            :         case LOOP_SET_DIRECT_IO:
    1799                 :            :                 err = lo_ioctl(bdev, mode, cmd, arg);
    1800                 :            :                 break;
    1801                 :            :         default:
    1802                 :            :                 err = -ENOIOCTLCMD;
    1803                 :            :                 break;
    1804                 :            :         }
    1805                 :            :         return err;
    1806                 :            : }
    1807                 :            : #endif
    1808                 :            : 
    1809                 :       3311 : static int lo_open(struct block_device *bdev, fmode_t mode)
    1810                 :            : {
    1811                 :            :         struct loop_device *lo;
    1812                 :            :         int err;
    1813                 :            : 
    1814                 :       3311 :         err = mutex_lock_killable(&loop_ctl_mutex);
    1815         [ +  - ]:       3312 :         if (err)
    1816                 :            :                 return err;
    1817                 :       3312 :         lo = bdev->bd_disk->private_data;
    1818         [ +  - ]:       3312 :         if (!lo) {
    1819                 :            :                 err = -ENXIO;
    1820                 :            :                 goto out;
    1821                 :            :         }
    1822                 :            : 
    1823                 :       3312 :         atomic_inc(&lo->lo_refcnt);
    1824                 :            : out:
    1825                 :       3312 :         mutex_unlock(&loop_ctl_mutex);
    1826                 :       3312 :         return err;
    1827                 :            : }
    1828                 :            : 
    1829                 :       3312 : static void lo_release(struct gendisk *disk, fmode_t mode)
    1830                 :            : {
    1831                 :            :         struct loop_device *lo;
    1832                 :            : 
    1833                 :       3312 :         mutex_lock(&loop_ctl_mutex);
    1834                 :       3312 :         lo = disk->private_data;
    1835         [ +  + ]:       3312 :         if (atomic_dec_return(&lo->lo_refcnt))
    1836                 :            :                 goto out_unlock;
    1837                 :            : 
    1838         [ -  + ]:       1656 :         if (lo->lo_flags & LO_FLAGS_AUTOCLEAR) {
    1839         [ #  # ]:          0 :                 if (lo->lo_state != Lo_bound)
    1840                 :            :                         goto out_unlock;
    1841                 :          0 :                 lo->lo_state = Lo_rundown;
    1842                 :          0 :                 mutex_unlock(&loop_ctl_mutex);
    1843                 :            :                 /*
    1844                 :            :                  * In autoclear mode, stop the loop thread
    1845                 :            :                  * and remove configuration after last close.
    1846                 :            :                  */
    1847                 :          0 :                 __loop_clr_fd(lo, true);
    1848                 :       3312 :                 return;
    1849         [ -  + ]:       1656 :         } else if (lo->lo_state == Lo_bound) {
    1850                 :            :                 /*
    1851                 :            :                  * Otherwise keep thread (if running) and config,
    1852                 :            :                  * but flush possible ongoing bios in thread.
    1853                 :            :                  */
    1854                 :          0 :                 blk_mq_freeze_queue(lo->lo_queue);
    1855                 :          0 :                 blk_mq_unfreeze_queue(lo->lo_queue);
    1856                 :            :         }
    1857                 :            : 
    1858                 :            : out_unlock:
    1859                 :       3312 :         mutex_unlock(&loop_ctl_mutex);
    1860                 :            : }
    1861                 :            : 
    1862                 :            : static const struct block_device_operations lo_fops = {
    1863                 :            :         .owner =        THIS_MODULE,
    1864                 :            :         .open =         lo_open,
    1865                 :            :         .release =      lo_release,
    1866                 :            :         .ioctl =        lo_ioctl,
    1867                 :            : #ifdef CONFIG_COMPAT
    1868                 :            :         .compat_ioctl = lo_compat_ioctl,
    1869                 :            : #endif
    1870                 :            : };
    1871                 :            : 
    1872                 :            : /*
    1873                 :            :  * And now the modules code and kernel interface.
    1874                 :            :  */
    1875                 :            : static int max_loop;
    1876                 :            : module_param(max_loop, int, 0444);
    1877                 :            : MODULE_PARM_DESC(max_loop, "Maximum number of loop devices");
    1878                 :            : module_param(max_part, int, 0444);
    1879                 :            : MODULE_PARM_DESC(max_part, "Maximum number of partitions per loop device");
    1880                 :            : MODULE_LICENSE("GPL");
    1881                 :            : MODULE_ALIAS_BLOCKDEV_MAJOR(LOOP_MAJOR);
    1882                 :            : 
    1883                 :          0 : int loop_register_transfer(struct loop_func_table *funcs)
    1884                 :            : {
    1885                 :          0 :         unsigned int n = funcs->number;
    1886                 :            : 
    1887   [ #  #  #  # ]:          0 :         if (n >= MAX_LO_CRYPT || xfer_funcs[n])
    1888                 :            :                 return -EINVAL;
    1889                 :          0 :         xfer_funcs[n] = funcs;
    1890                 :          0 :         return 0;
    1891                 :            : }
    1892                 :            : 
    1893                 :          0 : static int unregister_transfer_cb(int id, void *ptr, void *data)
    1894                 :            : {
    1895                 :            :         struct loop_device *lo = ptr;
    1896                 :            :         struct loop_func_table *xfer = data;
    1897                 :            : 
    1898                 :          0 :         mutex_lock(&loop_ctl_mutex);
    1899         [ #  # ]:          0 :         if (lo->lo_encryption == xfer)
    1900                 :          0 :                 loop_release_xfer(lo);
    1901                 :          0 :         mutex_unlock(&loop_ctl_mutex);
    1902                 :          0 :         return 0;
    1903                 :            : }
    1904                 :            : 
    1905                 :          0 : int loop_unregister_transfer(int number)
    1906                 :            : {
    1907                 :          0 :         unsigned int n = number;
    1908                 :            :         struct loop_func_table *xfer;
    1909                 :            : 
    1910   [ #  #  #  # ]:          0 :         if (n == 0 || n >= MAX_LO_CRYPT || (xfer = xfer_funcs[n]) == NULL)
    1911                 :            :                 return -EINVAL;
    1912                 :            : 
    1913                 :          0 :         xfer_funcs[n] = NULL;
    1914                 :          0 :         idr_for_each(&loop_index_idr, &unregister_transfer_cb, xfer);
    1915                 :          0 :         return 0;
    1916                 :            : }
    1917                 :            : 
    1918                 :            : EXPORT_SYMBOL(loop_register_transfer);
    1919                 :            : EXPORT_SYMBOL(loop_unregister_transfer);
    1920                 :            : 
    1921                 :          0 : static blk_status_t loop_queue_rq(struct blk_mq_hw_ctx *hctx,
    1922                 :            :                 const struct blk_mq_queue_data *bd)
    1923                 :            : {
    1924                 :          0 :         struct request *rq = bd->rq;
    1925                 :            :         struct loop_cmd *cmd = blk_mq_rq_to_pdu(rq);
    1926                 :          0 :         struct loop_device *lo = rq->q->queuedata;
    1927                 :            : 
    1928                 :          0 :         blk_mq_start_request(rq);
    1929                 :            : 
    1930         [ #  # ]:          0 :         if (lo->lo_state != Lo_bound)
    1931                 :            :                 return BLK_STS_IOERR;
    1932                 :            : 
    1933         [ #  # ]:          0 :         switch (req_op(rq)) {
    1934                 :            :         case REQ_OP_FLUSH:
    1935                 :            :         case REQ_OP_DISCARD:
    1936                 :            :         case REQ_OP_WRITE_ZEROES:
    1937                 :          0 :                 cmd->use_aio = false;
    1938                 :          0 :                 break;
    1939                 :            :         default:
    1940                 :          0 :                 cmd->use_aio = lo->use_dio;
    1941                 :          0 :                 break;
    1942                 :            :         }
    1943                 :            : 
    1944                 :            :         /* always use the first bio's css */
    1945                 :            : #ifdef CONFIG_BLK_CGROUP
    1946   [ #  #  #  #  :          0 :         if (cmd->use_aio && rq->bio && rq->bio->bi_blkg) {
                   #  # ]
    1947                 :          0 :                 cmd->css = &bio_blkcg(rq->bio)->css;
    1948                 :            :                 css_get(cmd->css);
    1949                 :            :         } else
    1950                 :            : #endif
    1951                 :          0 :                 cmd->css = NULL;
    1952                 :          0 :         kthread_queue_work(&lo->worker, &cmd->work);
    1953                 :            : 
    1954                 :          0 :         return BLK_STS_OK;
    1955                 :            : }
    1956                 :            : 
    1957                 :          0 : static void loop_handle_cmd(struct loop_cmd *cmd)
    1958                 :            : {
    1959                 :            :         struct request *rq = blk_mq_rq_from_pdu(cmd);
    1960                 :          0 :         const bool write = op_is_write(req_op(rq));
    1961                 :          0 :         struct loop_device *lo = rq->q->queuedata;
    1962                 :            :         int ret = 0;
    1963                 :            : 
    1964   [ #  #  #  # ]:          0 :         if (write && (lo->lo_flags & LO_FLAGS_READ_ONLY)) {
    1965                 :            :                 ret = -EIO;
    1966                 :            :                 goto failed;
    1967                 :            :         }
    1968                 :            : 
    1969                 :          0 :         ret = do_req_filebacked(lo, rq);
    1970                 :            :  failed:
    1971                 :            :         /* complete non-aio request */
    1972   [ #  #  #  # ]:          0 :         if (!cmd->use_aio || ret) {
    1973         [ #  # ]:          0 :                 cmd->ret = ret ? -EIO : 0;
    1974                 :          0 :                 blk_mq_complete_request(rq);
    1975                 :            :         }
    1976                 :          0 : }
    1977                 :            : 
    1978                 :          0 : static void loop_queue_work(struct kthread_work *work)
    1979                 :            : {
    1980                 :            :         struct loop_cmd *cmd =
    1981                 :            :                 container_of(work, struct loop_cmd, work);
    1982                 :            : 
    1983                 :          0 :         loop_handle_cmd(cmd);
    1984                 :          0 : }
    1985                 :            : 
    1986                 :     637560 : static int loop_init_request(struct blk_mq_tag_set *set, struct request *rq,
    1987                 :            :                 unsigned int hctx_idx, unsigned int numa_node)
    1988                 :            : {
    1989                 :            :         struct loop_cmd *cmd = blk_mq_rq_to_pdu(rq);
    1990                 :            : 
    1991                 :    1275120 :         kthread_init_work(&cmd->work, loop_queue_work);
    1992                 :     637560 :         return 0;
    1993                 :            : }
    1994                 :            : 
    1995                 :            : static const struct blk_mq_ops loop_mq_ops = {
    1996                 :            :         .queue_rq       = loop_queue_rq,
    1997                 :            :         .init_request   = loop_init_request,
    1998                 :            :         .complete       = lo_complete_rq,
    1999                 :            : };
    2000                 :            : 
    2001                 :       1656 : static int loop_add(struct loop_device **l, int i)
    2002                 :            : {
    2003                 :            :         struct loop_device *lo;
    2004                 :            :         struct gendisk *disk;
    2005                 :            :         int err;
    2006                 :            : 
    2007                 :            :         err = -ENOMEM;
    2008                 :       1656 :         lo = kzalloc(sizeof(*lo), GFP_KERNEL);
    2009         [ +  - ]:       1656 :         if (!lo)
    2010                 :            :                 goto out;
    2011                 :            : 
    2012                 :       1656 :         lo->lo_state = Lo_unbound;
    2013                 :            : 
    2014                 :            :         /* allocate id, if @id >= 0, we're requesting that specific id */
    2015         [ +  - ]:       1656 :         if (i >= 0) {
    2016                 :       1656 :                 err = idr_alloc(&loop_index_idr, lo, i, i + 1, GFP_KERNEL);
    2017         [ -  + ]:       1656 :                 if (err == -ENOSPC)
    2018                 :            :                         err = -EEXIST;
    2019                 :            :         } else {
    2020                 :          0 :                 err = idr_alloc(&loop_index_idr, lo, 0, 0, GFP_KERNEL);
    2021                 :            :         }
    2022         [ +  - ]:       1656 :         if (err < 0)
    2023                 :            :                 goto out_free_dev;
    2024                 :            :         i = err;
    2025                 :            : 
    2026                 :            :         err = -ENOMEM;
    2027                 :       1656 :         lo->tag_set.ops = &loop_mq_ops;
    2028                 :       1656 :         lo->tag_set.nr_hw_queues = 1;
    2029                 :       1656 :         lo->tag_set.queue_depth = 128;
    2030                 :       1656 :         lo->tag_set.numa_node = NUMA_NO_NODE;
    2031                 :       1656 :         lo->tag_set.cmd_size = sizeof(struct loop_cmd);
    2032                 :       1656 :         lo->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
    2033                 :       1656 :         lo->tag_set.driver_data = lo;
    2034                 :            : 
    2035                 :       1656 :         err = blk_mq_alloc_tag_set(&lo->tag_set);
    2036         [ +  - ]:       1656 :         if (err)
    2037                 :            :                 goto out_free_idr;
    2038                 :            : 
    2039                 :       1656 :         lo->lo_queue = blk_mq_init_queue(&lo->tag_set);
    2040         [ -  + ]:       1656 :         if (IS_ERR(lo->lo_queue)) {
    2041                 :            :                 err = PTR_ERR(lo->lo_queue);
    2042                 :          0 :                 goto out_cleanup_tags;
    2043                 :            :         }
    2044                 :       1656 :         lo->lo_queue->queuedata = lo;
    2045                 :            : 
    2046                 :       1656 :         blk_queue_max_hw_sectors(lo->lo_queue, BLK_DEF_MAX_SECTORS);
    2047                 :            : 
    2048                 :            :         /*
    2049                 :            :          * By default, we do buffer IO, so it doesn't make sense to enable
    2050                 :            :          * merge because the I/O submitted to backing file is handled page by
    2051                 :            :          * page. For directio mode, merge does help to dispatch bigger request
    2052                 :            :          * to underlayer disk. We will enable merge once directio is enabled.
    2053                 :            :          */
    2054                 :       1656 :         blk_queue_flag_set(QUEUE_FLAG_NOMERGES, lo->lo_queue);
    2055                 :            : 
    2056                 :            :         err = -ENOMEM;
    2057                 :       1656 :         disk = lo->lo_disk = alloc_disk(1 << part_shift);
    2058         [ +  - ]:       1656 :         if (!disk)
    2059                 :            :                 goto out_free_queue;
    2060                 :            : 
    2061                 :            :         /*
    2062                 :            :          * Disable partition scanning by default. The in-kernel partition
    2063                 :            :          * scanning can be requested individually per-device during its
    2064                 :            :          * setup. Userspace can always add and remove partitions from all
    2065                 :            :          * devices. The needed partition minors are allocated from the
    2066                 :            :          * extended minor space, the main loop device numbers will continue
    2067                 :            :          * to match the loop minors, regardless of the number of partitions
    2068                 :            :          * used.
    2069                 :            :          *
    2070                 :            :          * If max_part is given, partition scanning is globally enabled for
    2071                 :            :          * all loop devices. The minors for the main loop devices will be
    2072                 :            :          * multiples of max_part.
    2073                 :            :          *
    2074                 :            :          * Note: Global-for-all-devices, set-only-at-init, read-only module
    2075                 :            :          * parameteters like 'max_loop' and 'max_part' make things needlessly
    2076                 :            :          * complicated, are too static, inflexible and may surprise
    2077                 :            :          * userspace tools. Parameters like this in general should be avoided.
    2078                 :            :          */
    2079         [ +  - ]:       1656 :         if (!part_shift)
    2080                 :       1656 :                 disk->flags |= GENHD_FL_NO_PART_SCAN;
    2081                 :       1656 :         disk->flags |= GENHD_FL_EXT_DEVT;
    2082                 :            :         atomic_set(&lo->lo_refcnt, 0);
    2083                 :       1656 :         lo->lo_number                = i;
    2084                 :       1656 :         spin_lock_init(&lo->lo_lock);
    2085                 :       1656 :         disk->major          = LOOP_MAJOR;
    2086                 :       1656 :         disk->first_minor    = i << part_shift;
    2087                 :       1656 :         disk->fops           = &lo_fops;
    2088                 :       1656 :         disk->private_data   = lo;
    2089                 :       1656 :         disk->queue          = lo->lo_queue;
    2090                 :       1656 :         sprintf(disk->disk_name, "loop%d", i);
    2091                 :            :         add_disk(disk);
    2092                 :       1656 :         *l = lo;
    2093                 :       1656 :         return lo->lo_number;
    2094                 :            : 
    2095                 :            : out_free_queue:
    2096                 :          0 :         blk_cleanup_queue(lo->lo_queue);
    2097                 :            : out_cleanup_tags:
    2098                 :          0 :         blk_mq_free_tag_set(&lo->tag_set);
    2099                 :            : out_free_idr:
    2100                 :          0 :         idr_remove(&loop_index_idr, i);
    2101                 :            : out_free_dev:
    2102                 :          0 :         kfree(lo);
    2103                 :            : out:
    2104                 :          0 :         return err;
    2105                 :            : }
    2106                 :            : 
    2107                 :          0 : static void loop_remove(struct loop_device *lo)
    2108                 :            : {
    2109                 :          0 :         del_gendisk(lo->lo_disk);
    2110                 :          0 :         blk_cleanup_queue(lo->lo_queue);
    2111                 :          0 :         blk_mq_free_tag_set(&lo->tag_set);
    2112                 :          0 :         put_disk(lo->lo_disk);
    2113                 :          0 :         kfree(lo);
    2114                 :          0 : }
    2115                 :            : 
    2116                 :          0 : static int find_free_cb(int id, void *ptr, void *data)
    2117                 :            : {
    2118                 :            :         struct loop_device *lo = ptr;
    2119                 :            :         struct loop_device **l = data;
    2120                 :            : 
    2121         [ #  # ]:          0 :         if (lo->lo_state == Lo_unbound) {
    2122                 :          0 :                 *l = lo;
    2123                 :          0 :                 return 1;
    2124                 :            :         }
    2125                 :            :         return 0;
    2126                 :            : }
    2127                 :            : 
    2128                 :          0 : static int loop_lookup(struct loop_device **l, int i)
    2129                 :            : {
    2130                 :            :         struct loop_device *lo;
    2131                 :            :         int ret = -ENODEV;
    2132                 :            : 
    2133         [ #  # ]:          0 :         if (i < 0) {
    2134                 :            :                 int err;
    2135                 :            : 
    2136                 :          0 :                 err = idr_for_each(&loop_index_idr, &find_free_cb, &lo);
    2137         [ #  # ]:          0 :                 if (err == 1) {
    2138                 :          0 :                         *l = lo;
    2139                 :          0 :                         ret = lo->lo_number;
    2140                 :            :                 }
    2141                 :            :                 goto out;
    2142                 :            :         }
    2143                 :            : 
    2144                 :            :         /* lookup and return a specific i */
    2145                 :          0 :         lo = idr_find(&loop_index_idr, i);
    2146         [ #  # ]:          0 :         if (lo) {
    2147                 :          0 :                 *l = lo;
    2148                 :          0 :                 ret = lo->lo_number;
    2149                 :            :         }
    2150                 :            : out:
    2151                 :          0 :         return ret;
    2152                 :            : }
    2153                 :            : 
    2154                 :          0 : static struct kobject *loop_probe(dev_t dev, int *part, void *data)
    2155                 :            : {
    2156                 :            :         struct loop_device *lo;
    2157                 :            :         struct kobject *kobj;
    2158                 :            :         int err;
    2159                 :            : 
    2160                 :          0 :         mutex_lock(&loop_ctl_mutex);
    2161                 :          0 :         err = loop_lookup(&lo, MINOR(dev) >> part_shift);
    2162         [ #  # ]:          0 :         if (err < 0)
    2163                 :          0 :                 err = loop_add(&lo, MINOR(dev) >> part_shift);
    2164         [ #  # ]:          0 :         if (err < 0)
    2165                 :            :                 kobj = NULL;
    2166                 :            :         else
    2167                 :          0 :                 kobj = get_disk_and_module(lo->lo_disk);
    2168                 :          0 :         mutex_unlock(&loop_ctl_mutex);
    2169                 :            : 
    2170                 :          0 :         *part = 0;
    2171                 :          0 :         return kobj;
    2172                 :            : }
    2173                 :            : 
    2174                 :          0 : static long loop_control_ioctl(struct file *file, unsigned int cmd,
    2175                 :            :                                unsigned long parm)
    2176                 :            : {
    2177                 :            :         struct loop_device *lo;
    2178                 :            :         int ret;
    2179                 :            : 
    2180                 :          0 :         ret = mutex_lock_killable(&loop_ctl_mutex);
    2181         [ #  # ]:          0 :         if (ret)
    2182                 :            :                 return ret;
    2183                 :            : 
    2184                 :            :         ret = -ENOSYS;
    2185   [ #  #  #  # ]:          0 :         switch (cmd) {
    2186                 :            :         case LOOP_CTL_ADD:
    2187                 :          0 :                 ret = loop_lookup(&lo, parm);
    2188         [ #  # ]:          0 :                 if (ret >= 0) {
    2189                 :            :                         ret = -EEXIST;
    2190                 :            :                         break;
    2191                 :            :                 }
    2192                 :          0 :                 ret = loop_add(&lo, parm);
    2193                 :          0 :                 break;
    2194                 :            :         case LOOP_CTL_REMOVE:
    2195                 :          0 :                 ret = loop_lookup(&lo, parm);
    2196         [ #  # ]:          0 :                 if (ret < 0)
    2197                 :            :                         break;
    2198         [ #  # ]:          0 :                 if (lo->lo_state != Lo_unbound) {
    2199                 :            :                         ret = -EBUSY;
    2200                 :            :                         break;
    2201                 :            :                 }
    2202         [ #  # ]:          0 :                 if (atomic_read(&lo->lo_refcnt) > 0) {
    2203                 :            :                         ret = -EBUSY;
    2204                 :            :                         break;
    2205                 :            :                 }
    2206                 :          0 :                 lo->lo_disk->private_data = NULL;
    2207                 :          0 :                 idr_remove(&loop_index_idr, lo->lo_number);
    2208                 :          0 :                 loop_remove(lo);
    2209                 :          0 :                 break;
    2210                 :            :         case LOOP_CTL_GET_FREE:
    2211                 :          0 :                 ret = loop_lookup(&lo, -1);
    2212         [ #  # ]:          0 :                 if (ret >= 0)
    2213                 :            :                         break;
    2214                 :          0 :                 ret = loop_add(&lo, -1);
    2215                 :            :         }
    2216                 :          0 :         mutex_unlock(&loop_ctl_mutex);
    2217                 :            : 
    2218                 :          0 :         return ret;
    2219                 :            : }
    2220                 :            : 
    2221                 :            : static const struct file_operations loop_ctl_fops = {
    2222                 :            :         .open           = nonseekable_open,
    2223                 :            :         .unlocked_ioctl = loop_control_ioctl,
    2224                 :            :         .compat_ioctl   = loop_control_ioctl,
    2225                 :            :         .owner          = THIS_MODULE,
    2226                 :            :         .llseek         = noop_llseek,
    2227                 :            : };
    2228                 :            : 
    2229                 :            : static struct miscdevice loop_misc = {
    2230                 :            :         .minor          = LOOP_CTRL_MINOR,
    2231                 :            :         .name           = "loop-control",
    2232                 :            :         .fops           = &loop_ctl_fops,
    2233                 :            : };
    2234                 :            : 
    2235                 :            : MODULE_ALIAS_MISCDEV(LOOP_CTRL_MINOR);
    2236                 :            : MODULE_ALIAS("devname:loop-control");
    2237                 :            : 
    2238                 :        207 : static int __init loop_init(void)
    2239                 :            : {
    2240                 :            :         int i, nr;
    2241                 :            :         unsigned long range;
    2242                 :            :         struct loop_device *lo;
    2243                 :            :         int err;
    2244                 :            : 
    2245                 :        207 :         part_shift = 0;
    2246         [ -  + ]:        207 :         if (max_part > 0) {
    2247                 :          0 :                 part_shift = fls(max_part);
    2248                 :            : 
    2249                 :            :                 /*
    2250                 :            :                  * Adjust max_part according to part_shift as it is exported
    2251                 :            :                  * to user space so that user can decide correct minor number
    2252                 :            :                  * if [s]he want to create more devices.
    2253                 :            :                  *
    2254                 :            :                  * Note that -1 is required because partition 0 is reserved
    2255                 :            :                  * for the whole disk.
    2256                 :            :                  */
    2257                 :          0 :                 max_part = (1UL << part_shift) - 1;
    2258                 :            :         }
    2259                 :            : 
    2260         [ +  - ]:        207 :         if ((1UL << part_shift) > DISK_MAX_PARTS) {
    2261                 :            :                 err = -EINVAL;
    2262                 :            :                 goto err_out;
    2263                 :            :         }
    2264                 :            : 
    2265         [ +  - ]:        207 :         if (max_loop > 1UL << (MINORBITS - part_shift)) {
    2266                 :            :                 err = -EINVAL;
    2267                 :            :                 goto err_out;
    2268                 :            :         }
    2269                 :            : 
    2270                 :            :         /*
    2271                 :            :          * If max_loop is specified, create that many devices upfront.
    2272                 :            :          * This also becomes a hard limit. If max_loop is not specified,
    2273                 :            :          * create CONFIG_BLK_DEV_LOOP_MIN_COUNT loop devices at module
    2274                 :            :          * init time. Loop devices can be requested on-demand with the
    2275                 :            :          * /dev/loop-control interface, or be instantiated by accessing
    2276                 :            :          * a 'dead' device node.
    2277                 :            :          */
    2278         [ -  + ]:        207 :         if (max_loop) {
    2279                 :            :                 nr = max_loop;
    2280                 :          0 :                 range = max_loop << part_shift;
    2281                 :            :         } else {
    2282                 :            :                 nr = CONFIG_BLK_DEV_LOOP_MIN_COUNT;
    2283                 :            :                 range = 1UL << MINORBITS;
    2284                 :            :         }
    2285                 :            : 
    2286                 :        207 :         err = misc_register(&loop_misc);
    2287         [ +  - ]:        207 :         if (err < 0)
    2288                 :            :                 goto err_out;
    2289                 :            : 
    2290                 :            : 
    2291         [ -  + ]:        207 :         if (register_blkdev(LOOP_MAJOR, "loop")) {
    2292                 :            :                 err = -EIO;
    2293                 :            :                 goto misc_out;
    2294                 :            :         }
    2295                 :            : 
    2296                 :        207 :         blk_register_region(MKDEV(LOOP_MAJOR, 0), range,
    2297                 :            :                                   THIS_MODULE, loop_probe, NULL, NULL);
    2298                 :            : 
    2299                 :            :         /* pre-create number of devices given by config or max_loop */
    2300                 :        207 :         mutex_lock(&loop_ctl_mutex);
    2301         [ +  + ]:       1863 :         for (i = 0; i < nr; i++)
    2302                 :       1656 :                 loop_add(&lo, i);
    2303                 :        207 :         mutex_unlock(&loop_ctl_mutex);
    2304                 :            : 
    2305                 :        207 :         printk(KERN_INFO "loop: module loaded\n");
    2306                 :        207 :         return 0;
    2307                 :            : 
    2308                 :            : misc_out:
    2309                 :          0 :         misc_deregister(&loop_misc);
    2310                 :            : err_out:
    2311                 :          0 :         return err;
    2312                 :            : }
    2313                 :            : 
    2314                 :          0 : static int loop_exit_cb(int id, void *ptr, void *data)
    2315                 :            : {
    2316                 :            :         struct loop_device *lo = ptr;
    2317                 :            : 
    2318                 :          0 :         loop_remove(lo);
    2319                 :          0 :         return 0;
    2320                 :            : }
    2321                 :            : 
    2322                 :          0 : static void __exit loop_exit(void)
    2323                 :            : {
    2324                 :            :         unsigned long range;
    2325                 :            : 
    2326         [ #  # ]:          0 :         range = max_loop ? max_loop << part_shift : 1UL << MINORBITS;
    2327                 :            : 
    2328                 :          0 :         mutex_lock(&loop_ctl_mutex);
    2329                 :            : 
    2330                 :          0 :         idr_for_each(&loop_index_idr, &loop_exit_cb, NULL);
    2331                 :          0 :         idr_destroy(&loop_index_idr);
    2332                 :            : 
    2333                 :          0 :         blk_unregister_region(MKDEV(LOOP_MAJOR, 0), range);
    2334                 :          0 :         unregister_blkdev(LOOP_MAJOR, "loop");
    2335                 :            : 
    2336                 :          0 :         misc_deregister(&loop_misc);
    2337                 :            : 
    2338                 :          0 :         mutex_unlock(&loop_ctl_mutex);
    2339                 :          0 : }
    2340                 :            : 
    2341                 :            : module_init(loop_init);
    2342                 :            : module_exit(loop_exit);
    2343                 :            : 
    2344                 :            : #ifndef MODULE
    2345                 :          0 : static int __init max_loop_setup(char *str)
    2346                 :            : {
    2347                 :          0 :         max_loop = simple_strtol(str, NULL, 0);
    2348                 :          0 :         return 1;
    2349                 :            : }
    2350                 :            : 
    2351                 :            : __setup("max_loop=", max_loop_setup);
    2352                 :            : #endif

Generated by: LCOV version 1.14