2 * Copyright (c) International Business Machines Corp., 2006
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.
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.
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
18 * Author: Artem Bityutskiy (Битюцкий Артём)
22 * This file contains implementation of volume creation, deletion, updating and
26 #include <linux/err.h>
27 #include <linux/math64.h>
28 #include <linux/slab.h>
29 #include <linux/export.h>
32 static int self_check_volumes(struct ubi_device
*ubi
);
34 static ssize_t
vol_attribute_show(struct device
*dev
,
35 struct device_attribute
*attr
, char *buf
);
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
);
56 * "Show" method for files in '/<sysfs>/class/ubi/ubiX_Y/'.
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;
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.
67 static ssize_t
vol_attribute_show(struct device
*dev
,
68 struct device_attribute
*attr
, char *buf
)
71 struct ubi_volume
*vol
= container_of(dev
, struct ubi_volume
, dev
);
72 struct ubi_device
*ubi
;
74 ubi
= ubi_get_device(vol
->ubi
->ubi_num
);
78 spin_lock(&ubi
->volumes_lock
);
79 if (!ubi
->volumes
[vol
->vol_id
]) {
80 spin_unlock(&ubi
->volumes_lock
);
84 /* Take a reference to prevent volume removal */
86 spin_unlock(&ubi
->volumes_lock
);
88 if (attr
== &attr_vol_reserved_ebs
)
89 ret
= sprintf(buf
, "%d\n", vol
->reserved_pebs
);
90 else if (attr
== &attr_vol_type
) {
93 if (vol
->vol_type
== UBI_DYNAMIC_VOLUME
)
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
);
111 /* This must be a bug */
114 /* We've done the operation, drop volume and UBI device references */
115 spin_lock(&ubi
->volumes_lock
);
117 ubi_assert(vol
->ref_count
>= 0);
118 spin_unlock(&ubi
->volumes_lock
);
123 static struct attribute
*volume_dev_attrs
[] = {
124 &attr_vol_reserved_ebs
.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
,
134 ATTRIBUTE_GROUPS(volume_dev
);
136 /* Release method for volume devices */
137 static void vol_release(struct device
*dev
)
139 struct ubi_volume
*vol
= container_of(dev
, struct ubi_volume
, dev
);
141 ubi_eba_replace_table(vol
, NULL
);
146 * ubi_create_volume - create volume.
147 * @ubi: UBI device description object
148 * @req: volume creation request
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.
156 int ubi_create_volume(struct ubi_device
*ubi
, struct ubi_mkvol_req
*req
)
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
;
166 vol
= kzalloc(sizeof(struct ubi_volume
), GFP_KERNEL
);
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
;
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
]) {
186 if (vol_id
== UBI_VOL_NUM_AUTO
) {
187 ubi_err(ubi
, "out of volume IDs");
191 req
->vol_id
= vol_id
;
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
);
198 /* Ensure that this volume does not exist */
200 if (ubi
->volumes
[vol_id
]) {
201 ubi_err(ubi
, "volume %d already exists", vol_id
);
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)",
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
);
220 /* Reserve physical eraseblocks */
221 if (vol
->reserved_pebs
> ubi
->avail_pebs
) {
222 ubi_err(ubi
, "not enough PEBs, only %d available",
224 if (ubi
->corr_peb_count
)
225 ubi_err(ubi
, "%d PEBs are corrupted and not used",
226 ubi
->corr_peb_count
);
230 ubi
->avail_pebs
-= vol
->reserved_pebs
;
231 ubi
->rsvd_pebs
+= vol
->reserved_pebs
;
232 spin_unlock(&ubi
->volumes_lock
);
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
);
243 * Finish all pending erases because there may be some LEBs belonging
244 * to the same volume ID.
246 err
= ubi_wl_flush(ubi
, vol_id
, UBI_ALL
);
250 eba_tbl
= ubi_eba_create_table(vol
, vol
->reserved_pebs
);
251 if (IS_ERR(eba_tbl
)) {
252 err
= PTR_ERR(eba_tbl
);
256 ubi_eba_replace_table(vol
, eba_tbl
);
258 if (vol
->vol_type
== UBI_DYNAMIC_VOLUME
) {
259 vol
->used_ebs
= vol
->reserved_pebs
;
260 vol
->last_eb_bytes
= vol
->usable_leb_size
;
262 (long long)vol
->used_ebs
* vol
->usable_leb_size
;
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)
270 vol
->last_eb_bytes
= vol
->usable_leb_size
;
273 /* Register character device for the volume */
274 cdev_init(&vol
->cdev
, &ubi_vol_cdev_operations
);
275 vol
->cdev
.owner
= THIS_MODULE
;
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
);
281 ubi_err(ubi
, "cannot add device");
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
;
294 vtbl_rec
.vol_type
= UBI_VID_STATIC
;
295 memcpy(vtbl_rec
.name
, vol
->name
, vol
->name_len
);
297 err
= ubi_change_vtbl_record(ubi
, vol_id
, &vtbl_rec
);
301 spin_lock(&ubi
->volumes_lock
);
302 ubi
->volumes
[vol_id
] = vol
;
304 spin_unlock(&ubi
->volumes_lock
);
306 ubi_volume_notify(ubi
, vol
, UBI_VOLUME_ADDED
);
307 self_check_volumes(ubi
);
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.
316 cdev_device_del(&vol
->cdev
, &vol
->dev
);
318 ubi_eba_destroy_table(eba_tbl
);
320 spin_lock(&ubi
->volumes_lock
);
321 ubi
->rsvd_pebs
-= vol
->reserved_pebs
;
322 ubi
->avail_pebs
+= vol
->reserved_pebs
;
324 spin_unlock(&ubi
->volumes_lock
);
325 put_device(&vol
->dev
);
326 ubi_err(ubi
, "cannot create volume %d, error %d", vol_id
, err
);
331 * ubi_remove_volume - remove volume.
332 * @desc: volume descriptor
333 * @no_vtbl: do not change volume table if not zero
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
340 int ubi_remove_volume(struct ubi_volume_desc
*desc
, int no_vtbl
)
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
;
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
]);
353 spin_lock(&ubi
->volumes_lock
);
354 if (vol
->ref_count
> 1) {
356 * The volume is busy, probably someone is reading one of its
362 ubi
->volumes
[vol_id
] = NULL
;
363 spin_unlock(&ubi
->volumes_lock
);
366 err
= ubi_change_vtbl_record(ubi
, vol_id
, NULL
);
371 for (i
= 0; i
< vol
->reserved_pebs
; i
++) {
372 err
= ubi_eba_unmap_leb(ubi
, vol
, i
);
377 cdev_device_del(&vol
->cdev
, &vol
->dev
);
378 put_device(&vol
->dev
);
380 spin_lock(&ubi
->volumes_lock
);
381 ubi
->rsvd_pebs
-= reserved_pebs
;
382 ubi
->avail_pebs
+= reserved_pebs
;
383 ubi_update_reserved(ubi
);
385 spin_unlock(&ubi
->volumes_lock
);
387 ubi_volume_notify(ubi
, vol
, UBI_VOLUME_REMOVED
);
389 self_check_volumes(ubi
);
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
;
398 spin_unlock(&ubi
->volumes_lock
);
403 * ubi_resize_volume - re-size volume.
404 * @desc: volume descriptor
405 * @reserved_pebs: new size in physical eraseblocks
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.
411 int ubi_resize_volume(struct ubi_volume_desc
*desc
, int reserved_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
;
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
);
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
);
433 /* If the size is the same, we have nothing to do */
434 if (reserved_pebs
== vol
->reserved_pebs
)
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
);
441 spin_lock(&ubi
->volumes_lock
);
442 if (vol
->ref_count
> 1) {
443 spin_unlock(&ubi
->volumes_lock
);
447 spin_unlock(&ubi
->volumes_lock
);
449 /* Reserve physical eraseblocks */
450 pebs
= reserved_pebs
- vol
->reserved_pebs
;
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
);
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
);
471 for (i
= 0; i
< -pebs
; i
++) {
472 err
= ubi_eba_unmap_leb(ubi
, vol
, reserved_pebs
+ i
);
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
);
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.
491 err
= ubi_wl_flush(ubi
, vol_id
, UBI_ALL
);
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
);
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
;
508 (long long)vol
->used_ebs
* vol
->usable_leb_size
;
511 ubi_volume_notify(ubi
, vol
, UBI_VOLUME_RESIZED
);
512 self_check_volumes(ubi
);
517 spin_lock(&ubi
->volumes_lock
);
518 ubi
->rsvd_pebs
-= pebs
;
519 ubi
->avail_pebs
+= pebs
;
520 spin_unlock(&ubi
->volumes_lock
);
528 * ubi_rename_volumes - re-name UBI volumes.
529 * @ubi: UBI device description object
530 * @rename_list: list of &struct ubi_rename_entry objects
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
536 int ubi_rename_volumes(struct ubi_device
*ubi
, struct list_head
*rename_list
)
539 struct ubi_rename_entry
*re
;
541 err
= ubi_vtbl_rename_volumes(ubi
, rename_list
);
545 list_for_each_entry(re
, rename_list
, list
) {
547 err
= ubi_remove_volume(re
->desc
, 1);
551 struct ubi_volume
*vol
= re
->desc
->vol
;
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
);
562 self_check_volumes(ubi
);
567 * ubi_add_volume - add volume.
568 * @ubi: UBI device description object
569 * @vol: volume description object
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
575 int ubi_add_volume(struct ubi_device
*ubi
, struct ubi_volume
*vol
)
577 int err
, vol_id
= vol
->vol_id
;
580 dbg_gen("add volume %d", vol_id
);
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);
588 ubi_err(ubi
, "cannot add character device for volume %d, error %d",
593 vol
->dev
.release
= vol_release
;
594 vol
->dev
.parent
= &ubi
->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
);
603 self_check_volumes(ubi
);
607 cdev_del(&vol
->cdev
);
612 * ubi_free_volume - free volume.
613 * @ubi: UBI device description object
614 * @vol: volume description object
616 * This function frees all resources for volume @vol but does not remove it.
617 * Used only when the UBI device is detached.
619 void ubi_free_volume(struct ubi_device
*ubi
, struct ubi_volume
*vol
)
621 dbg_gen("free volume %d", vol
->vol_id
);
623 ubi
->volumes
[vol
->vol_id
] = NULL
;
624 cdev_del(&vol
->cdev
);
625 device_unregister(&vol
->dev
);
629 * self_check_volume - check volume information.
630 * @ubi: UBI device description object
633 * Returns zero if volume is all right and a a negative error code if not.
635 static int self_check_volume(struct ubi_device
*ubi
, int vol_id
)
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
;
643 spin_lock(&ubi
->volumes_lock
);
644 reserved_pebs
= be32_to_cpu(ubi
->vtbl
[vol_id
].reserved_pebs
);
645 vol
= ubi
->volumes
[idx
];
649 ubi_err(ubi
, "no volume info, but volume exists");
652 spin_unlock(&ubi
->volumes_lock
);
656 if (vol
->reserved_pebs
< 0 || vol
->alignment
< 0 || vol
->data_pad
< 0 ||
658 ubi_err(ubi
, "negative values");
661 if (vol
->alignment
> ubi
->leb_size
|| vol
->alignment
== 0) {
662 ubi_err(ubi
, "bad alignment");
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");
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
);
678 if (vol
->vol_type
!= UBI_DYNAMIC_VOLUME
&&
679 vol
->vol_type
!= UBI_STATIC_VOLUME
) {
680 ubi_err(ubi
, "bad vol_type");
684 if (vol
->upd_marker
&& vol
->corrupted
) {
685 ubi_err(ubi
, "update marker and corrupted simultaneously");
689 if (vol
->reserved_pebs
> ubi
->good_peb_count
) {
690 ubi_err(ubi
, "too large reserved_pebs");
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
);
700 if (vol
->name_len
> UBI_VOL_NAME_MAX
) {
701 ubi_err(ubi
, "too long volume name, max is %d",
706 n
= strnlen(vol
->name
, vol
->name_len
+ 1);
707 if (n
!= vol
->name_len
) {
708 ubi_err(ubi
, "bad name_len %lld", n
);
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");
718 if (vol
->used_ebs
!= vol
->reserved_pebs
) {
719 ubi_err(ubi
, "bad used_ebs");
722 if (vol
->last_eb_bytes
!= vol
->usable_leb_size
) {
723 ubi_err(ubi
, "bad last_eb_bytes");
726 if (vol
->used_bytes
!= n
) {
727 ubi_err(ubi
, "bad used_bytes");
731 if (vol
->used_ebs
< 0 || vol
->used_ebs
> vol
->reserved_pebs
) {
732 ubi_err(ubi
, "bad used_ebs");
735 if (vol
->last_eb_bytes
< 0 ||
736 vol
->last_eb_bytes
> vol
->usable_leb_size
) {
737 ubi_err(ubi
, "bad last_eb_bytes");
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");
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
;
755 vol_type
= UBI_STATIC_VOLUME
;
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");
764 spin_unlock(&ubi
->volumes_lock
);
768 ubi_err(ubi
, "self-check failed for volume %d", vol_id
);
770 ubi_dump_vol_info(vol
);
771 ubi_dump_vtbl_record(&ubi
->vtbl
[vol_id
], vol_id
);
773 spin_unlock(&ubi
->volumes_lock
);
778 * self_check_volumes - check information about all volumes.
779 * @ubi: UBI device description object
781 * Returns zero if volumes are all right and a a negative error code if not.
783 static int self_check_volumes(struct ubi_device
*ubi
)
787 if (!ubi_dbg_chk_gen(ubi
))
790 for (i
= 0; i
< ubi
->vtbl_slots
; i
++) {
791 err
= self_check_volume(ubi
, i
);