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