1/*
2 * block2mtd.c - create an mtd from a block device
3 *
4 * Copyright (C) 2001,2002	Simon Evans <spse@secret.org.uk>
5 * Copyright (C) 2004-2006	Joern Engel <joern@wh.fh-wedel.de>
6 *
7 * Licence: GPL
8 */
9
10#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12/*
13 * When the first attempt at device initialization fails, we may need to
14 * wait a little bit and retry. This timeout, by default 3 seconds, gives
15 * device time to start up. Required on BCM2708 and a few other chipsets.
16 */
17#define MTD_DEFAULT_TIMEOUT	3
18
19#include <linux/module.h>
20#include <linux/delay.h>
21#include <linux/fs.h>
22#include <linux/blkdev.h>
23#include <linux/backing-dev.h>
24#include <linux/bio.h>
25#include <linux/pagemap.h>
26#include <linux/list.h>
27#include <linux/init.h>
28#include <linux/mtd/mtd.h>
29#include <linux/mutex.h>
30#include <linux/mount.h>
31#include <linux/slab.h>
32#include <linux/major.h>
33
34/* Maximum number of comma-separated items in the 'block2mtd=' parameter */
35#define BLOCK2MTD_PARAM_MAX_COUNT 3
36
37/* Info for the block device */
38struct block2mtd_dev {
39	struct list_head list;
40	struct file *bdev_file;
41	struct mtd_info mtd;
42	struct mutex write_mutex;
43};
44
45
46/* Static info about the MTD, used in cleanup_module */
47static LIST_HEAD(blkmtd_device_list);
48
49
50static struct page *page_read(struct address_space *mapping, pgoff_t index)
51{
52	return read_mapping_page(mapping, index, NULL);
53}
54
55/* erase a specified part of the device */
56static int _block2mtd_erase(struct block2mtd_dev *dev, loff_t to, size_t len)
57{
58	struct address_space *mapping = dev->bdev_file->f_mapping;
59	struct page *page;
60	pgoff_t index = to >> PAGE_SHIFT;	// page index
61	int pages = len >> PAGE_SHIFT;
62	u_long *p;
63	u_long *max;
64
65	while (pages) {
66		page = page_read(mapping, index);
67		if (IS_ERR(page))
68			return PTR_ERR(page);
69
70		max = page_address(page) + PAGE_SIZE;
71		for (p=page_address(page); p<max; p++)
72			if (*p != -1UL) {
73				lock_page(page);
74				memset(page_address(page), 0xff, PAGE_SIZE);
75				set_page_dirty(page);
76				unlock_page(page);
77				balance_dirty_pages_ratelimited(mapping);
78				break;
79			}
80
81		put_page(page);
82		pages--;
83		index++;
84	}
85	return 0;
86}
87static int block2mtd_erase(struct mtd_info *mtd, struct erase_info *instr)
88{
89	struct block2mtd_dev *dev = mtd->priv;
90	size_t from = instr->addr;
91	size_t len = instr->len;
92	int err;
93
94	mutex_lock(&dev->write_mutex);
95	err = _block2mtd_erase(dev, from, len);
96	mutex_unlock(&dev->write_mutex);
97	if (err)
98		pr_err("erase failed err = %d\n", err);
99
100	return err;
101}
102
103
104static int block2mtd_read(struct mtd_info *mtd, loff_t from, size_t len,
105		size_t *retlen, u_char *buf)
106{
107	struct block2mtd_dev *dev = mtd->priv;
108	struct address_space *mapping = dev->bdev_file->f_mapping;
109	struct page *page;
110	pgoff_t index = from >> PAGE_SHIFT;
111	int offset = from & (PAGE_SIZE-1);
112	int cpylen;
113
114	while (len) {
115		if ((offset + len) > PAGE_SIZE)
116			cpylen = PAGE_SIZE - offset;	// multiple pages
117		else
118			cpylen = len;	// this page
119		len = len - cpylen;
120
121		page = page_read(mapping, index);
122		if (IS_ERR(page))
123			return PTR_ERR(page);
124
125		memcpy(buf, page_address(page) + offset, cpylen);
126		put_page(page);
127
128		if (retlen)
129			*retlen += cpylen;
130		buf += cpylen;
131		offset = 0;
132		index++;
133	}
134	return 0;
135}
136
137
138/* write data to the underlying device */
139static int _block2mtd_write(struct block2mtd_dev *dev, const u_char *buf,
140		loff_t to, size_t len, size_t *retlen)
141{
142	struct page *page;
143	struct address_space *mapping = dev->bdev_file->f_mapping;
144	pgoff_t index = to >> PAGE_SHIFT;	// page index
145	int offset = to & ~PAGE_MASK;	// page offset
146	int cpylen;
147
148	while (len) {
149		if ((offset+len) > PAGE_SIZE)
150			cpylen = PAGE_SIZE - offset;	// multiple pages
151		else
152			cpylen = len;			// this page
153		len = len - cpylen;
154
155		page = page_read(mapping, index);
156		if (IS_ERR(page))
157			return PTR_ERR(page);
158
159		if (memcmp(page_address(page)+offset, buf, cpylen)) {
160			lock_page(page);
161			memcpy(page_address(page) + offset, buf, cpylen);
162			set_page_dirty(page);
163			unlock_page(page);
164			balance_dirty_pages_ratelimited(mapping);
165		}
166		put_page(page);
167
168		if (retlen)
169			*retlen += cpylen;
170
171		buf += cpylen;
172		offset = 0;
173		index++;
174	}
175	return 0;
176}
177
178
179static int block2mtd_write(struct mtd_info *mtd, loff_t to, size_t len,
180		size_t *retlen, const u_char *buf)
181{
182	struct block2mtd_dev *dev = mtd->priv;
183	int err;
184
185	mutex_lock(&dev->write_mutex);
186	err = _block2mtd_write(dev, buf, to, len, retlen);
187	mutex_unlock(&dev->write_mutex);
188	if (err > 0)
189		err = 0;
190	return err;
191}
192
193
194/* sync the device - wait until the write queue is empty */
195static void block2mtd_sync(struct mtd_info *mtd)
196{
197	struct block2mtd_dev *dev = mtd->priv;
198	sync_blockdev(file_bdev(dev->bdev_file));
199	return;
200}
201
202
203static void block2mtd_free_device(struct block2mtd_dev *dev)
204{
205	if (!dev)
206		return;
207
208	kfree(dev->mtd.name);
209
210	if (dev->bdev_file) {
211		invalidate_mapping_pages(dev->bdev_file->f_mapping, 0, -1);
212		bdev_fput(dev->bdev_file);
213	}
214
215	kfree(dev);
216}
217
218/*
219 * This function is marked __ref because it calls the __init marked
220 * early_lookup_bdev when called from the early boot code.
221 */
222static struct file __ref *mdtblock_early_get_bdev(const char *devname,
223		blk_mode_t mode, int timeout, struct block2mtd_dev *dev)
224{
225	struct file *bdev_file = ERR_PTR(-ENODEV);
226#ifndef MODULE
227	int i;
228
229	/*
230	 * We can't use early_lookup_bdev from a running system.
231	 */
232	if (system_state >= SYSTEM_RUNNING)
233		return bdev_file;
234
235	/*
236	 * We might not have the root device mounted at this point.
237	 * Try to resolve the device name by other means.
238	 */
239	for (i = 0; i <= timeout; i++) {
240		dev_t devt;
241
242		if (i)
243			/*
244			 * Calling wait_for_device_probe in the first loop
245			 * was not enough, sleep for a bit in subsequent
246			 * go-arounds.
247			 */
248			msleep(1000);
249		wait_for_device_probe();
250
251		if (!early_lookup_bdev(devname, &devt)) {
252			bdev_file = bdev_file_open_by_dev(devt, mode, dev, NULL);
253			if (!IS_ERR(bdev_file))
254				break;
255		}
256	}
257#endif
258	return bdev_file;
259}
260
261static struct block2mtd_dev *add_device(char *devname, int erase_size,
262		char *label, int timeout)
263{
264	const blk_mode_t mode = BLK_OPEN_READ | BLK_OPEN_WRITE;
265	struct file *bdev_file;
266	struct block_device *bdev;
267	struct block2mtd_dev *dev;
268	char *name;
269
270	if (!devname)
271		return NULL;
272
273	dev = kzalloc(sizeof(struct block2mtd_dev), GFP_KERNEL);
274	if (!dev)
275		return NULL;
276
277	/* Get a handle on the device */
278	bdev_file = bdev_file_open_by_path(devname, mode, dev, NULL);
279	if (IS_ERR(bdev_file))
280		bdev_file = mdtblock_early_get_bdev(devname, mode, timeout,
281						      dev);
282	if (IS_ERR(bdev_file)) {
283		pr_err("error: cannot open device %s\n", devname);
284		goto err_free_block2mtd;
285	}
286	dev->bdev_file = bdev_file;
287	bdev = file_bdev(bdev_file);
288
289	if (MAJOR(bdev->bd_dev) == MTD_BLOCK_MAJOR) {
290		pr_err("attempting to use an MTD device as a block device\n");
291		goto err_free_block2mtd;
292	}
293
294	if ((long)bdev->bd_inode->i_size % erase_size) {
295		pr_err("erasesize must be a divisor of device size\n");
296		goto err_free_block2mtd;
297	}
298
299	mutex_init(&dev->write_mutex);
300
301	/* Setup the MTD structure */
302	/* make the name contain the block device in */
303	if (!label)
304		name = kasprintf(GFP_KERNEL, "block2mtd: %s", devname);
305	else
306		name = kstrdup(label, GFP_KERNEL);
307	if (!name)
308		goto err_destroy_mutex;
309
310	dev->mtd.name = name;
311
312	dev->mtd.size = bdev->bd_inode->i_size & PAGE_MASK;
313	dev->mtd.erasesize = erase_size;
314	dev->mtd.writesize = 1;
315	dev->mtd.writebufsize = PAGE_SIZE;
316	dev->mtd.type = MTD_RAM;
317	dev->mtd.flags = MTD_CAP_RAM;
318	dev->mtd._erase = block2mtd_erase;
319	dev->mtd._write = block2mtd_write;
320	dev->mtd._sync = block2mtd_sync;
321	dev->mtd._read = block2mtd_read;
322	dev->mtd.priv = dev;
323	dev->mtd.owner = THIS_MODULE;
324
325	if (mtd_device_register(&dev->mtd, NULL, 0)) {
326		/* Device didn't get added, so free the entry */
327		goto err_destroy_mutex;
328	}
329
330	list_add(&dev->list, &blkmtd_device_list);
331	pr_info("mtd%d: [%s] erase_size = %dKiB [%d]\n",
332		dev->mtd.index,
333		label ? label : dev->mtd.name + strlen("block2mtd: "),
334		dev->mtd.erasesize >> 10, dev->mtd.erasesize);
335	return dev;
336
337err_destroy_mutex:
338	mutex_destroy(&dev->write_mutex);
339err_free_block2mtd:
340	block2mtd_free_device(dev);
341	return NULL;
342}
343
344
345/* This function works similar to reguler strtoul.  In addition, it
346 * allows some suffixes for a more human-readable number format:
347 * ki, Ki, kiB, KiB	- multiply result with 1024
348 * Mi, MiB		- multiply result with 1024^2
349 * Gi, GiB		- multiply result with 1024^3
350 */
351static int ustrtoul(const char *cp, char **endp, unsigned int base)
352{
353	unsigned long result = simple_strtoul(cp, endp, base);
354	switch (**endp) {
355	case 'G' :
356		result *= 1024;
357		fallthrough;
358	case 'M':
359		result *= 1024;
360		fallthrough;
361	case 'K':
362	case 'k':
363		result *= 1024;
364	/* By dwmw2 editorial decree, "ki", "Mi" or "Gi" are to be used. */
365		if ((*endp)[1] == 'i') {
366			if ((*endp)[2] == 'B')
367				(*endp) += 3;
368			else
369				(*endp) += 2;
370		}
371	}
372	return result;
373}
374
375
376static int parse_num(size_t *num, const char *token)
377{
378	char *endp;
379	size_t n;
380
381	n = (size_t) ustrtoul(token, &endp, 0);
382	if (*endp)
383		return -EINVAL;
384
385	*num = n;
386	return 0;
387}
388
389
390static inline void kill_final_newline(char *str)
391{
392	char *newline = strrchr(str, '\n');
393	if (newline && !newline[1])
394		*newline = 0;
395}
396
397
398#ifndef MODULE
399static int block2mtd_init_called = 0;
400/* 80 for device, 12 for erase size */
401static char block2mtd_paramline[80 + 12];
402#endif
403
404static int block2mtd_setup2(const char *val)
405{
406	/* 80 for device, 12 for erase size, 80 for name, 8 for timeout */
407	char buf[80 + 12 + 80 + 8];
408	char *str = buf;
409	char *token[BLOCK2MTD_PARAM_MAX_COUNT];
410	char *name;
411	char *label = NULL;
412	size_t erase_size = PAGE_SIZE;
413	unsigned long timeout = MTD_DEFAULT_TIMEOUT;
414	int i, ret;
415
416	if (strnlen(val, sizeof(buf)) >= sizeof(buf)) {
417		pr_err("parameter too long\n");
418		return 0;
419	}
420
421	strcpy(str, val);
422	kill_final_newline(str);
423
424	for (i = 0; i < BLOCK2MTD_PARAM_MAX_COUNT; i++)
425		token[i] = strsep(&str, ",");
426
427	if (str) {
428		pr_err("too many arguments\n");
429		return 0;
430	}
431
432	if (!token[0]) {
433		pr_err("no argument\n");
434		return 0;
435	}
436
437	name = token[0];
438	if (strlen(name) + 1 > 80) {
439		pr_err("device name too long\n");
440		return 0;
441	}
442
443	/* Optional argument when custom label is used */
444	if (token[1] && strlen(token[1])) {
445		ret = parse_num(&erase_size, token[1]);
446		if (ret) {
447			pr_err("illegal erase size\n");
448			return 0;
449		}
450	}
451
452	if (token[2]) {
453		label = token[2];
454		pr_info("Using custom MTD label '%s' for dev %s\n", label, name);
455	}
456
457	add_device(name, erase_size, label, timeout);
458
459	return 0;
460}
461
462
463static int block2mtd_setup(const char *val, const struct kernel_param *kp)
464{
465#ifdef MODULE
466	return block2mtd_setup2(val);
467#else
468	/* If more parameters are later passed in via
469	   /sys/module/block2mtd/parameters/block2mtd
470	   and block2mtd_init() has already been called,
471	   we can parse the argument now. */
472
473	if (block2mtd_init_called)
474		return block2mtd_setup2(val);
475
476	/* During early boot stage, we only save the parameters
477	   here. We must parse them later: if the param passed
478	   from kernel boot command line, block2mtd_setup() is
479	   called so early that it is not possible to resolve
480	   the device (even kmalloc() fails). Deter that work to
481	   block2mtd_setup2(). */
482
483	strscpy(block2mtd_paramline, val, sizeof(block2mtd_paramline));
484
485	return 0;
486#endif
487}
488
489
490module_param_call(block2mtd, block2mtd_setup, NULL, NULL, 0200);
491MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,[<erasesize>][,<label>]]\"");
492
493static int __init block2mtd_init(void)
494{
495	int ret = 0;
496
497#ifndef MODULE
498	if (strlen(block2mtd_paramline))
499		ret = block2mtd_setup2(block2mtd_paramline);
500	block2mtd_init_called = 1;
501#endif
502
503	return ret;
504}
505
506
507static void block2mtd_exit(void)
508{
509	struct list_head *pos, *next;
510
511	/* Remove the MTD devices */
512	list_for_each_safe(pos, next, &blkmtd_device_list) {
513		struct block2mtd_dev *dev = list_entry(pos, typeof(*dev), list);
514		block2mtd_sync(&dev->mtd);
515		mtd_device_unregister(&dev->mtd);
516		mutex_destroy(&dev->write_mutex);
517		pr_info("mtd%d: [%s] removed\n",
518			dev->mtd.index,
519			dev->mtd.name + strlen("block2mtd: "));
520		list_del(&dev->list);
521		block2mtd_free_device(dev);
522	}
523}
524
525late_initcall(block2mtd_init);
526module_exit(block2mtd_exit);
527
528MODULE_LICENSE("GPL");
529MODULE_AUTHOR("Joern Engel <joern@lazybastard.org>");
530MODULE_DESCRIPTION("Emulate an MTD using a block device");
531