drivers/mtd/mtd_blkdevs.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Interface to Linux block layer for MTD 'translation layers'.
   4  *
   5  * Copyright © 2003-2010 David Woodhouse <dwmw2@infradead.org>
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/slab.h>
  10 #include <linux/module.h>
  11 #include <linux/list.h>
  12 #include <linux/fs.h>
  13 #include <linux/mtd/blktrans.h>
  14 #include <linux/mtd/mtd.h>
  15 #include <linux/blkdev.h>
  16 #include <linux/blk-mq.h>
  17 #include <linux/blkpg.h>
  18 #include <linux/spinlock.h>
  19 #include <linux/hdreg.h>
  20 #include <linux/mutex.h>
  21 #include <linux/uaccess.h>
  22
  23 #include "mtdcore.h"
  24
  25 static LIST_HEAD(blktrans_majors);
  26 static DEFINE_MUTEX(blktrans_ref_mutex);
  27
  28 static void blktrans_dev_release(struct kref *kref)
  29 {
  30         struct mtd_blktrans_dev *dev =
  31                 container_of(kref, struct mtd_blktrans_dev, ref);
  32
  33         dev->disk->private_data = NULL;
  34         blk_cleanup_queue(dev->rq);
  35         blk_mq_free_tag_set(dev->tag_set);
  36         kfree(dev->tag_set);
  37         put_disk(dev->disk);
  38         list_del(&dev->list);
  39         kfree(dev);
  40 }
  41
  42 static struct mtd_blktrans_dev *blktrans_dev_get(struct gendisk *disk)
  43 {
  44         struct mtd_blktrans_dev *dev;
  45
  46         mutex_lock(&blktrans_ref_mutex);
  47         dev = disk->private_data;
  48
  49         if (!dev)
  50                 goto unlock;
  51         kref_get(&dev->ref);
  52 unlock:
  53         mutex_unlock(&blktrans_ref_mutex);
  54         return dev;
  55 }
  56
  57 static void blktrans_dev_put(struct mtd_blktrans_dev *dev)
  58 {
  59         mutex_lock(&blktrans_ref_mutex);
  60         kref_put(&dev->ref, blktrans_dev_release);
  61         mutex_unlock(&blktrans_ref_mutex);
  62 }
  63
  64
  65 static blk_status_t do_blktrans_request(struct mtd_blktrans_ops *tr,
  66                                struct mtd_blktrans_dev *dev,
  67                                struct request *req)
  68 {
  69         unsigned long block, nsect;
  70         char *buf;
  71
  72         block = blk_rq_pos(req) << 9 >> tr->blkshift;
  73         nsect = blk_rq_cur_bytes(req) >> tr->blkshift;
  74
  75         if (req_op(req) == REQ_OP_FLUSH) {
  76                 if (tr->flush(dev))
  77                         return BLK_STS_IOERR;
  78                 return BLK_STS_OK;
  79         }
  80
  81         if (blk_rq_pos(req) + blk_rq_cur_sectors(req) >
  82             get_capacity(req->rq_disk))
  83                 return BLK_STS_IOERR;
  84
  85         switch (req_op(req)) {
  86         case REQ_OP_DISCARD:
  87                 if (tr->discard(dev, block, nsect))
  88                         return BLK_STS_IOERR;
  89                 return BLK_STS_OK;
  90         case REQ_OP_READ:
  91                 buf = kmap(bio_page(req->bio)) + bio_offset(req->bio);
  92                 for (; nsect > 0; nsect--, block++, buf += tr->blksize) {
  93                         if (tr->readsect(dev, block, buf)) {
  94                                 kunmap(bio_page(req->bio));
  95                                 return BLK_STS_IOERR;
  96                         }
  97                 }
  98                 kunmap(bio_page(req->bio));
  99                 rq_flush_dcache_pages(req);
 100                 return BLK_STS_OK;
 101         case REQ_OP_WRITE:
 102                 if (!tr->writesect)
 103                         return BLK_STS_IOERR;
 104
 105                 rq_flush_dcache_pages(req);
 106                 buf = kmap(bio_page(req->bio)) + bio_offset(req->bio);
 107                 for (; nsect > 0; nsect--, block++, buf += tr->blksize) {
 108                         if (tr->writesect(dev, block, buf)) {
 109                                 kunmap(bio_page(req->bio));
 110                                 return BLK_STS_IOERR;
 111                         }
 112                 }
 113                 kunmap(bio_page(req->bio));
 114                 return BLK_STS_OK;
 115         default:
 116                 return BLK_STS_IOERR;
 117         }
 118 }
 119
 120 int mtd_blktrans_cease_background(struct mtd_blktrans_dev *dev)
 121 {
 122         return dev->bg_stop;
 123 }
 124 EXPORT_SYMBOL_GPL(mtd_blktrans_cease_background);
 125
 126 static struct request *mtd_next_request(struct mtd_blktrans_dev *dev)
 127 {
 128         struct request *rq;
 129
 130         rq = list_first_entry_or_null(&dev->rq_list, struct request, queuelist);
 131         if (rq) {
 132                 list_del_init(&rq->queuelist);
 133                 blk_mq_start_request(rq);
 134                 return rq;
 135         }
 136
 137         return NULL;
 138 }
 139
 140 static void mtd_blktrans_work(struct mtd_blktrans_dev *dev)
 141         __releases(&dev->queue_lock)
 142         __acquires(&dev->queue_lock)
 143 {
 144         struct mtd_blktrans_ops *tr = dev->tr;
 145         struct request *req = NULL;
 146         int background_done = 0;
 147
 148         while (1) {
 149                 blk_status_t res;
 150
 151                 dev->bg_stop = false;
 152                 if (!req && !(req = mtd_next_request(dev))) {
 153                         if (tr->background && !background_done) {
 154                                 spin_unlock_irq(&dev->queue_lock);
 155                                 mutex_lock(&dev->lock);
 156                                 tr->background(dev);
 157                                 mutex_unlock(&dev->lock);
 158                                 spin_lock_irq(&dev->queue_lock);
 159                                 /*
 160                                  * Do background processing just once per idle
 161                                  * period.
 162                                  */
 163                                 background_done = !dev->bg_stop;
 164                                 continue;
 165                         }
 166                         break;
 167                 }
 168
 169                 spin_unlock_irq(&dev->queue_lock);
 170
 171                 mutex_lock(&dev->lock);
 172                 res = do_blktrans_request(dev->tr, dev, req);
 173                 mutex_unlock(&dev->lock);
 174
 175                 if (!blk_update_request(req, res, blk_rq_cur_bytes(req))) {
 176                         __blk_mq_end_request(req, res);
 177                         req = NULL;
 178                 }
 179
 180                 background_done = 0;
 181                 spin_lock_irq(&dev->queue_lock);
 182         }
 183 }
 184
 185 static blk_status_t mtd_queue_rq(struct blk_mq_hw_ctx *hctx,
 186                                  const struct blk_mq_queue_data *bd)
 187 {
 188         struct mtd_blktrans_dev *dev;
 189
 190         dev = hctx->queue->queuedata;
 191         if (!dev) {
 192                 blk_mq_start_request(bd->rq);
 193                 return BLK_STS_IOERR;
 194         }
 195
 196         spin_lock_irq(&dev->queue_lock);
 197         list_add_tail(&bd->rq->queuelist, &dev->rq_list);
 198         mtd_blktrans_work(dev);
 199         spin_unlock_irq(&dev->queue_lock);
 200
 201         return BLK_STS_OK;
 202 }
 203
 204 static int blktrans_open(struct block_device *bdev, fmode_t mode)
 205 {
 206         struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);
 207         int ret = 0;
 208
 209         if (!dev)
 210                 return -ERESTARTSYS; /* FIXME: busy loop! -arnd*/
 211
 212         mutex_lock(&mtd_table_mutex);
 213         mutex_lock(&dev->lock);
 214
 215         if (dev->open)
 216                 goto unlock;
 217
 218         kref_get(&dev->ref);
 219         __module_get(dev->tr->owner);
 220
 221         if (!dev->mtd)
 222                 goto unlock;
 223
 224         if (dev->tr->open) {
 225                 ret = dev->tr->open(dev);
 226                 if (ret)
 227                         goto error_put;
 228         }
 229
 230         ret = __get_mtd_device(dev->mtd);
 231         if (ret)
 232                 goto error_release;
 233         dev->file_mode = mode;
 234
 235 unlock:
 236         dev->open++;
 237         mutex_unlock(&dev->lock);
 238         mutex_unlock(&mtd_table_mutex);
 239         blktrans_dev_put(dev);
 240         return ret;
 241
 242 error_release:
 243         if (dev->tr->release)
 244                 dev->tr->release(dev);
 245 error_put:
 246         module_put(dev->tr->owner);
 247         kref_put(&dev->ref, blktrans_dev_release);
 248         mutex_unlock(&dev->lock);
 249         mutex_unlock(&mtd_table_mutex);
 250         blktrans_dev_put(dev);
 251         return ret;
 252 }
 253
 254 static void blktrans_release(struct gendisk *disk, fmode_t mode)
 255 {
 256         struct mtd_blktrans_dev *dev = blktrans_dev_get(disk);
 257
 258         if (!dev)
 259                 return;
 260
 261         mutex_lock(&mtd_table_mutex);
 262         mutex_lock(&dev->lock);
 263
 264         if (--dev->open)
 265                 goto unlock;
 266
 267         kref_put(&dev->ref, blktrans_dev_release);
 268         module_put(dev->tr->owner);
 269
 270         if (dev->mtd) {
 271                 if (dev->tr->release)
 272                         dev->tr->release(dev);
 273                 __put_mtd_device(dev->mtd);
 274         }
 275 unlock:
 276         mutex_unlock(&dev->lock);
 277         mutex_unlock(&mtd_table_mutex);
 278         blktrans_dev_put(dev);
 279 }
 280
 281 static int blktrans_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 282 {
 283         struct mtd_blktrans_dev *dev = blktrans_dev_get(bdev->bd_disk);
 284         int ret = -ENXIO;
 285
 286         if (!dev)
 287                 return ret;
 288
 289         mutex_lock(&dev->lock);
 290
 291         if (!dev->mtd)
 292                 goto unlock;
 293
 294         ret = dev->tr->getgeo ? dev->tr->getgeo(dev, geo) : -ENOTTY;
 295 unlock:
 296         mutex_unlock(&dev->lock);
 297         blktrans_dev_put(dev);
 298         return ret;
 299 }
 300
 301 static const struct block_device_operations mtd_block_ops = {
 302         .owner          = THIS_MODULE,
 303         .open           = blktrans_open,
 304         .release        = blktrans_release,
 305         .getgeo         = blktrans_getgeo,
 306 };
 307
 308 static const struct blk_mq_ops mtd_mq_ops = {
 309         .queue_rq       = mtd_queue_rq,
 310 };
 311
 312 int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
 313 {
 314         struct mtd_blktrans_ops *tr = new->tr;
 315         struct mtd_blktrans_dev *d;
 316         int last_devnum = -1;
 317         struct gendisk *gd;
 318         int ret;
 319
 320         if (mutex_trylock(&mtd_table_mutex)) {
 321                 mutex_unlock(&mtd_table_mutex);
 322                 BUG();
 323         }
 324
 325         mutex_lock(&blktrans_ref_mutex);
 326         list_for_each_entry(d, &tr->devs, list) {
 327                 if (new->devnum == -1) {
 328                         /* Use first free number */
 329                         if (d->devnum != last_devnum+1) {
 330                                 /* Found a free devnum. Plug it in here */
 331                                 new->devnum = last_devnum+1;
 332                                 list_add_tail(&new->list, &d->list);
 333                                 goto added;
 334                         }
 335                 } else if (d->devnum == new->devnum) {
 336                         /* Required number taken */
 337                         mutex_unlock(&blktrans_ref_mutex);
 338                         return -EBUSY;
 339                 } else if (d->devnum > new->devnum) {
 340                         /* Required number was free */
 341                         list_add_tail(&new->list, &d->list);
 342                         goto added;
 343                 }
 344                 last_devnum = d->devnum;
 345         }
 346
 347         ret = -EBUSY;
 348         if (new->devnum == -1)
 349                 new->devnum = last_devnum+1;
 350
 351         /* Check that the device and any partitions will get valid
 352          * minor numbers and that the disk naming code below can cope
 353          * with this number. */
 354         if (new->devnum > (MINORMASK >> tr->part_bits) ||
 355             (tr->part_bits && new->devnum >= 27 * 26)) {
 356                 mutex_unlock(&blktrans_ref_mutex);
 357                 goto error1;
 358         }
 359
 360         list_add_tail(&new->list, &tr->devs);
 361  added:
 362         mutex_unlock(&blktrans_ref_mutex);
 363
 364         mutex_init(&new->lock);
 365         kref_init(&new->ref);
 366         if (!tr->writesect)
 367                 new->readonly = 1;
 368
 369         /* Create gendisk */
 370         ret = -ENOMEM;
 371         gd = alloc_disk(1 << tr->part_bits);
 372
 373         if (!gd)
 374                 goto error2;
 375
 376         new->disk = gd;
 377         gd->private_data = new;
 378         gd->major = tr->major;
 379         gd->first_minor = (new->devnum) << tr->part_bits;
 380         gd->fops = &mtd_block_ops;
 381
 382         if (tr->part_bits)
 383                 if (new->devnum < 26)
 384                         snprintf(gd->disk_name, sizeof(gd->disk_name),
 385                                  "%s%c", tr->name, 'a' + new->devnum);
 386                 else
 387                         snprintf(gd->disk_name, sizeof(gd->disk_name),
 388                                  "%s%c%c", tr->name,
 389                                  'a' - 1 + new->devnum / 26,
 390                                  'a' + new->devnum % 26);
 391         else
 392                 snprintf(gd->disk_name, sizeof(gd->disk_name),
 393                          "%s%d", tr->name, new->devnum);
 394
 395         set_capacity(gd, ((u64)new->size * tr->blksize) >> 9);
 396
 397         /* Create the request queue */
 398         spin_lock_init(&new->queue_lock);
 399         INIT_LIST_HEAD(&new->rq_list);
 400
 401         new->tag_set = kzalloc(sizeof(*new->tag_set), GFP_KERNEL);
 402         if (!new->tag_set)
 403                 goto error3;
 404
 405         new->rq = blk_mq_init_sq_queue(new->tag_set, &mtd_mq_ops, 2,
 406                                 BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING);
 407         if (IS_ERR(new->rq)) {
 408                 ret = PTR_ERR(new->rq);
 409                 new->rq = NULL;
 410                 goto error4;
 411         }
 412
 413         if (tr->flush)
 414                 blk_queue_write_cache(new->rq, true, false);
 415
 416         new->rq->queuedata = new;
 417         blk_queue_logical_block_size(new->rq, tr->blksize);
 418
 419         blk_queue_flag_set(QUEUE_FLAG_NONROT, new->rq);
 420         blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, new->rq);
 421
 422         if (tr->discard) {
 423                 blk_queue_flag_set(QUEUE_FLAG_DISCARD, new->rq);
 424                 blk_queue_max_discard_sectors(new->rq, UINT_MAX);
 425         }
 426
 427         gd->queue = new->rq;
 428
 429         if (new->readonly)
 430                 set_disk_ro(gd, 1);
 431
 432         device_add_disk(&new->mtd->dev, gd, NULL);
 433
 434         if (new->disk_attributes) {
 435                 ret = sysfs_create_group(&disk_to_dev(gd)->kobj,
 436                                         new->disk_attributes);
 437                 WARN_ON(ret);
 438         }
 439         return 0;
 440 error4:
 441         kfree(new->tag_set);
 442 error3:
 443         put_disk(new->disk);
 444 error2:
 445         list_del(&new->list);
 446 error1:
 447         return ret;
 448 }
 449
 450 int del_mtd_blktrans_dev(struct mtd_blktrans_dev *old)
 451 {
 452         unsigned long flags;
 453
 454         if (mutex_trylock(&mtd_table_mutex)) {
 455                 mutex_unlock(&mtd_table_mutex);
 456                 BUG();
 457         }
 458
 459         if (old->disk_attributes)
 460                 sysfs_remove_group(&disk_to_dev(old->disk)->kobj,
 461                                                 old->disk_attributes);
 462
 463         /* Stop new requests to arrive */
 464         del_gendisk(old->disk);
 465
 466         /* Kill current requests */
 467         spin_lock_irqsave(&old->queue_lock, flags);
 468         old->rq->queuedata = NULL;
 469         spin_unlock_irqrestore(&old->queue_lock, flags);
 470
 471         /* freeze+quiesce queue to ensure all requests are flushed */
 472         blk_mq_freeze_queue(old->rq);
 473         blk_mq_quiesce_queue(old->rq);
 474         blk_mq_unquiesce_queue(old->rq);
 475         blk_mq_unfreeze_queue(old->rq);
 476
 477         /* If the device is currently open, tell trans driver to close it,
 478                 then put mtd device, and don't touch it again */
 479         mutex_lock(&old->lock);
 480         if (old->open) {
 481                 if (old->tr->release)
 482                         old->tr->release(old);
 483                 __put_mtd_device(old->mtd);
 484         }
 485
 486         old->mtd = NULL;
 487
 488         mutex_unlock(&old->lock);
 489         blktrans_dev_put(old);
 490         return 0;
 491 }
 492
 493 static void blktrans_notify_remove(struct mtd_info *mtd)
 494 {
 495         struct mtd_blktrans_ops *tr;
 496         struct mtd_blktrans_dev *dev, *next;
 497
 498         list_for_each_entry(tr, &blktrans_majors, list)
 499                 list_for_each_entry_safe(dev, next, &tr->devs, list)
 500                         if (dev->mtd == mtd)
 501                                 tr->remove_dev(dev);
 502 }
 503
 504 static void blktrans_notify_add(struct mtd_info *mtd)
 505 {
 506         struct mtd_blktrans_ops *tr;
 507
 508         if (mtd->type == MTD_ABSENT)
 509                 return;
 510
 511         list_for_each_entry(tr, &blktrans_majors, list)
 512                 tr->add_mtd(tr, mtd);
 513 }
 514
 515 static struct mtd_notifier blktrans_notifier = {
 516         .add = blktrans_notify_add,
 517         .remove = blktrans_notify_remove,
 518 };
 519
 520 int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
 521 {
 522         struct mtd_info *mtd;
 523         int ret;
 524
 525         /* Register the notifier if/when the first device type is
 526            registered, to prevent the link/init ordering from fucking
 527            us over. */
 528         if (!blktrans_notifier.list.next)
 529                 register_mtd_user(&blktrans_notifier);
 530
 531
 532         mutex_lock(&mtd_table_mutex);
 533
 534         ret = register_blkdev(tr->major, tr->name);
 535         if (ret < 0) {
 536                 printk(KERN_WARNING "Unable to register %s block device on major %d: %d\n",
 537                        tr->name, tr->major, ret);
 538                 mutex_unlock(&mtd_table_mutex);
 539                 return ret;
 540         }
 541
 542         if (ret)
 543                 tr->major = ret;
 544
 545         tr->blkshift = ffs(tr->blksize) - 1;
 546
 547         INIT_LIST_HEAD(&tr->devs);
 548         list_add(&tr->list, &blktrans_majors);
 549
 550         mtd_for_each_device(mtd)
 551                 if (mtd->type != MTD_ABSENT)
 552                         tr->add_mtd(tr, mtd);
 553
 554         mutex_unlock(&mtd_table_mutex);
 555         return 0;
 556 }
 557
 558 int deregister_mtd_blktrans(struct mtd_blktrans_ops *tr)
 559 {
 560         struct mtd_blktrans_dev *dev, *next;
 561
 562         mutex_lock(&mtd_table_mutex);
 563
 564         /* Remove it from the list of active majors */
 565         list_del(&tr->list);
 566
 567         list_for_each_entry_safe(dev, next, &tr->devs, list)
 568                 tr->remove_dev(dev);
 569
 570         unregister_blkdev(tr->major, tr->name);
 571         mutex_unlock(&mtd_table_mutex);
 572
 573         BUG_ON(!list_empty(&tr->devs));
 574         return 0;
 575 }
 576
 577 static void __exit mtd_blktrans_exit(void)
 578 {
 579         /* No race here -- if someone's currently in register_mtd_blktrans
 580            we're screwed anyway. */
 581         if (blktrans_notifier.list.next)
 582                 unregister_mtd_user(&blktrans_notifier);
 583 }
 584
 585 module_exit(mtd_blktrans_exit);
 586
 587 EXPORT_SYMBOL_GPL(register_mtd_blktrans);
 588 EXPORT_SYMBOL_GPL(deregister_mtd_blktrans);
 589 EXPORT_SYMBOL_GPL(add_mtd_blktrans_dev);
 590 EXPORT_SYMBOL_GPL(del_mtd_blktrans_dev);
 591
 592 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
 593 MODULE_LICENSE("GPL");
 594 MODULE_DESCRIPTION("Common interface to block layer for MTD 'translation layers'");