/* * Copyright (c) 2014 Ezequiel Garcia * Copyright (c) 2011 Free Electrons * * Driver parameter handling strongly based on drivers/mtd/ubi/build.c * Copyright (c) International Business Machines Corp., 2006 * Copyright (c) Nokia Corporation, 2007 * Authors: Artem Bityutskiy, Frank Haverkamp * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See * the GNU General Public License for more details. */ /* * Read-only block devices on top of UBI volumes * * A simple implementation to allow a block device to be layered on top of a * UBI volume. The implementation is provided by creating a static 1-to-1 * mapping between the block device and the UBI volume. * * The addressed byte is obtained from the addressed block sector, which is * mapped linearly into the corresponding LEB: * * LEB number = addressed byte / LEB size * * This feature is compiled in the UBI core, and adds a 'block' parameter * to allow early creation of block devices on top of UBI volumes. Runtime * block creation/removal for UBI volumes is provided through two UBI ioctls: * UBI_IOCVOLCRBLK and UBI_IOCVOLRMBLK. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ubi-media.h" #include "ubi.h" /* Maximum number of supported devices */ #define UBIBLOCK_MAX_DEVICES 32 /* Maximum length of the 'block=' parameter */ #define UBIBLOCK_PARAM_LEN 63 /* Maximum number of comma-separated items in the 'block=' parameter */ #define UBIBLOCK_PARAM_COUNT 2 struct ubiblock_param { int ubi_num; int vol_id; char name[UBIBLOCK_PARAM_LEN+1]; }; struct ubiblock_pdu { struct work_struct work; struct ubi_sgl usgl; }; /* Numbers of elements set in the @ubiblock_param array */ static int ubiblock_devs __initdata; /* MTD devices specification parameters */ static struct ubiblock_param ubiblock_param[UBIBLOCK_MAX_DEVICES] __initdata; struct ubiblock { struct ubi_volume_desc *desc; int ubi_num; int vol_id; int refcnt; int leb_size; struct gendisk *gd; struct request_queue *rq; struct workqueue_struct *wq; struct mutex dev_mutex; struct list_head list; struct blk_mq_tag_set tag_set; }; /* Linked list of all ubiblock instances */ static LIST_HEAD(ubiblock_devices); static DEFINE_MUTEX(devices_mutex); static int ubiblock_major; static int __init ubiblock_set_param(const char *val, const struct kernel_param *kp) { int i, ret; size_t len; struct ubiblock_param *param; char buf[UBIBLOCK_PARAM_LEN]; char *pbuf = &buf[0]; char *tokens[UBIBLOCK_PARAM_COUNT]; if (!val) return -EINVAL; len = strnlen(val, UBIBLOCK_PARAM_LEN); if (len == 0) { pr_warn("UBI: block: empty 'block=' parameter - ignored\n"); return 0; } if (len == UBIBLOCK_PARAM_LEN) { pr_err("UBI: block: parameter \"%s\" is too long, max. is %d\n", val, UBIBLOCK_PARAM_LEN); return -EINVAL; } strcpy(buf, val); /* Get rid of the final newline */ if (buf[len - 1] == '\n') buf[len - 1] = '\0'; for (i = 0; i < UBIBLOCK_PARAM_COUNT; i++) tokens[i] = strsep(&pbuf, ","); param = &ubiblock_param[ubiblock_devs]; if (tokens[1]) { /* Two parameters: can be 'ubi, vol_id' or 'ubi, vol_name' */ ret = kstrtoint(tokens[0], 10, ¶m->ubi_num); if (ret < 0) return -EINVAL; /* Second param can be a number or a name */ ret = kstrtoint(tokens[1], 10, ¶m->vol_id); if (ret < 0) { param->vol_id = -1; strcpy(param->name, tokens[1]); } } else { /* One parameter: must be device path */ strcpy(param->name, tokens[0]); param->ubi_num = -1; param->vol_id = -1; } ubiblock_devs++; return 0; } static const struct kernel_param_ops ubiblock_param_ops = { .set = ubiblock_set_param, }; module_param_cb(block, &ubiblock_param_ops, NULL, 0); MODULE_PARM_DESC(block, "Attach block devices to UBI volumes. Parameter format: block=.\n" "Multiple \"block\" parameters may be specified.\n" "UBI volumes may be specified by their number, name, or path to the device node.\n" "Examples\n" "Using the UBI volume path:\n" "ubi.block=/dev/ubi0_0\n" "Using the UBI device, and the volume name:\n" "ubi.block=0,rootfs\n" "Using both UBI device number and UBI volume number:\n" "ubi.block=0,0\n"); static struct ubiblock *find_dev_nolock(int ubi_num, int vol_id) { struct ubiblock *dev; list_for_each_entry(dev, &ubiblock_devices, list) if (dev->ubi_num == ubi_num && dev->vol_id == vol_id) return dev; return NULL; } static int ubiblock_read(struct ubiblock_pdu *pdu) { int ret, leb, offset, bytes_left, to_read; u64 pos; struct request *req = blk_mq_rq_from_pdu(pdu); struct ubiblock *dev = req->q->queuedata; to_read = blk_rq_bytes(req); pos = blk_rq_pos(req) << 9; /* Get LEB:offset address to read from */ offset = do_div(pos, dev->leb_size); leb = pos; bytes_left = to_read; while (bytes_left) { /* * We can only read one LEB at a time. Therefore if the read * length is larger than one LEB size, we split the operation. */ if (offset + to_read > dev->leb_size) to_read = dev->leb_size - offset; ret = ubi_read_sg(dev->desc, leb, &pdu->usgl, offset, to_read); if (ret < 0) return ret; bytes_left -= to_read; to_read = bytes_left; leb += 1; offset = 0; } return 0; } static int ubiblock_open(struct block_device *bdev, fmode_t mode) { struct ubiblock *dev = bdev->bd_disk->private_data; int ret; mutex_lock(&dev->dev_mutex); if (dev->refcnt > 0) { /* * The volume is already open, just increase the reference * counter. */ goto out_done; } /* * We want users to be aware they should only mount us as read-only. * It's just a paranoid check, as write requests will get rejected * in any case. */ if (mode & FMODE_WRITE) { ret = -EPERM; goto out_unlock; } dev->desc = ubi_open_volume(dev->ubi_num, dev->vol_id, UBI_READONLY); if (IS_ERR(dev->desc)) { dev_err(disk_to_dev(dev->gd), "failed to open ubi volume %d_%d", dev->ubi_num, dev->vol_id); ret = PTR_ERR(dev->desc); dev->desc = NULL; goto out_unlock; } out_done: dev->refcnt++; mutex_unlock(&dev->dev_mutex); return 0; out_unlock: mutex_unlock(&dev->dev_mutex); return ret; } static void ubiblock_release(struct gendisk *gd, fmode_t mode) { struct ubiblock *dev = gd->private_data; mutex_lock(&dev->dev_mutex); dev->refcnt--; if (dev->refcnt == 0) { ubi_close_volume(dev->desc); dev->desc = NULL; } mutex_unlock(&dev->dev_mutex); } static int ubiblock_getgeo(struct block_device *bdev, struct hd_geometry *geo) { /* Some tools might require this information */ geo->heads = 1; geo->cylinders = 1; geo->sectors = get_capacity(bdev->bd_disk); geo->start = 0; return 0; } static const struct block_device_operations ubiblock_ops = { .owner = THIS_MODULE, .open = ubiblock_open, .release = ubiblock_release, .getgeo = ubiblock_getgeo, }; static void ubiblock_do_work(struct work_struct *work) { int ret; struct ubiblock_pdu *pdu = container_of(work, struct ubiblock_pdu, work); struct request *req = blk_mq_rq_from_pdu(pdu); blk_mq_start_request(req); /* * It is safe to ignore the return value of blk_rq_map_sg() because * the number of sg entries is limited to UBI_MAX_SG_COUNT * and ubi_read_sg() will check that limit. */ blk_rq_map_sg(req->q, req, pdu->usgl.sg); ret = ubiblock_read(pdu); rq_flush_dcache_pages(req); blk_mq_end_request(req, ret); } static int ubiblock_queue_rq(struct blk_mq_hw_ctx *hctx, const struct blk_mq_queue_data *bd) { struct request *req = bd->rq; struct ubiblock *dev = hctx->queue->queuedata; struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req); if (req->cmd_type != REQ_TYPE_FS) return BLK_MQ_RQ_QUEUE_ERROR; if (rq_data_dir(req) != READ) return BLK_MQ_RQ_QUEUE_ERROR; /* Write not implemented */ ubi_sgl_init(&pdu->usgl); queue_work(dev->wq, &pdu->work); return BLK_MQ_RQ_QUEUE_OK; } static int ubiblock_init_request(void *data, struct request *req, unsigned int hctx_idx, unsigned int request_idx, unsigned int numa_node) { struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req); sg_init_table(pdu->usgl.sg, UBI_MAX_SG_COUNT); INIT_WORK(&pdu->work, ubiblock_do_work); return 0; } static struct blk_mq_ops ubiblock_mq_ops = { .queue_rq = ubiblock_queue_rq, .init_request = ubiblock_init_request, }; static DEFINE_IDR(ubiblock_minor_idr); int ubiblock_create(struct ubi_volume_info *vi) { struct ubiblock *dev; struct gendisk *gd; u64 disk_capacity = vi->used_bytes >> 9; int ret; if ((sector_t)disk_capacity != disk_capacity) return -EFBIG; /* Check that the volume isn't already handled */ mutex_lock(&devices_mutex); if (find_dev_nolock(vi->ubi_num, vi->vol_id)) { mutex_unlock(&devices_mutex); return -EEXIST; } mutex_unlock(&devices_mutex); dev = kzalloc(sizeof(struct ubiblock), GFP_KERNEL); if (!dev) return -ENOMEM; mutex_init(&dev->dev_mutex); dev->ubi_num = vi->ubi_num; dev->vol_id = vi->vol_id; dev->leb_size = vi->usable_leb_size; /* Initialize the gendisk of this ubiblock device */ gd = alloc_disk(1); if (!gd) { pr_err("UBI: block: alloc_disk failed"); ret = -ENODEV; goto out_free_dev; } gd->fops = &ubiblock_ops; gd->major = ubiblock_major; gd->first_minor = idr_alloc(&ubiblock_minor_idr, dev, 0, 0, GFP_KERNEL); if (gd->first_minor < 0) { dev_err(disk_to_dev(gd), "block: dynamic minor allocation failed"); ret = -ENODEV; goto out_put_disk; } gd->private_data = dev; sprintf(gd->disk_name, "ubiblock%d_%d", dev->ubi_num, dev->vol_id); set_capacity(gd, disk_capacity); dev->gd = gd; dev->tag_set.ops = &ubiblock_mq_ops; dev->tag_set.queue_depth = 64; dev->tag_set.numa_node = NUMA_NO_NODE; dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE; dev->tag_set.cmd_size = sizeof(struct ubiblock_pdu); dev->tag_set.driver_data = dev; dev->tag_set.nr_hw_queues = 1; ret = blk_mq_alloc_tag_set(&dev->tag_set); if (ret) { dev_err(disk_to_dev(dev->gd), "blk_mq_alloc_tag_set failed"); goto out_remove_minor; } dev->rq = blk_mq_init_queue(&dev->tag_set); if (IS_ERR(dev->rq)) { dev_err(disk_to_dev(gd), "blk_mq_init_queue failed"); ret = PTR_ERR(dev->rq); goto out_free_tags; } blk_queue_max_segments(dev->rq, UBI_MAX_SG_COUNT); dev->rq->queuedata = dev; dev->gd->queue = dev->rq; /* * Create one workqueue per volume (per registered block device). * Rembember workqueues are cheap, they're not threads. */ dev->wq = alloc_workqueue("%s", 0, 0, gd->disk_name); if (!dev->wq) { ret = -ENOMEM; goto out_free_queue; } mutex_lock(&devices_mutex); list_add_tail(&dev->list, &ubiblock_devices); mutex_unlock(&devices_mutex); /* Must be the last step: anyone can call file ops from now on */ add_disk(dev->gd); dev_info(disk_to_dev(dev->gd), "created from ubi%d:%d(%s)", dev->ubi_num, dev->vol_id, vi->name); return 0; out_free_queue: blk_cleanup_queue(dev->rq); out_free_tags: blk_mq_free_tag_set(&dev->tag_set); out_remove_minor: idr_remove(&ubiblock_minor_idr, gd->first_minor); out_put_disk: put_disk(dev->gd); out_free_dev: kfree(dev); return ret; } static void ubiblock_cleanup(struct ubiblock *dev) { /* Stop new requests to arrive */ del_gendisk(dev->gd); /* Flush pending work */ destroy_workqueue(dev->wq); /* Finally destroy the blk queue */ blk_cleanup_queue(dev->rq); blk_mq_free_tag_set(&dev->tag_set); dev_info(disk_to_dev(dev->gd), "released"); idr_remove(&ubiblock_minor_idr, dev->gd->first_minor); put_disk(dev->gd); } int ubiblock_remove(struct ubi_volume_info *vi) { struct ubiblock *dev; mutex_lock(&devices_mutex); dev = find_dev_nolock(vi->ubi_num, vi->vol_id); if (!dev) { mutex_unlock(&devices_mutex); return -ENODEV; } /* Found a device, let's lock it so we can check if it's busy */ mutex_lock(&dev->dev_mutex); if (dev->refcnt > 0) { mutex_unlock(&dev->dev_mutex); mutex_unlock(&devices_mutex); return -EBUSY; } /* Remove from device list */ list_del(&dev->list); mutex_unlock(&devices_mutex); ubiblock_cleanup(dev); mutex_unlock(&dev->dev_mutex); kfree(dev); return 0; } static int ubiblock_resize(struct ubi_volume_info *vi) { struct ubiblock *dev; u64 disk_capacity = vi->used_bytes >> 9; /* * Need to lock the device list until we stop using the device, * otherwise the device struct might get released in * 'ubiblock_remove()'. */ mutex_lock(&devices_mutex); dev = find_dev_nolock(vi->ubi_num, vi->vol_id); if (!dev) { mutex_unlock(&devices_mutex); return -ENODEV; } if ((sector_t)disk_capacity != disk_capacity) { mutex_unlock(&devices_mutex); dev_warn(disk_to_dev(dev->gd), "the volume is too big (%d LEBs), cannot resize", vi->size); return -EFBIG; } mutex_lock(&dev->dev_mutex); if (get_capacity(dev->gd) != disk_capacity) { set_capacity(dev->gd, disk_capacity); dev_info(disk_to_dev(dev->gd), "resized to %lld bytes", vi->used_bytes); } mutex_unlock(&dev->dev_mutex); mutex_unlock(&devices_mutex); return 0; } static int ubiblock_notify(struct notifier_block *nb, unsigned long notification_type, void *ns_ptr) { struct ubi_notification *nt = ns_ptr; switch (notification_type) { case UBI_VOLUME_ADDED: /* * We want to enforce explicit block device creation for * volumes, so when a volume is added we do nothing. */ break; case UBI_VOLUME_REMOVED: ubiblock_remove(&nt->vi); break; case UBI_VOLUME_RESIZED: ubiblock_resize(&nt->vi); break; case UBI_VOLUME_UPDATED: /* * If the volume is static, a content update might mean the * size (i.e. used_bytes) was also changed. */ if (nt->vi.vol_type == UBI_STATIC_VOLUME) ubiblock_resize(&nt->vi); break; default: break; } return NOTIFY_OK; } static struct notifier_block ubiblock_notifier = { .notifier_call = ubiblock_notify, }; static struct ubi_volume_desc * __init open_volume_desc(const char *name, int ubi_num, int vol_id) { if (ubi_num == -1) /* No ubi num, name must be a vol device path */ return ubi_open_volume_path(name, UBI_READONLY); else if (vol_id == -1) /* No vol_id, must be vol_name */ return ubi_open_volume_nm(ubi_num, name, UBI_READONLY); else return ubi_open_volume(ubi_num, vol_id, UBI_READONLY); } static void __init ubiblock_create_from_param(void) { int i, ret = 0; struct ubiblock_param *p; struct ubi_volume_desc *desc; struct ubi_volume_info vi; /* * If there is an error creating one of the ubiblocks, continue on to * create the following ubiblocks. This helps in a circumstance where * the kernel command-line specifies multiple block devices and some * may be broken, but we still want the working ones to come up. */ for (i = 0; i < ubiblock_devs; i++) { p = &ubiblock_param[i]; desc = open_volume_desc(p->name, p->ubi_num, p->vol_id); if (IS_ERR(desc)) { pr_err( "UBI: block: can't open volume on ubi%d_%d, err=%ld", p->ubi_num, p->vol_id, PTR_ERR(desc)); continue; } ubi_get_volume_info(desc, &vi); ubi_close_volume(desc); ret = ubiblock_create(&vi); if (ret) { pr_err( "UBI: block: can't add '%s' volume on ubi%d_%d, err=%d", vi.name, p->ubi_num, p->vol_id, ret); continue; } } } static void ubiblock_remove_all(void) { struct ubiblock *next; struct ubiblock *dev; list_for_each_entry_safe(dev, next, &ubiblock_devices, list) { /* The module is being forcefully removed */ WARN_ON(dev->desc); /* Remove from device list */ list_del(&dev->list); ubiblock_cleanup(dev); kfree(dev); } } int __init ubiblock_init(void) { int ret; ubiblock_major = register_blkdev(0, "ubiblock"); if (ubiblock_major < 0) return ubiblock_major; /* * Attach block devices from 'block=' module param. * Even if one block device in the param list fails to come up, * still allow the module to load and leave any others up. */ ubiblock_create_from_param(); /* * Block devices are only created upon user requests, so we ignore * existing volumes. */ ret = ubi_register_volume_notifier(&ubiblock_notifier, 1); if (ret) goto err_unreg; return 0; err_unreg: unregister_blkdev(ubiblock_major, "ubiblock"); ubiblock_remove_all(); return ret; } void __exit ubiblock_exit(void) { ubi_unregister_volume_notifier(&ubiblock_notifier); ubiblock_remove_all(); unregister_blkdev(ubiblock_major, "ubiblock"); }