build.c 40.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * Copyright (c) International Business Machines Corp., 2006
 * Copyright (c) Nokia Corporation, 2007
 *
 * 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; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * Author: Artem Bityutskiy (Битюцкий Артём),
 *         Frank Haverkamp
 */

/*
24 25 26 27 28 29
 * This file includes UBI initialization and building of UBI devices.
 *
 * When UBI is initialized, it attaches all the MTD devices specified as the
 * module load parameters or the kernel boot parameters. If MTD devices were
 * specified, UBI does not attach any MTD device, but it is possible to do
 * later using the "UBI control device".
30 31 32 33 34 35
 */

#include <linux/err.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/stringify.h>
36
#include <linux/namei.h>
37
#include <linux/stat.h>
38
#include <linux/miscdevice.h>
39
#include <linux/mtd/partitions.h>
Vignesh Babu's avatar
Vignesh Babu committed
40
#include <linux/log2.h>
41
#include <linux/kthread.h>
Roel Kluin's avatar
Roel Kluin committed
42
#include <linux/kernel.h>
43
#include <linux/slab.h>
44 45 46 47 48
#include "ubi.h"

/* Maximum length of the 'mtd=' parameter */
#define MTD_PARAM_LEN_MAX 64

49 50 51
/* Maximum number of comma-separated items in the 'mtd=' parameter */
#define MTD_PARAM_MAX_COUNT 2

52 53 54 55 56 57
#ifdef CONFIG_MTD_UBI_MODULE
#define ubi_is_module() 1
#else
#define ubi_is_module() 0
#endif

58 59
/**
 * struct mtd_dev_param - MTD device parameter description data structure.
60 61
 * @name: MTD character device node path, MTD device name, or MTD device number
 *        string
62 63
 * @vid_hdr_offs: VID header offset
 */
64
struct mtd_dev_param {
65 66 67 68 69
	char name[MTD_PARAM_LEN_MAX];
	int vid_hdr_offs;
};

/* Numbers of elements set in the @mtd_dev_param array */
70
static int __initdata mtd_devs;
71 72

/* MTD devices specification parameters */
73
static struct mtd_dev_param __initdata mtd_dev_param[UBI_MAX_DEVICES];
74 75 76 77

/* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */
struct class *ubi_class;

78 79 80
/* Slab cache for wear-leveling entries */
struct kmem_cache *ubi_wl_entry_slab;

81 82 83 84 85 86
/* UBI control character device */
static struct miscdevice ubi_ctrl_cdev = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "ubi_ctrl",
	.fops = &ubi_ctrl_cdev_operations,
};
87

88 89 90
/* All UBI devices in system */
static struct ubi_device *ubi_devices[UBI_MAX_DEVICES];

91 92 93
/* Serializes UBI devices creations and removals */
DEFINE_MUTEX(ubi_devices_mutex);

94 95 96
/* Protects @ubi_devices and @ubi->ref_count */
static DEFINE_SPINLOCK(ubi_devices_lock);

97
/* "Show" method for files in '/<sysfs>/class/ubi/' */
98 99
static ssize_t ubi_version_show(struct class *class,
				struct class_attribute *attr, char *buf)
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
{
	return sprintf(buf, "%d\n", UBI_VERSION);
}

/* UBI version attribute ('/<sysfs>/class/ubi/version') */
static struct class_attribute ubi_version =
	__ATTR(version, S_IRUGO, ubi_version_show, NULL);

static ssize_t dev_attribute_show(struct device *dev,
				  struct device_attribute *attr, char *buf);

/* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */
static struct device_attribute dev_eraseblock_size =
	__ATTR(eraseblock_size, S_IRUGO, dev_attribute_show, NULL);
static struct device_attribute dev_avail_eraseblocks =
	__ATTR(avail_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
static struct device_attribute dev_total_eraseblocks =
	__ATTR(total_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
static struct device_attribute dev_volumes_count =
	__ATTR(volumes_count, S_IRUGO, dev_attribute_show, NULL);
static struct device_attribute dev_max_ec =
	__ATTR(max_ec, S_IRUGO, dev_attribute_show, NULL);
static struct device_attribute dev_reserved_for_bad =
	__ATTR(reserved_for_bad, S_IRUGO, dev_attribute_show, NULL);
static struct device_attribute dev_bad_peb_count =
	__ATTR(bad_peb_count, S_IRUGO, dev_attribute_show, NULL);
static struct device_attribute dev_max_vol_count =
	__ATTR(max_vol_count, S_IRUGO, dev_attribute_show, NULL);
static struct device_attribute dev_min_io_size =
	__ATTR(min_io_size, S_IRUGO, dev_attribute_show, NULL);
static struct device_attribute dev_bgt_enabled =
	__ATTR(bgt_enabled, S_IRUGO, dev_attribute_show, NULL);
132 133
static struct device_attribute dev_mtd_num =
	__ATTR(mtd_num, S_IRUGO, dev_attribute_show, NULL);
134

Dmitry Pervushin's avatar
Dmitry Pervushin committed
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
/**
 * ubi_volume_notify - send a volume change notification.
 * @ubi: UBI device description object
 * @vol: volume description object of the changed volume
 * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc)
 *
 * This is a helper function which notifies all subscribers about a volume
 * change event (creation, removal, re-sizing, re-naming, updating). Returns
 * zero in case of success and a negative error code in case of failure.
 */
int ubi_volume_notify(struct ubi_device *ubi, struct ubi_volume *vol, int ntype)
{
	struct ubi_notification nt;

	ubi_do_get_device_info(ubi, &nt.di);
	ubi_do_get_volume_info(ubi, vol, &nt.vi);
	return blocking_notifier_call_chain(&ubi_notifiers, ntype, &nt);
}

/**
 * ubi_notify_all - send a notification to all volumes.
 * @ubi: UBI device description object
 * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc)
 * @nb: the notifier to call
 *
 * This function walks all volumes of UBI device @ubi and sends the @ntype
 * notification for each volume. If @nb is %NULL, then all registered notifiers
 * are called, otherwise only the @nb notifier is called. Returns the number of
 * sent notifications.
 */
int ubi_notify_all(struct ubi_device *ubi, int ntype, struct notifier_block *nb)
{
	struct ubi_notification nt;
	int i, count = 0;

	ubi_do_get_device_info(ubi, &nt.di);

	mutex_lock(&ubi->device_mutex);
	for (i = 0; i < ubi->vtbl_slots; i++) {
		/*
		 * Since the @ubi->device is locked, and we are not going to
		 * change @ubi->volumes, we do not have to lock
		 * @ubi->volumes_lock.
		 */
		if (!ubi->volumes[i])
			continue;

		ubi_do_get_volume_info(ubi, ubi->volumes[i], &nt.vi);
		if (nb)
			nb->notifier_call(nb, ntype, &nt);
		else
			blocking_notifier_call_chain(&ubi_notifiers, ntype,
						     &nt);
		count += 1;
	}
	mutex_unlock(&ubi->device_mutex);

	return count;
}

/**
 * ubi_enumerate_volumes - send "add" notification for all existing volumes.
 * @nb: the notifier to call
 *
 * This function walks all UBI devices and volumes and sends the
 * %UBI_VOLUME_ADDED notification for each volume. If @nb is %NULL, then all
 * registered notifiers are called, otherwise only the @nb notifier is called.
 * Returns the number of sent notifications.
 */
int ubi_enumerate_volumes(struct notifier_block *nb)
{
	int i, count = 0;

	/*
	 * Since the @ubi_devices_mutex is locked, and we are not going to
	 * change @ubi_devices, we do not have to lock @ubi_devices_lock.
	 */
	for (i = 0; i < UBI_MAX_DEVICES; i++) {
		struct ubi_device *ubi = ubi_devices[i];

		if (!ubi)
			continue;
		count += ubi_notify_all(ubi, UBI_VOLUME_ADDED, nb);
	}

	return count;
}

223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
/**
 * ubi_get_device - get UBI device.
 * @ubi_num: UBI device number
 *
 * This function returns UBI device description object for UBI device number
 * @ubi_num, or %NULL if the device does not exist. This function increases the
 * device reference count to prevent removal of the device. In other words, the
 * device cannot be removed if its reference count is not zero.
 */
struct ubi_device *ubi_get_device(int ubi_num)
{
	struct ubi_device *ubi;

	spin_lock(&ubi_devices_lock);
	ubi = ubi_devices[ubi_num];
	if (ubi) {
		ubi_assert(ubi->ref_count >= 0);
		ubi->ref_count += 1;
		get_device(&ubi->dev);
	}
	spin_unlock(&ubi_devices_lock);

	return ubi;
}

/**
 * ubi_put_device - drop an UBI device reference.
 * @ubi: UBI device description object
 */
void ubi_put_device(struct ubi_device *ubi)
{
	spin_lock(&ubi_devices_lock);
	ubi->ref_count -= 1;
	put_device(&ubi->dev);
	spin_unlock(&ubi_devices_lock);
}

/**
261
 * ubi_get_by_major - get UBI device by character device major number.
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
 * @major: major number
 *
 * This function is similar to 'ubi_get_device()', but it searches the device
 * by its major number.
 */
struct ubi_device *ubi_get_by_major(int major)
{
	int i;
	struct ubi_device *ubi;

	spin_lock(&ubi_devices_lock);
	for (i = 0; i < UBI_MAX_DEVICES; i++) {
		ubi = ubi_devices[i];
		if (ubi && MAJOR(ubi->cdev.dev) == major) {
			ubi_assert(ubi->ref_count >= 0);
			ubi->ref_count += 1;
			get_device(&ubi->dev);
			spin_unlock(&ubi_devices_lock);
			return ubi;
		}
	}
	spin_unlock(&ubi_devices_lock);

	return NULL;
}

/**
 * ubi_major2num - get UBI device number by character device major number.
 * @major: major number
 *
 * This function searches UBI device number object by its major number. If UBI
293
 * device was not found, this function returns -ENODEV, otherwise the UBI device
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
 * number is returned.
 */
int ubi_major2num(int major)
{
	int i, ubi_num = -ENODEV;

	spin_lock(&ubi_devices_lock);
	for (i = 0; i < UBI_MAX_DEVICES; i++) {
		struct ubi_device *ubi = ubi_devices[i];

		if (ubi && MAJOR(ubi->cdev.dev) == major) {
			ubi_num = ubi->ubi_num;
			break;
		}
	}
	spin_unlock(&ubi_devices_lock);

	return ubi_num;
}

314 315 316 317
/* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */
static ssize_t dev_attribute_show(struct device *dev,
				  struct device_attribute *attr, char *buf)
{
318 319
	ssize_t ret;
	struct ubi_device *ubi;
320

321 322 323 324 325 326 327 328 329 330
	/*
	 * The below code looks weird, but it actually makes sense. We get the
	 * UBI device reference from the contained 'struct ubi_device'. But it
	 * is unclear if the device was removed or not yet. Indeed, if the
	 * device was removed before we increased its reference count,
	 * 'ubi_get_device()' will return -ENODEV and we fail.
	 *
	 * Remember, 'struct ubi_device' is freed in the release function, so
	 * we still can use 'ubi->ubi_num'.
	 */
331
	ubi = container_of(dev, struct ubi_device, dev);
332 333 334 335
	ubi = ubi_get_device(ubi->ubi_num);
	if (!ubi)
		return -ENODEV;

336
	if (attr == &dev_eraseblock_size)
337
		ret = sprintf(buf, "%d\n", ubi->leb_size);
338
	else if (attr == &dev_avail_eraseblocks)
339
		ret = sprintf(buf, "%d\n", ubi->avail_pebs);
340
	else if (attr == &dev_total_eraseblocks)
341
		ret = sprintf(buf, "%d\n", ubi->good_peb_count);
342
	else if (attr == &dev_volumes_count)
343
		ret = sprintf(buf, "%d\n", ubi->vol_count - UBI_INT_VOL_COUNT);
344
	else if (attr == &dev_max_ec)
345
		ret = sprintf(buf, "%d\n", ubi->max_ec);
346
	else if (attr == &dev_reserved_for_bad)
347
		ret = sprintf(buf, "%d\n", ubi->beb_rsvd_pebs);
348
	else if (attr == &dev_bad_peb_count)
349
		ret = sprintf(buf, "%d\n", ubi->bad_peb_count);
350
	else if (attr == &dev_max_vol_count)
351
		ret = sprintf(buf, "%d\n", ubi->vtbl_slots);
352
	else if (attr == &dev_min_io_size)
353
		ret = sprintf(buf, "%d\n", ubi->min_io_size);
354
	else if (attr == &dev_bgt_enabled)
355
		ret = sprintf(buf, "%d\n", ubi->thread_enabled);
356 357
	else if (attr == &dev_mtd_num)
		ret = sprintf(buf, "%d\n", ubi->mtd->index);
358
	else
359
		ret = -EINVAL;
360

361 362
	ubi_put_device(ubi);
	return ret;
363 364
}

365 366 367 368 369 370
static void dev_release(struct device *dev)
{
	struct ubi_device *ubi = container_of(dev, struct ubi_device, dev);

	kfree(ubi);
}
371 372 373 374

/**
 * ubi_sysfs_init - initialize sysfs for an UBI device.
 * @ubi: UBI device description object
375 376
 * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was
 *       taken
377 378 379 380
 *
 * This function returns zero in case of success and a negative error code in
 * case of failure.
 */
381
static int ubi_sysfs_init(struct ubi_device *ubi, int *ref)
382 383 384 385
{
	int err;

	ubi->dev.release = dev_release;
386
	ubi->dev.devt = ubi->cdev.dev;
387
	ubi->dev.class = ubi_class;
388
	dev_set_name(&ubi->dev, UBI_NAME_STR"%d", ubi->ubi_num);
389 390
	err = device_register(&ubi->dev);
	if (err)
391
		return err;
392

393
	*ref = 1;
394 395
	err = device_create_file(&ubi->dev, &dev_eraseblock_size);
	if (err)
396
		return err;
397 398
	err = device_create_file(&ubi->dev, &dev_avail_eraseblocks);
	if (err)
399
		return err;
400 401
	err = device_create_file(&ubi->dev, &dev_total_eraseblocks);
	if (err)
402
		return err;
403 404
	err = device_create_file(&ubi->dev, &dev_volumes_count);
	if (err)
405
		return err;
406 407
	err = device_create_file(&ubi->dev, &dev_max_ec);
	if (err)
408
		return err;
409 410
	err = device_create_file(&ubi->dev, &dev_reserved_for_bad);
	if (err)
411
		return err;
412 413
	err = device_create_file(&ubi->dev, &dev_bad_peb_count);
	if (err)
414
		return err;
415 416
	err = device_create_file(&ubi->dev, &dev_max_vol_count);
	if (err)
417
		return err;
418 419
	err = device_create_file(&ubi->dev, &dev_min_io_size);
	if (err)
420
		return err;
421
	err = device_create_file(&ubi->dev, &dev_bgt_enabled);
422 423 424
	if (err)
		return err;
	err = device_create_file(&ubi->dev, &dev_mtd_num);
425 426 427 428 429 430 431 432 433
	return err;
}

/**
 * ubi_sysfs_close - close sysfs for an UBI device.
 * @ubi: UBI device description object
 */
static void ubi_sysfs_close(struct ubi_device *ubi)
{
434
	device_remove_file(&ubi->dev, &dev_mtd_num);
435 436 437 438 439 440 441 442 443 444 445 446 447 448
	device_remove_file(&ubi->dev, &dev_bgt_enabled);
	device_remove_file(&ubi->dev, &dev_min_io_size);
	device_remove_file(&ubi->dev, &dev_max_vol_count);
	device_remove_file(&ubi->dev, &dev_bad_peb_count);
	device_remove_file(&ubi->dev, &dev_reserved_for_bad);
	device_remove_file(&ubi->dev, &dev_max_ec);
	device_remove_file(&ubi->dev, &dev_volumes_count);
	device_remove_file(&ubi->dev, &dev_total_eraseblocks);
	device_remove_file(&ubi->dev, &dev_avail_eraseblocks);
	device_remove_file(&ubi->dev, &dev_eraseblock_size);
	device_unregister(&ubi->dev);
}

/**
449
 * kill_volumes - destroy all user volumes.
450 451 452 453 454 455 456 457
 * @ubi: UBI device description object
 */
static void kill_volumes(struct ubi_device *ubi)
{
	int i;

	for (i = 0; i < ubi->vtbl_slots; i++)
		if (ubi->volumes[i])
458
			ubi_free_volume(ubi, ubi->volumes[i]);
459 460 461 462 463
}

/**
 * uif_init - initialize user interfaces for an UBI device.
 * @ubi: UBI device description object
464 465 466 467 468 469 470 471 472 473 474
 * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was
 *       taken, otherwise set to %0
 *
 * This function initializes various user interfaces for an UBI device. If the
 * initialization fails at an early stage, this function frees all the
 * resources it allocated, returns an error, and @ref is set to %0. However,
 * if the initialization fails after the UBI device was registered in the
 * driver core subsystem, this function takes a reference to @ubi->dev, because
 * otherwise the release function ('dev_release()') would free whole @ubi
 * object. The @ref argument is set to %1 in this case. The caller has to put
 * this reference.
475 476
 *
 * This function returns zero in case of success and a negative error code in
477
 * case of failure.
478
 */
479
static int uif_init(struct ubi_device *ubi, int *ref)
480
{
481
	int i, err;
482 483
	dev_t dev;

484
	*ref = 0;
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
	sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);

	/*
	 * Major numbers for the UBI character devices are allocated
	 * dynamically. Major numbers of volume character devices are
	 * equivalent to ones of the corresponding UBI character device. Minor
	 * numbers of UBI character devices are 0, while minor numbers of
	 * volume character devices start from 1. Thus, we allocate one major
	 * number and ubi->vtbl_slots + 1 minor numbers.
	 */
	err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name);
	if (err) {
		ubi_err("cannot register UBI character devices");
		return err;
	}

501
	ubi_assert(MINOR(dev) == 0);
502
	cdev_init(&ubi->cdev, &ubi_cdev_operations);
503
	dbg_gen("%s major is %u", ubi->ubi_name, MAJOR(dev));
504 505 506 507
	ubi->cdev.owner = THIS_MODULE;

	err = cdev_add(&ubi->cdev, dev, 1);
	if (err) {
508
		ubi_err("cannot add character device");
509 510 511
		goto out_unreg;
	}

512
	err = ubi_sysfs_init(ubi, ref);
513
	if (err)
514
		goto out_sysfs;
515 516 517

	for (i = 0; i < ubi->vtbl_slots; i++)
		if (ubi->volumes[i]) {
518
			err = ubi_add_volume(ubi, ubi->volumes[i]);
519 520
			if (err) {
				ubi_err("cannot add volume %d", i);
521
				goto out_volumes;
522
			}
523 524 525 526 527 528
		}

	return 0;

out_volumes:
	kill_volumes(ubi);
529
out_sysfs:
530 531
	if (*ref)
		get_device(&ubi->dev);
532 533 534
	ubi_sysfs_close(ubi);
	cdev_del(&ubi->cdev);
out_unreg:
535
	unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
536
	ubi_err("cannot initialize UBI %s, error %d", ubi->ubi_name, err);
537 538 539 540 541 542
	return err;
}

/**
 * uif_close - close user interfaces for an UBI device.
 * @ubi: UBI device description object
543 544 545 546
 *
 * Note, since this function un-registers UBI volume device objects (@vol->dev),
 * the memory allocated voe the volumes is freed as well (in the release
 * function).
547 548 549 550 551 552
 */
static void uif_close(struct ubi_device *ubi)
{
	kill_volumes(ubi);
	ubi_sysfs_close(ubi);
	cdev_del(&ubi->cdev);
553
	unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
554 555
}

556
/**
557
 * ubi_free_internal_volumes - free internal volumes.
558 559
 * @ubi: UBI device description object
 */
560
void ubi_free_internal_volumes(struct ubi_device *ubi)
561 562 563 564 565 566 567 568 569 570
{
	int i;

	for (i = ubi->vtbl_slots;
	     i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) {
		kfree(ubi->volumes[i]->eba_tbl);
		kfree(ubi->volumes[i]);
	}
}

571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
static int get_bad_peb_limit(const struct ubi_device *ubi, int max_beb_per1024)
{
	int limit, device_pebs;
	uint64_t device_size;

	if (!max_beb_per1024)
		return 0;

	/*
	 * Here we are using size of the entire flash chip and
	 * not just the MTD partition size because the maximum
	 * number of bad eraseblocks is a percentage of the
	 * whole device and bad eraseblocks are not fairly
	 * distributed over the flash chip. So the worst case
	 * is that all the bad eraseblocks of the chip are in
	 * the MTD partition we are attaching (ubi->mtd).
	 */
	device_size = mtd_get_device_size(ubi->mtd);
	device_pebs = mtd_div_by_eb(device_size, ubi->mtd);
	limit = mult_frac(device_pebs, max_beb_per1024, 1024);

	/* Round it up */
	if (mult_frac(limit, 1024, max_beb_per1024) < device_pebs)
		limit += 1;

	return limit;
}

599
/**
Artem Bityutskiy's avatar
Artem Bityutskiy committed
600
 * io_init - initialize I/O sub-system for a given UBI device.
601 602 603 604 605 606
 * @ubi: UBI device description object
 *
 * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are
 * assumed:
 *   o EC header is always at offset zero - this cannot be changed;
 *   o VID header starts just after the EC header at the closest address
607
 *     aligned to @io->hdrs_min_io_size;
608
 *   o data starts just after the VID header at the closest address aligned to
609
 *     @io->min_io_size
610 611 612 613 614 615
 *
 * This function returns zero in case of success and a negative error code in
 * case of failure.
 */
static int io_init(struct ubi_device *ubi)
{
616 617
	const int max_beb_per1024 = CONFIG_MTD_UBI_BEB_LIMIT;

618 619 620 621 622 623 624 625 626 627 628 629 630 631
	if (ubi->mtd->numeraseregions != 0) {
		/*
		 * Some flashes have several erase regions. Different regions
		 * may have different eraseblock size and other
		 * characteristics. It looks like mostly multi-region flashes
		 * have one "main" region and one or more small regions to
		 * store boot loader code or boot parameters or whatever. I
		 * guess we should just pick the largest region. But this is
		 * not implemented.
		 */
		ubi_err("multiple regions, not implemented");
		return -EINVAL;
	}

Artem Bityutskiy's avatar
Artem Bityutskiy committed
632
	if (ubi->vid_hdr_offset < 0)
633 634
		return -EINVAL;

635 636 637 638 639 640
	/*
	 * Note, in this implementation we support MTD devices with 0x7FFFFFFF
	 * physical eraseblocks maximum.
	 */

	ubi->peb_size   = ubi->mtd->erasesize;
641
	ubi->peb_count  = mtd_div_by_eb(ubi->mtd->size, ubi->mtd);
642 643
	ubi->flash_size = ubi->mtd->size;

644
	if (mtd_can_have_bb(ubi->mtd)) {
645
		ubi->bad_allowed = 1;
646
		ubi->bad_peb_limit = get_bad_peb_limit(ubi, max_beb_per1024);
647
	}
648

649 650 651 652 653
	if (ubi->mtd->type == MTD_NORFLASH) {
		ubi_assert(ubi->mtd->writesize == 1);
		ubi->nor_flash = 1;
	}

654 655 656
	ubi->min_io_size = ubi->mtd->writesize;
	ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft;

657 658 659 660 661
	/*
	 * Make sure minimal I/O unit is power of 2. Note, there is no
	 * fundamental reason for this assumption. It is just an optimization
	 * which allows us to avoid costly division operations.
	 */
Vignesh Babu's avatar
Vignesh Babu committed
662
	if (!is_power_of_2(ubi->min_io_size)) {
663 664
		ubi_err("min. I/O unit (%d) is not power of 2",
			ubi->min_io_size);
665 666 667 668 669 670 671
		return -EINVAL;
	}

	ubi_assert(ubi->hdrs_min_io_size > 0);
	ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size);
	ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0);

672 673 674 675 676 677 678 679 680 681 682 683 684
	ubi->max_write_size = ubi->mtd->writebufsize;
	/*
	 * Maximum write size has to be greater or equivalent to min. I/O
	 * size, and be multiple of min. I/O size.
	 */
	if (ubi->max_write_size < ubi->min_io_size ||
	    ubi->max_write_size % ubi->min_io_size ||
	    !is_power_of_2(ubi->max_write_size)) {
		ubi_err("bad write buffer size %d for %d min. I/O unit",
			ubi->max_write_size, ubi->min_io_size);
		return -EINVAL;
	}

685 686 687 688 689
	/* Calculate default aligned sizes of EC and VID headers */
	ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size);
	ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size);

	dbg_msg("min_io_size      %d", ubi->min_io_size);
690
	dbg_msg("max_write_size   %d", ubi->max_write_size);
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706
	dbg_msg("hdrs_min_io_size %d", ubi->hdrs_min_io_size);
	dbg_msg("ec_hdr_alsize    %d", ubi->ec_hdr_alsize);
	dbg_msg("vid_hdr_alsize   %d", ubi->vid_hdr_alsize);

	if (ubi->vid_hdr_offset == 0)
		/* Default offset */
		ubi->vid_hdr_offset = ubi->vid_hdr_aloffset =
				      ubi->ec_hdr_alsize;
	else {
		ubi->vid_hdr_aloffset = ubi->vid_hdr_offset &
						~(ubi->hdrs_min_io_size - 1);
		ubi->vid_hdr_shift = ubi->vid_hdr_offset -
						ubi->vid_hdr_aloffset;
	}

	/* Similar for the data offset */
707
	ubi->leb_start = ubi->vid_hdr_offset + UBI_VID_HDR_SIZE;
Artem Bityutskiy's avatar
Artem Bityutskiy committed
708
	ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size);
709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725

	dbg_msg("vid_hdr_offset   %d", ubi->vid_hdr_offset);
	dbg_msg("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset);
	dbg_msg("vid_hdr_shift    %d", ubi->vid_hdr_shift);
	dbg_msg("leb_start        %d", ubi->leb_start);

	/* The shift must be aligned to 32-bit boundary */
	if (ubi->vid_hdr_shift % 4) {
		ubi_err("unaligned VID header shift %d",
			ubi->vid_hdr_shift);
		return -EINVAL;
	}

	/* Check sanity */
	if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE ||
	    ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE ||
	    ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE ||
726
	    ubi->leb_start & (ubi->min_io_size - 1)) {
727 728 729 730 731
		ubi_err("bad VID header (%d) or data offsets (%d)",
			ubi->vid_hdr_offset, ubi->leb_start);
		return -EINVAL;
	}

732 733 734 735 736 737 738 739 740
	/*
	 * Set maximum amount of physical erroneous eraseblocks to be 10%.
	 * Erroneous PEB are those which have read errors.
	 */
	ubi->max_erroneous = ubi->peb_count / 10;
	if (ubi->max_erroneous < 16)
		ubi->max_erroneous = 16;
	dbg_msg("max_erroneous    %d", ubi->max_erroneous);

741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
	/*
	 * It may happen that EC and VID headers are situated in one minimal
	 * I/O unit. In this case we can only accept this UBI image in
	 * read-only mode.
	 */
	if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) {
		ubi_warn("EC and VID headers are in the same minimal I/O unit, "
			 "switch to read-only mode");
		ubi->ro_mode = 1;
	}

	ubi->leb_size = ubi->peb_size - ubi->leb_start;

	if (!(ubi->mtd->flags & MTD_WRITEABLE)) {
		ubi_msg("MTD device %d is write-protected, attach in "
			"read-only mode", ubi->mtd->index);
		ubi->ro_mode = 1;
	}

760 761 762 763 764 765 766 767 768 769
	ubi_msg("physical eraseblock size:   %d bytes (%d KiB)",
		ubi->peb_size, ubi->peb_size >> 10);
	ubi_msg("logical eraseblock size:    %d bytes", ubi->leb_size);
	ubi_msg("smallest flash I/O unit:    %d", ubi->min_io_size);
	if (ubi->hdrs_min_io_size != ubi->min_io_size)
		ubi_msg("sub-page size:              %d",
			ubi->hdrs_min_io_size);
	ubi_msg("VID header offset:          %d (aligned %d)",
		ubi->vid_hdr_offset, ubi->vid_hdr_aloffset);
	ubi_msg("data offset:                %d", ubi->leb_start);
770 771

	/*
772
	 * Note, ideally, we have to initialize @ubi->bad_peb_count here. But
773 774
	 * unfortunately, MTD does not provide this information. We should loop
	 * over all physical eraseblocks and invoke mtd->block_is_bad() for
775 776
	 * each physical eraseblock. So, we leave @ubi->bad_peb_count
	 * uninitialized so far.
777 778 779 780 781
	 */

	return 0;
}

782 783 784 785 786
/**
 * autoresize - re-size the volume which has the "auto-resize" flag set.
 * @ubi: UBI device description object
 * @vol_id: ID of the volume to re-size
 *
787
 * This function re-sizes the volume marked by the %UBI_VTBL_AUTORESIZE_FLG in
788 789 790 791 792 793 794 795 796 797 798 799
 * the volume table to the largest possible size. See comments in ubi-header.h
 * for more description of the flag. Returns zero in case of success and a
 * negative error code in case of failure.
 */
static int autoresize(struct ubi_device *ubi, int vol_id)
{
	struct ubi_volume_desc desc;
	struct ubi_volume *vol = ubi->volumes[vol_id];
	int err, old_reserved_pebs = vol->reserved_pebs;

	/*
	 * Clear the auto-resize flag in the volume in-memory copy of the
800
	 * volume table, and 'ubi_resize_volume()' will propagate this change
801 802 803 804 805 806 807 808
	 * to the flash.
	 */
	ubi->vtbl[vol_id].flags &= ~UBI_VTBL_AUTORESIZE_FLG;

	if (ubi->avail_pebs == 0) {
		struct ubi_vtbl_record vtbl_rec;

		/*
809
		 * No available PEBs to re-size the volume, clear the flag on
810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833
		 * flash and exit.
		 */
		memcpy(&vtbl_rec, &ubi->vtbl[vol_id],
		       sizeof(struct ubi_vtbl_record));
		err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
		if (err)
			ubi_err("cannot clean auto-resize flag for volume %d",
				vol_id);
	} else {
		desc.vol = vol;
		err = ubi_resize_volume(&desc,
					old_reserved_pebs + ubi->avail_pebs);
		if (err)
			ubi_err("cannot auto-resize volume %d", vol_id);
	}

	if (err)
		return err;

	ubi_msg("volume %d (\"%s\") re-sized from %d to %d LEBs", vol_id,
		vol->name, old_reserved_pebs, vol->reserved_pebs);
	return 0;
}

834
/**
835
 * ubi_attach_mtd_dev - attach an MTD device.
836
 * @mtd: MTD device description object
Artem Bityutskiy's avatar
Artem Bityutskiy committed
837
 * @ubi_num: number to assign to the new UBI device
838 839
 * @vid_hdr_offset: VID header offset
 *
Artem Bityutskiy's avatar
Artem Bityutskiy committed
840 841
 * This function attaches MTD device @mtd_dev to UBI and assign @ubi_num number
 * to the newly created UBI device, unless @ubi_num is %UBI_DEV_NUM_AUTO, in
842
 * which case this function finds a vacant device number and assigns it
Artem Bityutskiy's avatar
Artem Bityutskiy committed
843 844
 * automatically. Returns the new UBI device number in case of success and a
 * negative error code in case of failure.
845 846 847
 *
 * Note, the invocations of this function has to be serialized by the
 * @ubi_devices_mutex.
848
 */
Artem Bityutskiy's avatar
Artem Bityutskiy committed
849
int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
850 851
{
	struct ubi_device *ubi;
852
	int i, err, ref = 0;
853

854 855 856 857 858 859
	/*
	 * Check if we already have the same MTD device attached.
	 *
	 * Note, this function assumes that UBI devices creations and deletions
	 * are serialized, so it does not take the &ubi_devices_lock.
	 */
Artem Bityutskiy's avatar
Artem Bityutskiy committed
860
	for (i = 0; i < UBI_MAX_DEVICES; i++) {
861
		ubi = ubi_devices[i];
862
		if (ubi && mtd->index == ubi->mtd->index) {
Artem Bityutskiy's avatar
Artem Bityutskiy committed
863
			ubi_err("mtd%d is already attached to ubi%d",
864
				mtd->index, i);
Artem Bityutskiy's avatar
Artem Bityutskiy committed
865
			return -EEXIST;
866
		}
Artem Bityutskiy's avatar
Artem Bityutskiy committed
867
	}
868

Artem Bityutskiy's avatar
Artem Bityutskiy committed
869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888
	/*
	 * Make sure this MTD device is not emulated on top of an UBI volume
	 * already. Well, generally this recursion works fine, but there are
	 * different problems like the UBI module takes a reference to itself
	 * by attaching (and thus, opening) the emulated MTD device. This
	 * results in inability to unload the module. And in general it makes
	 * no sense to attach emulated MTD devices, so we prohibit this.
	 */
	if (mtd->type == MTD_UBIVOLUME) {
		ubi_err("refuse attaching mtd%d - it is already emulated on "
			"top of UBI", mtd->index);
		return -EINVAL;
	}

	if (ubi_num == UBI_DEV_NUM_AUTO) {
		/* Search for an empty slot in the @ubi_devices array */
		for (ubi_num = 0; ubi_num < UBI_MAX_DEVICES; ubi_num++)
			if (!ubi_devices[ubi_num])
				break;
		if (ubi_num == UBI_MAX_DEVICES) {
Artem Bityutskiy's avatar
Artem Bityutskiy committed
889
			ubi_err("only %d UBI devices may be created",
890
				UBI_MAX_DEVICES);
Artem Bityutskiy's avatar
Artem Bityutskiy committed
891 892 893 894 895
			return -ENFILE;
		}
	} else {
		if (ubi_num >= UBI_MAX_DEVICES)
			return -EINVAL;
896

Artem Bityutskiy's avatar
Artem Bityutskiy committed
897 898
		/* Make sure ubi_num is not busy */
		if (ubi_devices[ubi_num]) {
Artem Bityutskiy's avatar
Artem Bityutskiy committed
899
			ubi_err("ubi%d already exists", ubi_num);
Artem Bityutskiy's avatar
Artem Bityutskiy committed
900 901
			return -EEXIST;
		}
902 903
	}

904 905 906
	ubi = kzalloc(sizeof(struct ubi_device), GFP_KERNEL);
	if (!ubi)
		return -ENOMEM;
907

908
	ubi->mtd = mtd;
Artem Bityutskiy's avatar
Artem Bityutskiy committed
909
	ubi->ubi_num = ubi_num;
910
	ubi->vid_hdr_offset = vid_hdr_offset;
911 912 913 914
	ubi->autoresize_vol_id = -1;

	mutex_init(&ubi->buf_mutex);
	mutex_init(&ubi->ckvol_mutex);
915
	mutex_init(&ubi->device_mutex);
916
	spin_lock_init(&ubi->volumes_lock);
917

Artem Bityutskiy's avatar
Artem Bityutskiy committed
918
	ubi_msg("attaching mtd%d to ubi%d", mtd->index, ubi_num);
919
	dbg_msg("sizeof(struct ubi_ainf_peb) %zu", sizeof(struct ubi_ainf_peb));
920
	dbg_msg("sizeof(struct ubi_wl_entry) %zu", sizeof(struct ubi_wl_entry));
921

922 923 924 925
	err = io_init(ubi);
	if (err)
		goto out_free;

926
	err = -ENOMEM;
927 928
	ubi->peb_buf = vmalloc(ubi->peb_size);
	if (!ubi->peb_buf)
929 930
		goto out_free;

931 932 933 934
	err = ubi_debugging_init_dev(ubi);
	if (err)
		goto out_free;

935
	err = ubi_attach(ubi);
936
	if (err) {
937
		ubi_err("failed to attach mtd%d, error %d", mtd->index, err);
938
		goto out_debugging;
939 940
	}

941 942 943 944 945 946
	if (ubi->autoresize_vol_id != -1) {
		err = autoresize(ubi, ubi->autoresize_vol_id);
		if (err)
			goto out_detach;
	}

947
	err = uif_init(ubi, &ref);
948
	if (err)
949
		goto out_detach;
950

951 952 953 954
	err = ubi_debugfs_init_dev(ubi);
	if (err)
		goto out_uif;

955 956 957 958 959
	ubi->bgt_thread = kthread_create(ubi_thread, ubi, ubi->bgt_name);
	if (IS_ERR(ubi->bgt_thread)) {
		err = PTR_ERR(ubi->bgt_thread);
		ubi_err("cannot spawn \"%s\", error %d", ubi->bgt_name,
			err);
960
		goto out_debugfs;
961 962
	}

Artem Bityutskiy's avatar
Artem Bityutskiy committed
963
	ubi_msg("attached mtd%d to ubi%d", mtd->index, ubi_num);
964
	ubi_msg("MTD device name:            \"%s\"", mtd->name);
965 966 967
	ubi_msg("MTD device size:            %llu MiB", ubi->flash_size >> 20);
	ubi_msg("number of good PEBs:        %d", ubi->good_peb_count);
	ubi_msg("number of bad PEBs:         %d", ubi->bad_peb_count);
968
	ubi_msg("number of corrupted PEBs:   %d", ubi->corr_peb_count);
969 970 971 972 973 974 975 976 977 978
	ubi_msg("max. allowed volumes:       %d", ubi->vtbl_slots);
	ubi_msg("wear-leveling threshold:    %d", CONFIG_MTD_UBI_WL_THRESHOLD);
	ubi_msg("number of internal volumes: %d", UBI_INT_VOL_COUNT);
	ubi_msg("number of user volumes:     %d",
		ubi->vol_count - UBI_INT_VOL_COUNT);
	ubi_msg("available PEBs:             %d", ubi->avail_pebs);
	ubi_msg("total number of reserved PEBs: %d", ubi->rsvd_pebs);
	ubi_msg("number of PEBs reserved for bad PEB handling: %d",
		ubi->beb_rsvd_pebs);
	ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
979
	ubi_msg("image sequence number:  %u", ubi->image_seq);
980

Artem Bityutskiy's avatar
Artem Bityutskiy committed
981 982 983 984 985
	/*
	 * The below lock makes sure we do not race with 'ubi_thread()' which
	 * checks @ubi->thread_enabled. Otherwise we may fail to wake it up.
	 */
	spin_lock(&ubi->wl_lock);
986
	ubi->thread_enabled = 1;
987
	wake_up_process(ubi->bgt_thread);
Artem Bityutskiy's avatar
Artem Bityutskiy committed
988
	spin_unlock(&ubi->wl_lock);
989

Artem Bityutskiy's avatar
Artem Bityutskiy committed
990
	ubi_devices[ubi_num] = ubi;
Dmitry Pervushin's avatar
Dmitry Pervushin committed
991
	ubi_notify_all(ubi, UBI_VOLUME_ADDED, NULL);
Artem Bityutskiy's avatar
Artem Bityutskiy committed
992
	return ubi_num;
993

994 995
out_debugfs:
	ubi_debugfs_exit_dev(ubi);
996
out_uif:
997 998
	get_device(&ubi->dev);
	ubi_assert(ref);
999
	uif_close(ubi);
1000 1001
out_detach:
	ubi_wl_close(ubi);
1002
	ubi_free_internal_volumes(ubi);
1003
	vfree(ubi->vtbl);
1004 1005
out_debugging:
	ubi_debugging_exit_dev(ubi);
1006
out_free:
1007
	vfree(ubi->peb_buf);
1008 1009 1010 1011
	if (ref)
		put_device(&ubi->dev);
	else
		kfree(ubi);
1012 1013 1014 1015
	return err;
}

/**
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
 * ubi_detach_mtd_dev - detach an MTD device.
 * @ubi_num: UBI device number to detach from
 * @anyway: detach MTD even if device reference count is not zero
 *
 * This function destroys an UBI device number @ubi_num and detaches the
 * underlying MTD device. Returns zero in case of success and %-EBUSY if the
 * UBI device is busy and cannot be destroyed, and %-EINVAL if it does not
 * exist.
 *
 * Note, the invocations of this function has to be serialized by the
 * @ubi_devices_mutex.
1027
 */
1028
int ubi_detach_mtd_dev(int ubi_num, int anyway)
1029
{
1030 1031 1032 1033 1034
	struct ubi_device *ubi;

	if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES)
		return -EINVAL;

Dmitry Pervushin's avatar
Dmitry Pervushin committed
1035 1036
	ubi = ubi_get_device(ubi_num);
	if (!ubi)
1037 1038
		return -EINVAL;

Dmitry Pervushin's avatar
Dmitry Pervushin committed
1039 1040 1041
	spin_lock(&ubi_devices_lock);
	put_device(&ubi->dev);
	ubi->ref_count -= 1;
1042 1043
	if (ubi->ref_count) {
		if (!anyway) {
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1044
			spin_unlock(&ubi_devices_lock);
1045 1046 1047 1048 1049 1050
			return -EBUSY;
		}
		/* This may only happen if there is a bug */
		ubi_err("%s reference count %d, destroy anyway",
			ubi->ubi_name, ubi->ref_count);
	}
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1051
	ubi_devices[ubi_num] = NULL;
1052 1053
	spin_unlock(&ubi_devices_lock);

Artem Bityutskiy's avatar
Artem Bityutskiy committed
1054
	ubi_assert(ubi_num == ubi->ubi_num);
Dmitry Pervushin's avatar
Dmitry Pervushin committed
1055
	ubi_notify_all(ubi, UBI_VOLUME_REMOVED, NULL);
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1056
	dbg_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num);
1057 1058 1059 1060 1061 1062 1063

	/*
	 * Before freeing anything, we have to stop the background thread to
	 * prevent it from doing anything on this device while we are freeing.
	 */
	if (ubi->bgt_thread)
		kthread_stop(ubi->bgt_thread);
1064

1065 1066
	/*
	 * Get a reference to the device in order to prevent 'dev_release()'
1067
	 * from freeing the @ubi object.
1068 1069 1070
	 */
	get_device(&ubi->dev);

1071
	ubi_debugfs_exit_dev(ubi);
1072 1073
	uif_close(ubi);
	ubi_wl_close(ubi);
1074
	ubi_free_internal_volumes(ubi);
1075
	vfree(ubi->vtbl);
1076
	put_mtd_device(ubi->mtd);
1077
	ubi_debugging_exit_dev(ubi);
1078
	vfree(ubi->peb_buf);
1079
	ubi_msg("mtd%d is detached from ubi%d", ubi->mtd->index, ubi->ubi_num);
1080
	put_device(&ubi->dev);
1081
	return 0;
1082 1083
}

1084
/**
1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
 * open_mtd_by_chdev - open an MTD device by its character device node path.
 * @mtd_dev: MTD character device node path
 *
 * This helper function opens an MTD device by its character node device path.
 * Returns MTD device description object in case of success and a negative
 * error code in case of failure.
 */
static struct mtd_info * __init open_mtd_by_chdev(const char *mtd_dev)
{
	int err, major, minor, mode;
	struct path path;

	/* Probably this is an MTD character device node path */
	err = kern_path(mtd_dev, LOOKUP_FOLLOW, &path);
	if (err)
		return ERR_PTR(err);

	/* MTD device number is defined by the major / minor numbers */
	major = imajor(path.dentry->d_inode);
	minor = iminor(path.dentry->d_inode);
	mode = path.dentry->d_inode->i_mode;
	path_put(&path);
	if (major != MTD_CHAR_MAJOR || !S_ISCHR(mode))
		return ERR_PTR(-EINVAL);

	if (minor & 1)
		/*
		 * Just do not think the "/dev/mtdrX" devices support is need,
		 * so do not support them to avoid doing extra work.
		 */
		return ERR_PTR(-EINVAL);

	return get_mtd_device(NULL, minor / 2);
}

/**
 * open_mtd_device - open MTD device by name, character device path, or number.
 * @mtd_dev: name, character device node path, or MTD device device number
1123
 *
1124
 * This function tries to open and MTD device described by @mtd_dev string,
1125 1126 1127 1128
 * which is first treated as ASCII MTD device number, and if it is not true, it
 * is treated as MTD device name, and if that is also not true, it is treated
 * as MTD character device node path. Returns MTD device description object in
 * case of success and a negative error code in case of failure.
1129 1130 1131 1132
 */
static struct mtd_info * __init open_mtd_device(const char *mtd_dev)
{
	struct mtd_info *mtd;
1133 1134
	int mtd_num;
	char *endp;
1135

1136 1137
	mtd_num = simple_strtoul(mtd_dev, &endp, 0);
	if (*endp != '\0' || mtd_dev == endp) {
1138
		/*
1139 1140
		 * This does not look like an ASCII integer, probably this is
		 * MTD device name.
1141
		 */
1142
		mtd = get_mtd_device_nm(mtd_dev);
1143 1144 1145
		if (IS_ERR(mtd) && PTR_ERR(mtd) == -ENODEV)
			/* Probably this is an MTD character device node path */
			mtd = open_mtd_by_chdev(mtd_dev);
1146
	} else
1147 1148 1149 1150 1151
		mtd = get_mtd_device(NULL, mtd_num);

	return mtd;
}

1152 1153 1154 1155 1156 1157 1158 1159 1160
static int __init ubi_init(void)
{
	int err, i, k;

	/* Ensure that EC and VID headers have correct size */
	BUILD_BUG_ON(sizeof(struct ubi_ec_hdr) != 64);
	BUILD_BUG_ON(sizeof(struct ubi_vid_hdr) != 64);

	if (mtd_devs > UBI_MAX_DEVICES) {
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1161
		ubi_err("too many MTD devices, maximum is %d", UBI_MAX_DEVICES);
1162 1163 1164
		return -EINVAL;
	}

1165
	/* Create base sysfs directory and sysfs files */
1166
	ubi_class = class_create(THIS_MODULE, UBI_NAME_STR);
1167 1168
	if (IS_ERR(ubi_class)) {
		err = PTR_ERR(ubi_class);
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1169
		ubi_err("cannot create UBI class");
1170 1171
		goto out;
	}
1172 1173

	err = class_create_file(ubi_class, &ubi_version);
1174
	if (err) {
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1175
		ubi_err("cannot create sysfs file");
1176
		goto out_class;
1177 1178 1179 1180
	}

	err = misc_register(&ubi_ctrl_cdev);
	if (err) {
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1181
		ubi_err("cannot register device");
1182 1183
		goto out_version;
	}
1184

1185
	ubi_wl_entry_slab = kmem_cache_create("ubi_wl_entry_slab",
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1186 1187
					      sizeof(struct ubi_wl_entry),
					      0, 0, NULL);
1188
	if (!ubi_wl_entry_slab)
1189
		goto out_dev_unreg;
1190

1191 1192 1193 1194 1195
	err = ubi_debugfs_init();
	if (err)
		goto out_slab;


1196 1197 1198
	/* Attach MTD devices */
	for (i = 0; i < mtd_devs; i++) {
		struct mtd_dev_param *p = &mtd_dev_param[i];
1199
		struct mtd_info *mtd;
1200 1201

		cond_resched();
1202 1203 1204 1205 1206 1207 1208 1209

		mtd = open_mtd_device(p->name);
		if (IS_ERR(mtd)) {
			err = PTR_ERR(mtd);
			goto out_detach;
		}

		mutex_lock(&ubi_devices_mutex);
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1210 1211
		err = ubi_attach_mtd_dev(mtd, UBI_DEV_NUM_AUTO,
					 p->vid_hdr_offs);
1212 1213
		mutex_unlock(&ubi_devices_mutex);
		if (err < 0) {
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1214
			ubi_err("cannot attach mtd%d", mtd->index);
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
			put_mtd_device(mtd);

			/*
			 * Originally UBI stopped initializing on any error.
			 * However, later on it was found out that this
			 * behavior is not very good when UBI is compiled into
			 * the kernel and the MTD devices to attach are passed
			 * through the command line. Indeed, UBI failure
			 * stopped whole boot sequence.
			 *
			 * To fix this, we changed the behavior for the
			 * non-module case, but preserved the old behavior for
			 * the module case, just for compatibility. This is a
			 * little inconsistent, though.
			 */
			if (ubi_is_module())
				goto out_detach;
1232
		}
1233 1234 1235 1236 1237 1238
	}

	return 0;

out_detach:
	for (k = 0; k < i; k++)
1239 1240 1241 1242 1243
		if (ubi_devices[k]) {
			mutex_lock(&ubi_devices_mutex);
			ubi_detach_mtd_dev(ubi_devices[k]->ubi_num, 1);
			mutex_unlock(&ubi_devices_mutex);
		}
1244 1245
	ubi_debugfs_exit();
out_slab:
1246
	kmem_cache_destroy(ubi_wl_entry_slab);
1247 1248
out_dev_unreg:
	misc_deregister(&ubi_ctrl_cdev);
1249
out_version:
1250 1251 1252
	class_remove_file(ubi_class, &ubi_version);
out_class:
	class_destroy(ubi_class);
1253
out:
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1254
	ubi_err("UBI error: cannot initialize UBI, error %d", err);
1255 1256 1257 1258 1259 1260
	return err;
}
module_init(ubi_init);

static void __exit ubi_exit(void)
{
1261
	int i;
1262

1263
	for (i = 0; i < UBI_MAX_DEVICES; i++)
1264 1265 1266 1267 1268
		if (ubi_devices[i]) {
			mutex_lock(&ubi_devices_mutex);
			ubi_detach_mtd_dev(ubi_devices[i]->ubi_num, 1);
			mutex_unlock(&ubi_devices_mutex);
		}
1269
	ubi_debugfs_exit();
1270
	kmem_cache_destroy(ubi_wl_entry_slab);
1271
	misc_deregister(&ubi_ctrl_cdev);
1272 1273 1274 1275 1276 1277
	class_remove_file(ubi_class, &ubi_version);
	class_destroy(ubi_class);
}
module_exit(ubi_exit);

/**
1278
 * bytes_str_to_int - convert a number of bytes string into an integer.
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
 * @str: the string to convert
 *
 * This function returns positive resulting integer in case of success and a
 * negative error code in case of failure.
 */
static int __init bytes_str_to_int(const char *str)
{
	char *endp;
	unsigned long result;

	result = simple_strtoul(str, &endp, 0);
Roel Kluin's avatar
Roel Kluin committed
1290
	if (str == endp || result >= INT_MAX) {
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1291 1292
		printk(KERN_ERR "UBI error: incorrect bytes count: \"%s\"\n",
		       str);
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302
		return -EINVAL;
	}

	switch (*endp) {
	case 'G':
		result *= 1024;
	case 'M':
		result *= 1024;
	case 'K':
		result *= 1024;
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1303
		if (endp[1] == 'i' && endp[2] == 'B')
1304 1305 1306 1307
			endp += 2;
	case '\0':
		break;
	default:
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1308 1309
		printk(KERN_ERR "UBI error: incorrect bytes count: \"%s\"\n",
		       str);
1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
		return -EINVAL;
	}

	return result;
}

/**
 * ubi_mtd_param_parse - parse the 'mtd=' UBI parameter.
 * @val: the parameter value to parse
 * @kp: not used
 *
 * This function returns zero in case of success and a negative error code in
 * case of error.
 */
static int __init ubi_mtd_param_parse(const char *val, struct kernel_param *kp)
{
	int i, len;
	struct mtd_dev_param *p;
	char buf[MTD_PARAM_LEN_MAX];
	char *pbuf = &buf[0];
1330
	char *tokens[MTD_PARAM_MAX_COUNT];
1331

1332 1333 1334
	if (!val)
		return -EINVAL;

1335
	if (mtd_devs == UBI_MAX_DEVICES) {
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1336
		printk(KERN_ERR "UBI error: too many parameters, max. is %d\n",
1337 1338 1339 1340 1341 1342
		       UBI_MAX_DEVICES);
		return -EINVAL;
	}

	len = strnlen(val, MTD_PARAM_LEN_MAX);
	if (len == MTD_PARAM_LEN_MAX) {
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1343 1344
		printk(KERN_ERR "UBI error: parameter \"%s\" is too long, "
		       "max. is %d\n", val, MTD_PARAM_LEN_MAX);
1345 1346 1347 1348
		return -EINVAL;
	}

	if (len == 0) {
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1349 1350
		printk(KERN_WARNING "UBI warning: empty 'mtd=' parameter - "
		       "ignored\n");
1351 1352 1353 1354 1355 1356 1357
		return 0;
	}

	strcpy(buf, val);

	/* Get rid of the final newline */
	if (buf[len - 1] == '\n')
1358
		buf[len - 1] = '\0';
1359

1360
	for (i = 0; i < MTD_PARAM_MAX_COUNT; i++)
1361 1362 1363
		tokens[i] = strsep(&pbuf, ",");

	if (pbuf) {
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1364 1365
		printk(KERN_ERR "UBI error: too many arguments at \"%s\"\n",
		       val);
1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383
		return -EINVAL;
	}

	p = &mtd_dev_param[mtd_devs];
	strcpy(&p->name[0], tokens[0]);

	if (tokens[1])
		p->vid_hdr_offs = bytes_str_to_int(tokens[1]);

	if (p->vid_hdr_offs < 0)
		return p->vid_hdr_offs;

	mtd_devs += 1;
	return 0;
}

module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 000);
MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: "
1384
		      "mtd=<name|num|path>[,<vid_hdr_offs>].\n"
1385
		      "Multiple \"mtd\" parameters may be specified.\n"
1386 1387
		      "MTD devices may be specified by their number, name, or "
		      "path to the MTD character device node.\n"
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1388
		      "Optional \"vid_hdr_offs\" parameter specifies UBI VID "
1389 1390 1391 1392
		      "header position to be used by UBI.\n"
		      "Example 1: mtd=/dev/mtd0 - attach MTD device "
		      "/dev/mtd0.\n"
		      "Example 2: mtd=content,1984 mtd=4 - attach MTD device "
Artem Bityutskiy's avatar
Artem Bityutskiy committed
1393 1394
		      "with name \"content\" using VID header offset 1984, and "
		      "MTD device number 4 with default VID header offset.");
1395 1396 1397 1398 1399

MODULE_VERSION(__stringify(UBI_VERSION));
MODULE_DESCRIPTION("UBI - Unsorted Block Images");
MODULE_AUTHOR("Artem Bityutskiy");
MODULE_LICENSE("GPL");