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