1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include <linux/err.h>
27#include <linux/math64.h>
28#include "ubi.h"
29
30#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
31static int paranoid_check_volumes(struct ubi_device *ubi);
32#else
33#define paranoid_check_volumes(ubi) 0
34#endif
35
36static ssize_t vol_attribute_show(struct device *dev,
37 struct device_attribute *attr, char *buf);
38
39
40static struct device_attribute attr_vol_reserved_ebs =
41 __ATTR(reserved_ebs, S_IRUGO, vol_attribute_show, NULL);
42static struct device_attribute attr_vol_type =
43 __ATTR(type, S_IRUGO, vol_attribute_show, NULL);
44static struct device_attribute attr_vol_name =
45 __ATTR(name, S_IRUGO, vol_attribute_show, NULL);
46static struct device_attribute attr_vol_corrupted =
47 __ATTR(corrupted, S_IRUGO, vol_attribute_show, NULL);
48static struct device_attribute attr_vol_alignment =
49 __ATTR(alignment, S_IRUGO, vol_attribute_show, NULL);
50static struct device_attribute attr_vol_usable_eb_size =
51 __ATTR(usable_eb_size, S_IRUGO, vol_attribute_show, NULL);
52static struct device_attribute attr_vol_data_bytes =
53 __ATTR(data_bytes, S_IRUGO, vol_attribute_show, NULL);
54static struct device_attribute attr_vol_upd_marker =
55 __ATTR(upd_marker, S_IRUGO, vol_attribute_show, NULL);
56
57
58
59
60
61
62
63
64
65
66
67
68
69static ssize_t vol_attribute_show(struct device *dev,
70 struct device_attribute *attr, char *buf)
71{
72 int ret;
73 struct ubi_volume *vol = container_of(dev, struct ubi_volume, dev);
74 struct ubi_device *ubi;
75
76 ubi = ubi_get_device(vol->ubi->ubi_num);
77 if (!ubi)
78 return -ENODEV;
79
80 spin_lock(&ubi->volumes_lock);
81 if (!ubi->volumes[vol->vol_id]) {
82 spin_unlock(&ubi->volumes_lock);
83 ubi_put_device(ubi);
84 return -ENODEV;
85 }
86
87 vol->ref_count += 1;
88 spin_unlock(&ubi->volumes_lock);
89
90 if (attr == &attr_vol_reserved_ebs)
91 ret = sprintf(buf, "%d\n", vol->reserved_pebs);
92 else if (attr == &attr_vol_type) {
93 const char *tp;
94
95 if (vol->vol_type == UBI_DYNAMIC_VOLUME)
96 tp = "dynamic";
97 else
98 tp = "static";
99 ret = sprintf(buf, "%s\n", tp);
100 } else if (attr == &attr_vol_name)
101 ret = sprintf(buf, "%s\n", vol->name);
102 else if (attr == &attr_vol_corrupted)
103 ret = sprintf(buf, "%d\n", vol->corrupted);
104 else if (attr == &attr_vol_alignment)
105 ret = sprintf(buf, "%d\n", vol->alignment);
106 else if (attr == &attr_vol_usable_eb_size)
107 ret = sprintf(buf, "%d\n", vol->usable_leb_size);
108 else if (attr == &attr_vol_data_bytes)
109 ret = sprintf(buf, "%lld\n", vol->used_bytes);
110 else if (attr == &attr_vol_upd_marker)
111 ret = sprintf(buf, "%d\n", vol->upd_marker);
112 else
113
114 ret = -EINVAL;
115
116
117 spin_lock(&ubi->volumes_lock);
118 vol->ref_count -= 1;
119 ubi_assert(vol->ref_count >= 0);
120 spin_unlock(&ubi->volumes_lock);
121 ubi_put_device(ubi);
122 return ret;
123}
124
125
126static void vol_release(struct device *dev)
127{
128 struct ubi_volume *vol = container_of(dev, struct ubi_volume, dev);
129
130 kfree(vol->eba_tbl);
131 kfree(vol);
132}
133
134
135
136
137
138
139
140
141
142
143
144
145
146static int volume_sysfs_init(struct ubi_device *ubi, struct ubi_volume *vol)
147{
148 int err;
149
150 err = device_create_file(&vol->dev, &attr_vol_reserved_ebs);
151 if (err)
152 return err;
153 err = device_create_file(&vol->dev, &attr_vol_type);
154 if (err)
155 return err;
156 err = device_create_file(&vol->dev, &attr_vol_name);
157 if (err)
158 return err;
159 err = device_create_file(&vol->dev, &attr_vol_corrupted);
160 if (err)
161 return err;
162 err = device_create_file(&vol->dev, &attr_vol_alignment);
163 if (err)
164 return err;
165 err = device_create_file(&vol->dev, &attr_vol_usable_eb_size);
166 if (err)
167 return err;
168 err = device_create_file(&vol->dev, &attr_vol_data_bytes);
169 if (err)
170 return err;
171 err = device_create_file(&vol->dev, &attr_vol_upd_marker);
172 return err;
173}
174
175
176
177
178
179static void volume_sysfs_close(struct ubi_volume *vol)
180{
181 device_remove_file(&vol->dev, &attr_vol_upd_marker);
182 device_remove_file(&vol->dev, &attr_vol_data_bytes);
183 device_remove_file(&vol->dev, &attr_vol_usable_eb_size);
184 device_remove_file(&vol->dev, &attr_vol_alignment);
185 device_remove_file(&vol->dev, &attr_vol_corrupted);
186 device_remove_file(&vol->dev, &attr_vol_name);
187 device_remove_file(&vol->dev, &attr_vol_type);
188 device_remove_file(&vol->dev, &attr_vol_reserved_ebs);
189 device_unregister(&vol->dev);
190}
191
192
193
194
195
196
197
198
199
200
201
202
203int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
204{
205 int i, err, vol_id = req->vol_id, do_free = 1;
206 struct ubi_volume *vol;
207 struct ubi_vtbl_record vtbl_rec;
208 dev_t dev;
209
210 if (ubi->ro_mode)
211 return -EROFS;
212
213 vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL);
214 if (!vol)
215 return -ENOMEM;
216
217 spin_lock(&ubi->volumes_lock);
218 if (vol_id == UBI_VOL_NUM_AUTO) {
219
220 dbg_gen("search for vacant volume ID");
221 for (i = 0; i < ubi->vtbl_slots; i++)
222 if (!ubi->volumes[i]) {
223 vol_id = i;
224 break;
225 }
226
227 if (vol_id == UBI_VOL_NUM_AUTO) {
228 dbg_err("out of volume IDs");
229 err = -ENFILE;
230 goto out_unlock;
231 }
232 req->vol_id = vol_id;
233 }
234
235 dbg_gen("create device %d, volume %d, %llu bytes, type %d, name %s",
236 ubi->ubi_num, vol_id, (unsigned long long)req->bytes,
237 (int)req->vol_type, req->name);
238
239
240 err = -EEXIST;
241 if (ubi->volumes[vol_id]) {
242 dbg_err("volume %d already exists", vol_id);
243 goto out_unlock;
244 }
245
246
247 for (i = 0; i < ubi->vtbl_slots; i++)
248 if (ubi->volumes[i] &&
249 ubi->volumes[i]->name_len == req->name_len &&
250 !strcmp(ubi->volumes[i]->name, req->name)) {
251 dbg_err("volume \"%s\" exists (ID %d)", req->name, i);
252 goto out_unlock;
253 }
254
255
256 vol->usable_leb_size = ubi->leb_size - ubi->leb_size % req->alignment;
257 vol->reserved_pebs += div_u64(req->bytes + vol->usable_leb_size - 1,
258 vol->usable_leb_size);
259
260
261 if (vol->reserved_pebs > ubi->avail_pebs) {
262 dbg_err("not enough PEBs, only %d available", ubi->avail_pebs);
263 err = -ENOSPC;
264 goto out_unlock;
265 }
266 ubi->avail_pebs -= vol->reserved_pebs;
267 ubi->rsvd_pebs += vol->reserved_pebs;
268 spin_unlock(&ubi->volumes_lock);
269
270 vol->vol_id = vol_id;
271 vol->alignment = req->alignment;
272 vol->data_pad = ubi->leb_size % vol->alignment;
273 vol->vol_type = req->vol_type;
274 vol->name_len = req->name_len;
275 memcpy(vol->name, req->name, vol->name_len);
276 vol->ubi = ubi;
277
278
279
280
281
282 err = ubi_wl_flush(ubi);
283 if (err)
284 goto out_acc;
285
286 vol->eba_tbl = kmalloc(vol->reserved_pebs * sizeof(int), GFP_KERNEL);
287 if (!vol->eba_tbl) {
288 err = -ENOMEM;
289 goto out_acc;
290 }
291
292 for (i = 0; i < vol->reserved_pebs; i++)
293 vol->eba_tbl[i] = UBI_LEB_UNMAPPED;
294
295 if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
296 vol->used_ebs = vol->reserved_pebs;
297 vol->last_eb_bytes = vol->usable_leb_size;
298 vol->used_bytes =
299 (long long)vol->used_ebs * vol->usable_leb_size;
300 } else {
301 vol->used_ebs = div_u64_rem(vol->used_bytes,
302 vol->usable_leb_size,
303 &vol->last_eb_bytes);
304 if (vol->last_eb_bytes != 0)
305 vol->used_ebs += 1;
306 else
307 vol->last_eb_bytes = vol->usable_leb_size;
308 }
309
310
311 cdev_init(&vol->cdev, &ubi_vol_cdev_operations);
312 vol->cdev.owner = THIS_MODULE;
313 dev = MKDEV(MAJOR(ubi->cdev.dev), vol_id + 1);
314 err = cdev_add(&vol->cdev, dev, 1);
315 if (err) {
316 ubi_err("cannot add character device");
317 goto out_mapping;
318 }
319
320 vol->dev.release = vol_release;
321 vol->dev.parent = &ubi->dev;
322 vol->dev.devt = dev;
323 vol->dev.class = ubi_class;
324
325 dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
326 err = device_register(&vol->dev);
327 if (err) {
328 ubi_err("cannot register device");
329 goto out_cdev;
330 }
331
332 err = volume_sysfs_init(ubi, vol);
333 if (err)
334 goto out_sysfs;
335
336
337 memset(&vtbl_rec, 0, sizeof(struct ubi_vtbl_record));
338 vtbl_rec.reserved_pebs = cpu_to_be32(vol->reserved_pebs);
339 vtbl_rec.alignment = cpu_to_be32(vol->alignment);
340 vtbl_rec.data_pad = cpu_to_be32(vol->data_pad);
341 vtbl_rec.name_len = cpu_to_be16(vol->name_len);
342 if (vol->vol_type == UBI_DYNAMIC_VOLUME)
343 vtbl_rec.vol_type = UBI_VID_DYNAMIC;
344 else
345 vtbl_rec.vol_type = UBI_VID_STATIC;
346 memcpy(vtbl_rec.name, vol->name, vol->name_len);
347
348 err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
349 if (err)
350 goto out_sysfs;
351
352 spin_lock(&ubi->volumes_lock);
353 ubi->volumes[vol_id] = vol;
354 ubi->vol_count += 1;
355 spin_unlock(&ubi->volumes_lock);
356
357 ubi_volume_notify(ubi, vol, UBI_VOLUME_ADDED);
358 if (paranoid_check_volumes(ubi))
359 dbg_err("check failed while creating volume %d", vol_id);
360 return err;
361
362out_sysfs:
363
364
365
366
367
368
369
370
371 do_free = 0;
372 get_device(&vol->dev);
373 volume_sysfs_close(vol);
374out_cdev:
375 cdev_del(&vol->cdev);
376out_mapping:
377 if (do_free)
378 kfree(vol->eba_tbl);
379out_acc:
380 spin_lock(&ubi->volumes_lock);
381 ubi->rsvd_pebs -= vol->reserved_pebs;
382 ubi->avail_pebs += vol->reserved_pebs;
383out_unlock:
384 spin_unlock(&ubi->volumes_lock);
385 if (do_free)
386 kfree(vol);
387 else
388 put_device(&vol->dev);
389 ubi_err("cannot create volume %d, error %d", vol_id, err);
390 return err;
391}
392
393
394
395
396
397
398
399
400
401
402
403int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl)
404{
405 struct ubi_volume *vol = desc->vol;
406 struct ubi_device *ubi = vol->ubi;
407 int i, err, vol_id = vol->vol_id, reserved_pebs = vol->reserved_pebs;
408
409 dbg_gen("remove device %d, volume %d", ubi->ubi_num, vol_id);
410 ubi_assert(desc->mode == UBI_EXCLUSIVE);
411 ubi_assert(vol == ubi->volumes[vol_id]);
412
413 if (ubi->ro_mode)
414 return -EROFS;
415
416 spin_lock(&ubi->volumes_lock);
417 if (vol->ref_count > 1) {
418
419
420
421
422 err = -EBUSY;
423 goto out_unlock;
424 }
425 ubi->volumes[vol_id] = NULL;
426 spin_unlock(&ubi->volumes_lock);
427
428 if (!no_vtbl) {
429 err = ubi_change_vtbl_record(ubi, vol_id, NULL);
430 if (err)
431 goto out_err;
432 }
433
434 for (i = 0; i < vol->reserved_pebs; i++) {
435 err = ubi_eba_unmap_leb(ubi, vol, i);
436 if (err)
437 goto out_err;
438 }
439
440 cdev_del(&vol->cdev);
441 volume_sysfs_close(vol);
442
443 spin_lock(&ubi->volumes_lock);
444 ubi->rsvd_pebs -= reserved_pebs;
445 ubi->avail_pebs += reserved_pebs;
446 i = ubi->beb_rsvd_level - ubi->beb_rsvd_pebs;
447 if (i > 0) {
448 i = ubi->avail_pebs >= i ? i : ubi->avail_pebs;
449 ubi->avail_pebs -= i;
450 ubi->rsvd_pebs += i;
451 ubi->beb_rsvd_pebs += i;
452 if (i > 0)
453 ubi_msg("reserve more %d PEBs", i);
454 }
455 ubi->vol_count -= 1;
456 spin_unlock(&ubi->volumes_lock);
457
458 ubi_volume_notify(ubi, vol, UBI_VOLUME_REMOVED);
459 if (!no_vtbl && paranoid_check_volumes(ubi))
460 dbg_err("check failed while removing volume %d", vol_id);
461
462 return err;
463
464out_err:
465 ubi_err("cannot remove volume %d, error %d", vol_id, err);
466 spin_lock(&ubi->volumes_lock);
467 ubi->volumes[vol_id] = vol;
468out_unlock:
469 spin_unlock(&ubi->volumes_lock);
470 return err;
471}
472
473
474
475
476
477
478
479
480
481
482int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs)
483{
484 int i, err, pebs, *new_mapping;
485 struct ubi_volume *vol = desc->vol;
486 struct ubi_device *ubi = vol->ubi;
487 struct ubi_vtbl_record vtbl_rec;
488 int vol_id = vol->vol_id;
489
490 if (ubi->ro_mode)
491 return -EROFS;
492
493 dbg_gen("re-size device %d, volume %d to from %d to %d PEBs",
494 ubi->ubi_num, vol_id, vol->reserved_pebs, reserved_pebs);
495
496 if (vol->vol_type == UBI_STATIC_VOLUME &&
497 reserved_pebs < vol->used_ebs) {
498 dbg_err("too small size %d, %d LEBs contain data",
499 reserved_pebs, vol->used_ebs);
500 return -EINVAL;
501 }
502
503
504 if (reserved_pebs == vol->reserved_pebs)
505 return 0;
506
507 new_mapping = kmalloc(reserved_pebs * sizeof(int), GFP_KERNEL);
508 if (!new_mapping)
509 return -ENOMEM;
510
511 for (i = 0; i < reserved_pebs; i++)
512 new_mapping[i] = UBI_LEB_UNMAPPED;
513
514 spin_lock(&ubi->volumes_lock);
515 if (vol->ref_count > 1) {
516 spin_unlock(&ubi->volumes_lock);
517 err = -EBUSY;
518 goto out_free;
519 }
520 spin_unlock(&ubi->volumes_lock);
521
522
523 pebs = reserved_pebs - vol->reserved_pebs;
524 if (pebs > 0) {
525 spin_lock(&ubi->volumes_lock);
526 if (pebs > ubi->avail_pebs) {
527 dbg_err("not enough PEBs: requested %d, available %d",
528 pebs, ubi->avail_pebs);
529 spin_unlock(&ubi->volumes_lock);
530 err = -ENOSPC;
531 goto out_free;
532 }
533 ubi->avail_pebs -= pebs;
534 ubi->rsvd_pebs += pebs;
535 for (i = 0; i < vol->reserved_pebs; i++)
536 new_mapping[i] = vol->eba_tbl[i];
537 kfree(vol->eba_tbl);
538 vol->eba_tbl = new_mapping;
539 spin_unlock(&ubi->volumes_lock);
540 }
541
542
543 memcpy(&vtbl_rec, &ubi->vtbl[vol_id], sizeof(struct ubi_vtbl_record));
544 vtbl_rec.reserved_pebs = cpu_to_be32(reserved_pebs);
545 err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
546 if (err)
547 goto out_acc;
548
549 if (pebs < 0) {
550 for (i = 0; i < -pebs; i++) {
551 err = ubi_eba_unmap_leb(ubi, vol, reserved_pebs + i);
552 if (err)
553 goto out_acc;
554 }
555 spin_lock(&ubi->volumes_lock);
556 ubi->rsvd_pebs += pebs;
557 ubi->avail_pebs -= pebs;
558 pebs = ubi->beb_rsvd_level - ubi->beb_rsvd_pebs;
559 if (pebs > 0) {
560 pebs = ubi->avail_pebs >= pebs ? pebs : ubi->avail_pebs;
561 ubi->avail_pebs -= pebs;
562 ubi->rsvd_pebs += pebs;
563 ubi->beb_rsvd_pebs += pebs;
564 if (pebs > 0)
565 ubi_msg("reserve more %d PEBs", pebs);
566 }
567 for (i = 0; i < reserved_pebs; i++)
568 new_mapping[i] = vol->eba_tbl[i];
569 kfree(vol->eba_tbl);
570 vol->eba_tbl = new_mapping;
571 spin_unlock(&ubi->volumes_lock);
572 }
573
574 vol->reserved_pebs = reserved_pebs;
575 if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
576 vol->used_ebs = reserved_pebs;
577 vol->last_eb_bytes = vol->usable_leb_size;
578 vol->used_bytes =
579 (long long)vol->used_ebs * vol->usable_leb_size;
580 }
581
582 ubi_volume_notify(ubi, vol, UBI_VOLUME_RESIZED);
583 if (paranoid_check_volumes(ubi))
584 dbg_err("check failed while re-sizing volume %d", vol_id);
585 return err;
586
587out_acc:
588 if (pebs > 0) {
589 spin_lock(&ubi->volumes_lock);
590 ubi->rsvd_pebs -= pebs;
591 ubi->avail_pebs += pebs;
592 spin_unlock(&ubi->volumes_lock);
593 }
594out_free:
595 kfree(new_mapping);
596 return err;
597}
598
599
600
601
602
603
604
605
606
607
608int ubi_rename_volumes(struct ubi_device *ubi, struct list_head *rename_list)
609{
610 int err;
611 struct ubi_rename_entry *re;
612
613 err = ubi_vtbl_rename_volumes(ubi, rename_list);
614 if (err)
615 return err;
616
617 list_for_each_entry(re, rename_list, list) {
618 if (re->remove) {
619 err = ubi_remove_volume(re->desc, 1);
620 if (err)
621 break;
622 } else {
623 struct ubi_volume *vol = re->desc->vol;
624
625 spin_lock(&ubi->volumes_lock);
626 vol->name_len = re->new_name_len;
627 memcpy(vol->name, re->new_name, re->new_name_len + 1);
628 spin_unlock(&ubi->volumes_lock);
629 ubi_volume_notify(ubi, vol, UBI_VOLUME_RENAMED);
630 }
631 }
632
633 if (!err && paranoid_check_volumes(ubi))
634 ;
635 return err;
636}
637
638
639
640
641
642
643
644
645
646
647int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol)
648{
649 int err, vol_id = vol->vol_id;
650 dev_t dev;
651
652 dbg_gen("add volume %d", vol_id);
653
654
655 cdev_init(&vol->cdev, &ubi_vol_cdev_operations);
656 vol->cdev.owner = THIS_MODULE;
657 dev = MKDEV(MAJOR(ubi->cdev.dev), vol->vol_id + 1);
658 err = cdev_add(&vol->cdev, dev, 1);
659 if (err) {
660 ubi_err("cannot add character device for volume %d, error %d",
661 vol_id, err);
662 return err;
663 }
664
665 vol->dev.release = vol_release;
666 vol->dev.parent = &ubi->dev;
667 vol->dev.devt = dev;
668 vol->dev.class = ubi_class;
669 dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
670 err = device_register(&vol->dev);
671 if (err)
672 goto out_cdev;
673
674 err = volume_sysfs_init(ubi, vol);
675 if (err) {
676 cdev_del(&vol->cdev);
677 volume_sysfs_close(vol);
678 return err;
679 }
680
681 if (paranoid_check_volumes(ubi))
682 dbg_err("check failed while adding volume %d", vol_id);
683 return err;
684
685out_cdev:
686 cdev_del(&vol->cdev);
687 return err;
688}
689
690
691
692
693
694
695
696
697
698void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol)
699{
700 dbg_gen("free volume %d", vol->vol_id);
701
702 ubi->volumes[vol->vol_id] = NULL;
703 cdev_del(&vol->cdev);
704 volume_sysfs_close(vol);
705}
706
707#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
708
709
710
711
712
713
714
715
716static int paranoid_check_volume(struct ubi_device *ubi, int vol_id)
717{
718 int idx = vol_id2idx(ubi, vol_id);
719 int reserved_pebs, alignment, data_pad, vol_type, name_len, upd_marker;
720 const struct ubi_volume *vol;
721 long long n;
722 const char *name;
723
724 spin_lock(&ubi->volumes_lock);
725 reserved_pebs = be32_to_cpu(ubi->vtbl[vol_id].reserved_pebs);
726 vol = ubi->volumes[idx];
727
728 if (!vol) {
729 if (reserved_pebs) {
730 ubi_err("no volume info, but volume exists");
731 goto fail;
732 }
733 spin_unlock(&ubi->volumes_lock);
734 return 0;
735 }
736
737 if (vol->reserved_pebs < 0 || vol->alignment < 0 || vol->data_pad < 0 ||
738 vol->name_len < 0) {
739 ubi_err("negative values");
740 goto fail;
741 }
742 if (vol->alignment > ubi->leb_size || vol->alignment == 0) {
743 ubi_err("bad alignment");
744 goto fail;
745 }
746
747 n = vol->alignment & (ubi->min_io_size - 1);
748 if (vol->alignment != 1 && n) {
749 ubi_err("alignment is not multiple of min I/O unit");
750 goto fail;
751 }
752
753 n = ubi->leb_size % vol->alignment;
754 if (vol->data_pad != n) {
755 ubi_err("bad data_pad, has to be %lld", n);
756 goto fail;
757 }
758
759 if (vol->vol_type != UBI_DYNAMIC_VOLUME &&
760 vol->vol_type != UBI_STATIC_VOLUME) {
761 ubi_err("bad vol_type");
762 goto fail;
763 }
764
765 if (vol->upd_marker && vol->corrupted) {
766 dbg_err("update marker and corrupted simultaneously");
767 goto fail;
768 }
769
770 if (vol->reserved_pebs > ubi->good_peb_count) {
771 ubi_err("too large reserved_pebs");
772 goto fail;
773 }
774
775 n = ubi->leb_size - vol->data_pad;
776 if (vol->usable_leb_size != ubi->leb_size - vol->data_pad) {
777 ubi_err("bad usable_leb_size, has to be %lld", n);
778 goto fail;
779 }
780
781 if (vol->name_len > UBI_VOL_NAME_MAX) {
782 ubi_err("too long volume name, max is %d", UBI_VOL_NAME_MAX);
783 goto fail;
784 }
785
786 if (!vol->name) {
787 ubi_err("NULL volume name");
788 goto fail;
789 }
790
791 n = strnlen(vol->name, vol->name_len + 1);
792 if (n != vol->name_len) {
793 ubi_err("bad name_len %lld", n);
794 goto fail;
795 }
796
797 n = (long long)vol->used_ebs * vol->usable_leb_size;
798 if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
799 if (vol->corrupted) {
800 ubi_err("corrupted dynamic volume");
801 goto fail;
802 }
803 if (vol->used_ebs != vol->reserved_pebs) {
804 ubi_err("bad used_ebs");
805 goto fail;
806 }
807 if (vol->last_eb_bytes != vol->usable_leb_size) {
808 ubi_err("bad last_eb_bytes");
809 goto fail;
810 }
811 if (vol->used_bytes != n) {
812 ubi_err("bad used_bytes");
813 goto fail;
814 }
815 } else {
816 if (vol->used_ebs < 0 || vol->used_ebs > vol->reserved_pebs) {
817 ubi_err("bad used_ebs");
818 goto fail;
819 }
820 if (vol->last_eb_bytes < 0 ||
821 vol->last_eb_bytes > vol->usable_leb_size) {
822 ubi_err("bad last_eb_bytes");
823 goto fail;
824 }
825 if (vol->used_bytes < 0 || vol->used_bytes > n ||
826 vol->used_bytes < n - vol->usable_leb_size) {
827 ubi_err("bad used_bytes");
828 goto fail;
829 }
830 }
831
832 alignment = be32_to_cpu(ubi->vtbl[vol_id].alignment);
833 data_pad = be32_to_cpu(ubi->vtbl[vol_id].data_pad);
834 name_len = be16_to_cpu(ubi->vtbl[vol_id].name_len);
835 upd_marker = ubi->vtbl[vol_id].upd_marker;
836 name = &ubi->vtbl[vol_id].name[0];
837 if (ubi->vtbl[vol_id].vol_type == UBI_VID_DYNAMIC)
838 vol_type = UBI_DYNAMIC_VOLUME;
839 else
840 vol_type = UBI_STATIC_VOLUME;
841
842 if (alignment != vol->alignment || data_pad != vol->data_pad ||
843 upd_marker != vol->upd_marker || vol_type != vol->vol_type ||
844 name_len != vol->name_len || strncmp(name, vol->name, name_len)) {
845 ubi_err("volume info is different");
846 goto fail;
847 }
848
849 spin_unlock(&ubi->volumes_lock);
850 return 0;
851
852fail:
853 ubi_err("paranoid check failed for volume %d", vol_id);
854 if (vol)
855 ubi_dbg_dump_vol_info(vol);
856 ubi_dbg_dump_vtbl_record(&ubi->vtbl[vol_id], vol_id);
857 dump_stack();
858 spin_unlock(&ubi->volumes_lock);
859 return -EINVAL;
860}
861
862
863
864
865
866
867
868static int paranoid_check_volumes(struct ubi_device *ubi)
869{
870 int i, err = 0;
871
872 for (i = 0; i < ubi->vtbl_slots; i++) {
873 err = paranoid_check_volume(ubi, i);
874 if (err)
875 break;
876 }
877
878 return err;
879}
880#endif
881