xref: /openbmc/linux/drivers/mtd/ubi/vmt.c (revision a36954f5)
1 /*
2  * Copyright (c) International Business Machines Corp., 2006
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation;  either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12  * the GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Artem Bityutskiy (Битюцкий Артём)
19  */
20 
21 /*
22  * This file contains implementation of volume creation, deletion, updating and
23  * resizing.
24  */
25 
26 #include <linux/err.h>
27 #include <linux/math64.h>
28 #include <linux/slab.h>
29 #include <linux/export.h>
30 #include "ubi.h"
31 
32 static int self_check_volumes(struct ubi_device *ubi);
33 
34 static ssize_t vol_attribute_show(struct device *dev,
35 				  struct device_attribute *attr, char *buf);
36 
37 /* Device attributes corresponding to files in '/<sysfs>/class/ubi/ubiX_Y' */
38 static struct device_attribute attr_vol_reserved_ebs =
39 	__ATTR(reserved_ebs, S_IRUGO, vol_attribute_show, NULL);
40 static struct device_attribute attr_vol_type =
41 	__ATTR(type, S_IRUGO, vol_attribute_show, NULL);
42 static struct device_attribute attr_vol_name =
43 	__ATTR(name, S_IRUGO, vol_attribute_show, NULL);
44 static struct device_attribute attr_vol_corrupted =
45 	__ATTR(corrupted, S_IRUGO, vol_attribute_show, NULL);
46 static struct device_attribute attr_vol_alignment =
47 	__ATTR(alignment, S_IRUGO, vol_attribute_show, NULL);
48 static struct device_attribute attr_vol_usable_eb_size =
49 	__ATTR(usable_eb_size, S_IRUGO, vol_attribute_show, NULL);
50 static struct device_attribute attr_vol_data_bytes =
51 	__ATTR(data_bytes, S_IRUGO, vol_attribute_show, NULL);
52 static struct device_attribute attr_vol_upd_marker =
53 	__ATTR(upd_marker, S_IRUGO, vol_attribute_show, NULL);
54 
55 /*
56  * "Show" method for files in '/<sysfs>/class/ubi/ubiX_Y/'.
57  *
58  * Consider a situation:
59  * A. process 1 opens a sysfs file related to volume Y, say
60  *    /<sysfs>/class/ubi/ubiX_Y/reserved_ebs;
61  * B. process 2 removes volume Y;
62  * C. process 1 starts reading the /<sysfs>/class/ubi/ubiX_Y/reserved_ebs file;
63  *
64  * In this situation, this function will return %-ENODEV because it will find
65  * out that the volume was removed from the @ubi->volumes array.
66  */
67 static ssize_t vol_attribute_show(struct device *dev,
68 				  struct device_attribute *attr, char *buf)
69 {
70 	int ret;
71 	struct ubi_volume *vol = container_of(dev, struct ubi_volume, dev);
72 	struct ubi_device *ubi;
73 
74 	ubi = ubi_get_device(vol->ubi->ubi_num);
75 	if (!ubi)
76 		return -ENODEV;
77 
78 	spin_lock(&ubi->volumes_lock);
79 	if (!ubi->volumes[vol->vol_id]) {
80 		spin_unlock(&ubi->volumes_lock);
81 		ubi_put_device(ubi);
82 		return -ENODEV;
83 	}
84 	/* Take a reference to prevent volume removal */
85 	vol->ref_count += 1;
86 	spin_unlock(&ubi->volumes_lock);
87 
88 	if (attr == &attr_vol_reserved_ebs)
89 		ret = sprintf(buf, "%d\n", vol->reserved_pebs);
90 	else if (attr == &attr_vol_type) {
91 		const char *tp;
92 
93 		if (vol->vol_type == UBI_DYNAMIC_VOLUME)
94 			tp = "dynamic";
95 		else
96 			tp = "static";
97 		ret = sprintf(buf, "%s\n", tp);
98 	} else if (attr == &attr_vol_name)
99 		ret = sprintf(buf, "%s\n", vol->name);
100 	else if (attr == &attr_vol_corrupted)
101 		ret = sprintf(buf, "%d\n", vol->corrupted);
102 	else if (attr == &attr_vol_alignment)
103 		ret = sprintf(buf, "%d\n", vol->alignment);
104 	else if (attr == &attr_vol_usable_eb_size)
105 		ret = sprintf(buf, "%d\n", vol->usable_leb_size);
106 	else if (attr == &attr_vol_data_bytes)
107 		ret = sprintf(buf, "%lld\n", vol->used_bytes);
108 	else if (attr == &attr_vol_upd_marker)
109 		ret = sprintf(buf, "%d\n", vol->upd_marker);
110 	else
111 		/* This must be a bug */
112 		ret = -EINVAL;
113 
114 	/* We've done the operation, drop volume and UBI device references */
115 	spin_lock(&ubi->volumes_lock);
116 	vol->ref_count -= 1;
117 	ubi_assert(vol->ref_count >= 0);
118 	spin_unlock(&ubi->volumes_lock);
119 	ubi_put_device(ubi);
120 	return ret;
121 }
122 
123 static struct attribute *volume_dev_attrs[] = {
124 	&attr_vol_reserved_ebs.attr,
125 	&attr_vol_type.attr,
126 	&attr_vol_name.attr,
127 	&attr_vol_corrupted.attr,
128 	&attr_vol_alignment.attr,
129 	&attr_vol_usable_eb_size.attr,
130 	&attr_vol_data_bytes.attr,
131 	&attr_vol_upd_marker.attr,
132 	NULL
133 };
134 ATTRIBUTE_GROUPS(volume_dev);
135 
136 /* Release method for volume devices */
137 static void vol_release(struct device *dev)
138 {
139 	struct ubi_volume *vol = container_of(dev, struct ubi_volume, dev);
140 
141 	ubi_eba_replace_table(vol, NULL);
142 	kfree(vol);
143 }
144 
145 /**
146  * ubi_create_volume - create volume.
147  * @ubi: UBI device description object
148  * @req: volume creation request
149  *
150  * This function creates volume described by @req. If @req->vol_id id
151  * %UBI_VOL_NUM_AUTO, this function automatically assign ID to the new volume
152  * and saves it in @req->vol_id. Returns zero in case of success and a negative
153  * error code in case of failure. Note, the caller has to have the
154  * @ubi->device_mutex locked.
155  */
156 int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
157 {
158 	int i, err, vol_id = req->vol_id;
159 	struct ubi_volume *vol;
160 	struct ubi_vtbl_record vtbl_rec;
161 	struct ubi_eba_table *eba_tbl = NULL;
162 
163 	if (ubi->ro_mode)
164 		return -EROFS;
165 
166 	vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL);
167 	if (!vol)
168 		return -ENOMEM;
169 
170 	device_initialize(&vol->dev);
171 	vol->dev.release = vol_release;
172 	vol->dev.parent = &ubi->dev;
173 	vol->dev.class = &ubi_class;
174 	vol->dev.groups = volume_dev_groups;
175 
176 	spin_lock(&ubi->volumes_lock);
177 	if (vol_id == UBI_VOL_NUM_AUTO) {
178 		/* Find unused volume ID */
179 		dbg_gen("search for vacant volume ID");
180 		for (i = 0; i < ubi->vtbl_slots; i++)
181 			if (!ubi->volumes[i]) {
182 				vol_id = i;
183 				break;
184 			}
185 
186 		if (vol_id == UBI_VOL_NUM_AUTO) {
187 			ubi_err(ubi, "out of volume IDs");
188 			err = -ENFILE;
189 			goto out_unlock;
190 		}
191 		req->vol_id = vol_id;
192 	}
193 
194 	dbg_gen("create device %d, volume %d, %llu bytes, type %d, name %s",
195 		ubi->ubi_num, vol_id, (unsigned long long)req->bytes,
196 		(int)req->vol_type, req->name);
197 
198 	/* Ensure that this volume does not exist */
199 	err = -EEXIST;
200 	if (ubi->volumes[vol_id]) {
201 		ubi_err(ubi, "volume %d already exists", vol_id);
202 		goto out_unlock;
203 	}
204 
205 	/* Ensure that the name is unique */
206 	for (i = 0; i < ubi->vtbl_slots; i++)
207 		if (ubi->volumes[i] &&
208 		    ubi->volumes[i]->name_len == req->name_len &&
209 		    !strcmp(ubi->volumes[i]->name, req->name)) {
210 			ubi_err(ubi, "volume \"%s\" exists (ID %d)",
211 				req->name, i);
212 			goto out_unlock;
213 		}
214 
215 	/* Calculate how many eraseblocks are requested */
216 	vol->usable_leb_size = ubi->leb_size - ubi->leb_size % req->alignment;
217 	vol->reserved_pebs = div_u64(req->bytes + vol->usable_leb_size - 1,
218 				     vol->usable_leb_size);
219 
220 	/* Reserve physical eraseblocks */
221 	if (vol->reserved_pebs > ubi->avail_pebs) {
222 		ubi_err(ubi, "not enough PEBs, only %d available",
223 			ubi->avail_pebs);
224 		if (ubi->corr_peb_count)
225 			ubi_err(ubi, "%d PEBs are corrupted and not used",
226 				ubi->corr_peb_count);
227 		err = -ENOSPC;
228 		goto out_unlock;
229 	}
230 	ubi->avail_pebs -= vol->reserved_pebs;
231 	ubi->rsvd_pebs += vol->reserved_pebs;
232 	spin_unlock(&ubi->volumes_lock);
233 
234 	vol->vol_id    = vol_id;
235 	vol->alignment = req->alignment;
236 	vol->data_pad  = ubi->leb_size % vol->alignment;
237 	vol->vol_type  = req->vol_type;
238 	vol->name_len  = req->name_len;
239 	memcpy(vol->name, req->name, vol->name_len);
240 	vol->ubi = ubi;
241 
242 	/*
243 	 * Finish all pending erases because there may be some LEBs belonging
244 	 * to the same volume ID.
245 	 */
246 	err = ubi_wl_flush(ubi, vol_id, UBI_ALL);
247 	if (err)
248 		goto out_acc;
249 
250 	eba_tbl = ubi_eba_create_table(vol, vol->reserved_pebs);
251 	if (IS_ERR(eba_tbl)) {
252 		err = PTR_ERR(eba_tbl);
253 		goto out_acc;
254 	}
255 
256 	ubi_eba_replace_table(vol, eba_tbl);
257 
258 	if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
259 		vol->used_ebs = vol->reserved_pebs;
260 		vol->last_eb_bytes = vol->usable_leb_size;
261 		vol->used_bytes =
262 			(long long)vol->used_ebs * vol->usable_leb_size;
263 	} else {
264 		vol->used_ebs = div_u64_rem(vol->used_bytes,
265 					    vol->usable_leb_size,
266 					    &vol->last_eb_bytes);
267 		if (vol->last_eb_bytes != 0)
268 			vol->used_ebs += 1;
269 		else
270 			vol->last_eb_bytes = vol->usable_leb_size;
271 	}
272 
273 	/* Register character device for the volume */
274 	cdev_init(&vol->cdev, &ubi_vol_cdev_operations);
275 	vol->cdev.owner = THIS_MODULE;
276 
277 	vol->dev.devt = MKDEV(MAJOR(ubi->cdev.dev), vol_id + 1);
278 	dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
279 	err = cdev_device_add(&vol->cdev, &vol->dev);
280 	if (err) {
281 		ubi_err(ubi, "cannot add device");
282 		goto out_mapping;
283 	}
284 
285 	/* Fill volume table record */
286 	memset(&vtbl_rec, 0, sizeof(struct ubi_vtbl_record));
287 	vtbl_rec.reserved_pebs = cpu_to_be32(vol->reserved_pebs);
288 	vtbl_rec.alignment     = cpu_to_be32(vol->alignment);
289 	vtbl_rec.data_pad      = cpu_to_be32(vol->data_pad);
290 	vtbl_rec.name_len      = cpu_to_be16(vol->name_len);
291 	if (vol->vol_type == UBI_DYNAMIC_VOLUME)
292 		vtbl_rec.vol_type = UBI_VID_DYNAMIC;
293 	else
294 		vtbl_rec.vol_type = UBI_VID_STATIC;
295 	memcpy(vtbl_rec.name, vol->name, vol->name_len);
296 
297 	err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
298 	if (err)
299 		goto out_sysfs;
300 
301 	spin_lock(&ubi->volumes_lock);
302 	ubi->volumes[vol_id] = vol;
303 	ubi->vol_count += 1;
304 	spin_unlock(&ubi->volumes_lock);
305 
306 	ubi_volume_notify(ubi, vol, UBI_VOLUME_ADDED);
307 	self_check_volumes(ubi);
308 	return err;
309 
310 out_sysfs:
311 	/*
312 	 * We have registered our device, we should not free the volume
313 	 * description object in this function in case of an error - it is
314 	 * freed by the release function.
315 	 */
316 	cdev_device_del(&vol->cdev, &vol->dev);
317 out_mapping:
318 	ubi_eba_destroy_table(eba_tbl);
319 out_acc:
320 	spin_lock(&ubi->volumes_lock);
321 	ubi->rsvd_pebs -= vol->reserved_pebs;
322 	ubi->avail_pebs += vol->reserved_pebs;
323 out_unlock:
324 	spin_unlock(&ubi->volumes_lock);
325 	put_device(&vol->dev);
326 	ubi_err(ubi, "cannot create volume %d, error %d", vol_id, err);
327 	return err;
328 }
329 
330 /**
331  * ubi_remove_volume - remove volume.
332  * @desc: volume descriptor
333  * @no_vtbl: do not change volume table if not zero
334  *
335  * This function removes volume described by @desc. The volume has to be opened
336  * in "exclusive" mode. Returns zero in case of success and a negative error
337  * code in case of failure. The caller has to have the @ubi->device_mutex
338  * locked.
339  */
340 int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl)
341 {
342 	struct ubi_volume *vol = desc->vol;
343 	struct ubi_device *ubi = vol->ubi;
344 	int i, err, vol_id = vol->vol_id, reserved_pebs = vol->reserved_pebs;
345 
346 	dbg_gen("remove device %d, volume %d", ubi->ubi_num, vol_id);
347 	ubi_assert(desc->mode == UBI_EXCLUSIVE);
348 	ubi_assert(vol == ubi->volumes[vol_id]);
349 
350 	if (ubi->ro_mode)
351 		return -EROFS;
352 
353 	spin_lock(&ubi->volumes_lock);
354 	if (vol->ref_count > 1) {
355 		/*
356 		 * The volume is busy, probably someone is reading one of its
357 		 * sysfs files.
358 		 */
359 		err = -EBUSY;
360 		goto out_unlock;
361 	}
362 	ubi->volumes[vol_id] = NULL;
363 	spin_unlock(&ubi->volumes_lock);
364 
365 	if (!no_vtbl) {
366 		err = ubi_change_vtbl_record(ubi, vol_id, NULL);
367 		if (err)
368 			goto out_err;
369 	}
370 
371 	for (i = 0; i < vol->reserved_pebs; i++) {
372 		err = ubi_eba_unmap_leb(ubi, vol, i);
373 		if (err)
374 			goto out_err;
375 	}
376 
377 	cdev_device_del(&vol->cdev, &vol->dev);
378 	put_device(&vol->dev);
379 
380 	spin_lock(&ubi->volumes_lock);
381 	ubi->rsvd_pebs -= reserved_pebs;
382 	ubi->avail_pebs += reserved_pebs;
383 	ubi_update_reserved(ubi);
384 	ubi->vol_count -= 1;
385 	spin_unlock(&ubi->volumes_lock);
386 
387 	ubi_volume_notify(ubi, vol, UBI_VOLUME_REMOVED);
388 	if (!no_vtbl)
389 		self_check_volumes(ubi);
390 
391 	return 0;
392 
393 out_err:
394 	ubi_err(ubi, "cannot remove volume %d, error %d", vol_id, err);
395 	spin_lock(&ubi->volumes_lock);
396 	ubi->volumes[vol_id] = vol;
397 out_unlock:
398 	spin_unlock(&ubi->volumes_lock);
399 	return err;
400 }
401 
402 /**
403  * ubi_resize_volume - re-size volume.
404  * @desc: volume descriptor
405  * @reserved_pebs: new size in physical eraseblocks
406  *
407  * This function re-sizes the volume and returns zero in case of success, and a
408  * negative error code in case of failure. The caller has to have the
409  * @ubi->device_mutex locked.
410  */
411 int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs)
412 {
413 	int i, err, pebs;
414 	struct ubi_volume *vol = desc->vol;
415 	struct ubi_device *ubi = vol->ubi;
416 	struct ubi_vtbl_record vtbl_rec;
417 	struct ubi_eba_table *new_eba_tbl = NULL;
418 	int vol_id = vol->vol_id;
419 
420 	if (ubi->ro_mode)
421 		return -EROFS;
422 
423 	dbg_gen("re-size device %d, volume %d to from %d to %d PEBs",
424 		ubi->ubi_num, vol_id, vol->reserved_pebs, reserved_pebs);
425 
426 	if (vol->vol_type == UBI_STATIC_VOLUME &&
427 	    reserved_pebs < vol->used_ebs) {
428 		ubi_err(ubi, "too small size %d, %d LEBs contain data",
429 			reserved_pebs, vol->used_ebs);
430 		return -EINVAL;
431 	}
432 
433 	/* If the size is the same, we have nothing to do */
434 	if (reserved_pebs == vol->reserved_pebs)
435 		return 0;
436 
437 	new_eba_tbl = ubi_eba_create_table(vol, reserved_pebs);
438 	if (IS_ERR(new_eba_tbl))
439 		return PTR_ERR(new_eba_tbl);
440 
441 	spin_lock(&ubi->volumes_lock);
442 	if (vol->ref_count > 1) {
443 		spin_unlock(&ubi->volumes_lock);
444 		err = -EBUSY;
445 		goto out_free;
446 	}
447 	spin_unlock(&ubi->volumes_lock);
448 
449 	/* Reserve physical eraseblocks */
450 	pebs = reserved_pebs - vol->reserved_pebs;
451 	if (pebs > 0) {
452 		spin_lock(&ubi->volumes_lock);
453 		if (pebs > ubi->avail_pebs) {
454 			ubi_err(ubi, "not enough PEBs: requested %d, available %d",
455 				pebs, ubi->avail_pebs);
456 			if (ubi->corr_peb_count)
457 				ubi_err(ubi, "%d PEBs are corrupted and not used",
458 					ubi->corr_peb_count);
459 			spin_unlock(&ubi->volumes_lock);
460 			err = -ENOSPC;
461 			goto out_free;
462 		}
463 		ubi->avail_pebs -= pebs;
464 		ubi->rsvd_pebs += pebs;
465 		ubi_eba_copy_table(vol, new_eba_tbl, vol->reserved_pebs);
466 		ubi_eba_replace_table(vol, new_eba_tbl);
467 		spin_unlock(&ubi->volumes_lock);
468 	}
469 
470 	if (pebs < 0) {
471 		for (i = 0; i < -pebs; i++) {
472 			err = ubi_eba_unmap_leb(ubi, vol, reserved_pebs + i);
473 			if (err)
474 				goto out_acc;
475 		}
476 		spin_lock(&ubi->volumes_lock);
477 		ubi->rsvd_pebs += pebs;
478 		ubi->avail_pebs -= pebs;
479 		ubi_update_reserved(ubi);
480 		ubi_eba_copy_table(vol, new_eba_tbl, reserved_pebs);
481 		ubi_eba_replace_table(vol, new_eba_tbl);
482 		spin_unlock(&ubi->volumes_lock);
483 	}
484 
485 	/*
486 	 * When we shrink a volume we have to flush all pending (erase) work.
487 	 * Otherwise it can happen that upon next attach UBI finds a LEB with
488 	 * lnum > highest_lnum and refuses to attach.
489 	 */
490 	if (pebs < 0) {
491 		err = ubi_wl_flush(ubi, vol_id, UBI_ALL);
492 		if (err)
493 			goto out_acc;
494 	}
495 
496 	/* Change volume table record */
497 	vtbl_rec = ubi->vtbl[vol_id];
498 	vtbl_rec.reserved_pebs = cpu_to_be32(reserved_pebs);
499 	err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
500 	if (err)
501 		goto out_acc;
502 
503 	vol->reserved_pebs = reserved_pebs;
504 	if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
505 		vol->used_ebs = reserved_pebs;
506 		vol->last_eb_bytes = vol->usable_leb_size;
507 		vol->used_bytes =
508 			(long long)vol->used_ebs * vol->usable_leb_size;
509 	}
510 
511 	ubi_volume_notify(ubi, vol, UBI_VOLUME_RESIZED);
512 	self_check_volumes(ubi);
513 	return err;
514 
515 out_acc:
516 	if (pebs > 0) {
517 		spin_lock(&ubi->volumes_lock);
518 		ubi->rsvd_pebs -= pebs;
519 		ubi->avail_pebs += pebs;
520 		spin_unlock(&ubi->volumes_lock);
521 	}
522 out_free:
523 	kfree(new_eba_tbl);
524 	return err;
525 }
526 
527 /**
528  * ubi_rename_volumes - re-name UBI volumes.
529  * @ubi: UBI device description object
530  * @rename_list: list of &struct ubi_rename_entry objects
531  *
532  * This function re-names or removes volumes specified in the re-name list.
533  * Returns zero in case of success and a negative error code in case of
534  * failure.
535  */
536 int ubi_rename_volumes(struct ubi_device *ubi, struct list_head *rename_list)
537 {
538 	int err;
539 	struct ubi_rename_entry *re;
540 
541 	err = ubi_vtbl_rename_volumes(ubi, rename_list);
542 	if (err)
543 		return err;
544 
545 	list_for_each_entry(re, rename_list, list) {
546 		if (re->remove) {
547 			err = ubi_remove_volume(re->desc, 1);
548 			if (err)
549 				break;
550 		} else {
551 			struct ubi_volume *vol = re->desc->vol;
552 
553 			spin_lock(&ubi->volumes_lock);
554 			vol->name_len = re->new_name_len;
555 			memcpy(vol->name, re->new_name, re->new_name_len + 1);
556 			spin_unlock(&ubi->volumes_lock);
557 			ubi_volume_notify(ubi, vol, UBI_VOLUME_RENAMED);
558 		}
559 	}
560 
561 	if (!err)
562 		self_check_volumes(ubi);
563 	return err;
564 }
565 
566 /**
567  * ubi_add_volume - add volume.
568  * @ubi: UBI device description object
569  * @vol: volume description object
570  *
571  * This function adds an existing volume and initializes all its data
572  * structures. Returns zero in case of success and a negative error code in
573  * case of failure.
574  */
575 int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol)
576 {
577 	int err, vol_id = vol->vol_id;
578 	dev_t dev;
579 
580 	dbg_gen("add volume %d", vol_id);
581 
582 	/* Register character device for the volume */
583 	cdev_init(&vol->cdev, &ubi_vol_cdev_operations);
584 	vol->cdev.owner = THIS_MODULE;
585 	dev = MKDEV(MAJOR(ubi->cdev.dev), vol->vol_id + 1);
586 	err = cdev_add(&vol->cdev, dev, 1);
587 	if (err) {
588 		ubi_err(ubi, "cannot add character device for volume %d, error %d",
589 			vol_id, err);
590 		return err;
591 	}
592 
593 	vol->dev.release = vol_release;
594 	vol->dev.parent = &ubi->dev;
595 	vol->dev.devt = dev;
596 	vol->dev.class = &ubi_class;
597 	vol->dev.groups = volume_dev_groups;
598 	dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
599 	err = device_register(&vol->dev);
600 	if (err)
601 		goto out_cdev;
602 
603 	self_check_volumes(ubi);
604 	return err;
605 
606 out_cdev:
607 	cdev_del(&vol->cdev);
608 	return err;
609 }
610 
611 /**
612  * ubi_free_volume - free volume.
613  * @ubi: UBI device description object
614  * @vol: volume description object
615  *
616  * This function frees all resources for volume @vol but does not remove it.
617  * Used only when the UBI device is detached.
618  */
619 void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol)
620 {
621 	dbg_gen("free volume %d", vol->vol_id);
622 
623 	ubi->volumes[vol->vol_id] = NULL;
624 	cdev_del(&vol->cdev);
625 	device_unregister(&vol->dev);
626 }
627 
628 /**
629  * self_check_volume - check volume information.
630  * @ubi: UBI device description object
631  * @vol_id: volume ID
632  *
633  * Returns zero if volume is all right and a a negative error code if not.
634  */
635 static int self_check_volume(struct ubi_device *ubi, int vol_id)
636 {
637 	int idx = vol_id2idx(ubi, vol_id);
638 	int reserved_pebs, alignment, data_pad, vol_type, name_len, upd_marker;
639 	const struct ubi_volume *vol;
640 	long long n;
641 	const char *name;
642 
643 	spin_lock(&ubi->volumes_lock);
644 	reserved_pebs = be32_to_cpu(ubi->vtbl[vol_id].reserved_pebs);
645 	vol = ubi->volumes[idx];
646 
647 	if (!vol) {
648 		if (reserved_pebs) {
649 			ubi_err(ubi, "no volume info, but volume exists");
650 			goto fail;
651 		}
652 		spin_unlock(&ubi->volumes_lock);
653 		return 0;
654 	}
655 
656 	if (vol->reserved_pebs < 0 || vol->alignment < 0 || vol->data_pad < 0 ||
657 	    vol->name_len < 0) {
658 		ubi_err(ubi, "negative values");
659 		goto fail;
660 	}
661 	if (vol->alignment > ubi->leb_size || vol->alignment == 0) {
662 		ubi_err(ubi, "bad alignment");
663 		goto fail;
664 	}
665 
666 	n = vol->alignment & (ubi->min_io_size - 1);
667 	if (vol->alignment != 1 && n) {
668 		ubi_err(ubi, "alignment is not multiple of min I/O unit");
669 		goto fail;
670 	}
671 
672 	n = ubi->leb_size % vol->alignment;
673 	if (vol->data_pad != n) {
674 		ubi_err(ubi, "bad data_pad, has to be %lld", n);
675 		goto fail;
676 	}
677 
678 	if (vol->vol_type != UBI_DYNAMIC_VOLUME &&
679 	    vol->vol_type != UBI_STATIC_VOLUME) {
680 		ubi_err(ubi, "bad vol_type");
681 		goto fail;
682 	}
683 
684 	if (vol->upd_marker && vol->corrupted) {
685 		ubi_err(ubi, "update marker and corrupted simultaneously");
686 		goto fail;
687 	}
688 
689 	if (vol->reserved_pebs > ubi->good_peb_count) {
690 		ubi_err(ubi, "too large reserved_pebs");
691 		goto fail;
692 	}
693 
694 	n = ubi->leb_size - vol->data_pad;
695 	if (vol->usable_leb_size != ubi->leb_size - vol->data_pad) {
696 		ubi_err(ubi, "bad usable_leb_size, has to be %lld", n);
697 		goto fail;
698 	}
699 
700 	if (vol->name_len > UBI_VOL_NAME_MAX) {
701 		ubi_err(ubi, "too long volume name, max is %d",
702 			UBI_VOL_NAME_MAX);
703 		goto fail;
704 	}
705 
706 	n = strnlen(vol->name, vol->name_len + 1);
707 	if (n != vol->name_len) {
708 		ubi_err(ubi, "bad name_len %lld", n);
709 		goto fail;
710 	}
711 
712 	n = (long long)vol->used_ebs * vol->usable_leb_size;
713 	if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
714 		if (vol->corrupted) {
715 			ubi_err(ubi, "corrupted dynamic volume");
716 			goto fail;
717 		}
718 		if (vol->used_ebs != vol->reserved_pebs) {
719 			ubi_err(ubi, "bad used_ebs");
720 			goto fail;
721 		}
722 		if (vol->last_eb_bytes != vol->usable_leb_size) {
723 			ubi_err(ubi, "bad last_eb_bytes");
724 			goto fail;
725 		}
726 		if (vol->used_bytes != n) {
727 			ubi_err(ubi, "bad used_bytes");
728 			goto fail;
729 		}
730 	} else {
731 		if (vol->used_ebs < 0 || vol->used_ebs > vol->reserved_pebs) {
732 			ubi_err(ubi, "bad used_ebs");
733 			goto fail;
734 		}
735 		if (vol->last_eb_bytes < 0 ||
736 		    vol->last_eb_bytes > vol->usable_leb_size) {
737 			ubi_err(ubi, "bad last_eb_bytes");
738 			goto fail;
739 		}
740 		if (vol->used_bytes < 0 || vol->used_bytes > n ||
741 		    vol->used_bytes < n - vol->usable_leb_size) {
742 			ubi_err(ubi, "bad used_bytes");
743 			goto fail;
744 		}
745 	}
746 
747 	alignment  = be32_to_cpu(ubi->vtbl[vol_id].alignment);
748 	data_pad   = be32_to_cpu(ubi->vtbl[vol_id].data_pad);
749 	name_len   = be16_to_cpu(ubi->vtbl[vol_id].name_len);
750 	upd_marker = ubi->vtbl[vol_id].upd_marker;
751 	name       = &ubi->vtbl[vol_id].name[0];
752 	if (ubi->vtbl[vol_id].vol_type == UBI_VID_DYNAMIC)
753 		vol_type = UBI_DYNAMIC_VOLUME;
754 	else
755 		vol_type = UBI_STATIC_VOLUME;
756 
757 	if (alignment != vol->alignment || data_pad != vol->data_pad ||
758 	    upd_marker != vol->upd_marker || vol_type != vol->vol_type ||
759 	    name_len != vol->name_len || strncmp(name, vol->name, name_len)) {
760 		ubi_err(ubi, "volume info is different");
761 		goto fail;
762 	}
763 
764 	spin_unlock(&ubi->volumes_lock);
765 	return 0;
766 
767 fail:
768 	ubi_err(ubi, "self-check failed for volume %d", vol_id);
769 	if (vol)
770 		ubi_dump_vol_info(vol);
771 	ubi_dump_vtbl_record(&ubi->vtbl[vol_id], vol_id);
772 	dump_stack();
773 	spin_unlock(&ubi->volumes_lock);
774 	return -EINVAL;
775 }
776 
777 /**
778  * self_check_volumes - check information about all volumes.
779  * @ubi: UBI device description object
780  *
781  * Returns zero if volumes are all right and a a negative error code if not.
782  */
783 static int self_check_volumes(struct ubi_device *ubi)
784 {
785 	int i, err = 0;
786 
787 	if (!ubi_dbg_chk_gen(ubi))
788 		return 0;
789 
790 	for (i = 0; i < ubi->vtbl_slots; i++) {
791 		err = self_check_volume(ubi, i);
792 		if (err)
793 			break;
794 	}
795 
796 	return err;
797 }
798