drivers/block/loop.c

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