This source file includes following definitions.
- vol_attribute_show
- vol_release
- ubi_create_volume
- ubi_remove_volume
- ubi_resize_volume
- ubi_rename_volumes
- ubi_add_volume
- ubi_free_volume
- self_check_volume
- self_check_volumes
1
2
3
4
5
6
7
8
9
10
11
12
13 #include <linux/err.h>
14 #include <linux/math64.h>
15 #include <linux/slab.h>
16 #include <linux/export.h>
17 #include "ubi.h"
18
19 static int self_check_volumes(struct ubi_device *ubi);
20
21 static ssize_t vol_attribute_show(struct device *dev,
22 struct device_attribute *attr, char *buf);
23
24
25 static struct device_attribute attr_vol_reserved_ebs =
26 __ATTR(reserved_ebs, S_IRUGO, vol_attribute_show, NULL);
27 static struct device_attribute attr_vol_type =
28 __ATTR(type, S_IRUGO, vol_attribute_show, NULL);
29 static struct device_attribute attr_vol_name =
30 __ATTR(name, S_IRUGO, vol_attribute_show, NULL);
31 static struct device_attribute attr_vol_corrupted =
32 __ATTR(corrupted, S_IRUGO, vol_attribute_show, NULL);
33 static struct device_attribute attr_vol_alignment =
34 __ATTR(alignment, S_IRUGO, vol_attribute_show, NULL);
35 static struct device_attribute attr_vol_usable_eb_size =
36 __ATTR(usable_eb_size, S_IRUGO, vol_attribute_show, NULL);
37 static struct device_attribute attr_vol_data_bytes =
38 __ATTR(data_bytes, S_IRUGO, vol_attribute_show, NULL);
39 static struct device_attribute attr_vol_upd_marker =
40 __ATTR(upd_marker, S_IRUGO, vol_attribute_show, NULL);
41
42
43
44
45
46
47
48
49
50
51
52
53
54 static ssize_t vol_attribute_show(struct device *dev,
55 struct device_attribute *attr, char *buf)
56 {
57 int ret;
58 struct ubi_volume *vol = container_of(dev, struct ubi_volume, dev);
59 struct ubi_device *ubi;
60
61 ubi = ubi_get_device(vol->ubi->ubi_num);
62 if (!ubi)
63 return -ENODEV;
64
65 spin_lock(&ubi->volumes_lock);
66 if (!ubi->volumes[vol->vol_id]) {
67 spin_unlock(&ubi->volumes_lock);
68 ubi_put_device(ubi);
69 return -ENODEV;
70 }
71
72 vol->ref_count += 1;
73 spin_unlock(&ubi->volumes_lock);
74
75 if (attr == &attr_vol_reserved_ebs)
76 ret = sprintf(buf, "%d\n", vol->reserved_pebs);
77 else if (attr == &attr_vol_type) {
78 const char *tp;
79
80 if (vol->vol_type == UBI_DYNAMIC_VOLUME)
81 tp = "dynamic";
82 else
83 tp = "static";
84 ret = sprintf(buf, "%s\n", tp);
85 } else if (attr == &attr_vol_name)
86 ret = sprintf(buf, "%s\n", vol->name);
87 else if (attr == &attr_vol_corrupted)
88 ret = sprintf(buf, "%d\n", vol->corrupted);
89 else if (attr == &attr_vol_alignment)
90 ret = sprintf(buf, "%d\n", vol->alignment);
91 else if (attr == &attr_vol_usable_eb_size)
92 ret = sprintf(buf, "%d\n", vol->usable_leb_size);
93 else if (attr == &attr_vol_data_bytes)
94 ret = sprintf(buf, "%lld\n", vol->used_bytes);
95 else if (attr == &attr_vol_upd_marker)
96 ret = sprintf(buf, "%d\n", vol->upd_marker);
97 else
98
99 ret = -EINVAL;
100
101
102 spin_lock(&ubi->volumes_lock);
103 vol->ref_count -= 1;
104 ubi_assert(vol->ref_count >= 0);
105 spin_unlock(&ubi->volumes_lock);
106 ubi_put_device(ubi);
107 return ret;
108 }
109
110 static struct attribute *volume_dev_attrs[] = {
111 &attr_vol_reserved_ebs.attr,
112 &attr_vol_type.attr,
113 &attr_vol_name.attr,
114 &attr_vol_corrupted.attr,
115 &attr_vol_alignment.attr,
116 &attr_vol_usable_eb_size.attr,
117 &attr_vol_data_bytes.attr,
118 &attr_vol_upd_marker.attr,
119 NULL
120 };
121 ATTRIBUTE_GROUPS(volume_dev);
122
123
124 static void vol_release(struct device *dev)
125 {
126 struct ubi_volume *vol = container_of(dev, struct ubi_volume, dev);
127
128 ubi_eba_replace_table(vol, NULL);
129 ubi_fastmap_destroy_checkmap(vol);
130 kfree(vol);
131 }
132
133
134
135
136
137
138
139
140
141
142
143
144 int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
145 {
146 int i, err, vol_id = req->vol_id;
147 struct ubi_volume *vol;
148 struct ubi_vtbl_record vtbl_rec;
149 struct ubi_eba_table *eba_tbl = NULL;
150
151 if (ubi->ro_mode)
152 return -EROFS;
153
154 vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL);
155 if (!vol)
156 return -ENOMEM;
157
158 device_initialize(&vol->dev);
159 vol->dev.release = vol_release;
160 vol->dev.parent = &ubi->dev;
161 vol->dev.class = &ubi_class;
162 vol->dev.groups = volume_dev_groups;
163
164 if (req->flags & UBI_VOL_SKIP_CRC_CHECK_FLG)
165 vol->skip_check = 1;
166
167 spin_lock(&ubi->volumes_lock);
168 if (vol_id == UBI_VOL_NUM_AUTO) {
169
170 dbg_gen("search for vacant volume ID");
171 for (i = 0; i < ubi->vtbl_slots; i++)
172 if (!ubi->volumes[i]) {
173 vol_id = i;
174 break;
175 }
176
177 if (vol_id == UBI_VOL_NUM_AUTO) {
178 ubi_err(ubi, "out of volume IDs");
179 err = -ENFILE;
180 goto out_unlock;
181 }
182 req->vol_id = vol_id;
183 }
184
185 dbg_gen("create device %d, volume %d, %llu bytes, type %d, name %s",
186 ubi->ubi_num, vol_id, (unsigned long long)req->bytes,
187 (int)req->vol_type, req->name);
188
189
190 err = -EEXIST;
191 if (ubi->volumes[vol_id]) {
192 ubi_err(ubi, "volume %d already exists", vol_id);
193 goto out_unlock;
194 }
195
196
197 for (i = 0; i < ubi->vtbl_slots; i++)
198 if (ubi->volumes[i] &&
199 ubi->volumes[i]->name_len == req->name_len &&
200 !strcmp(ubi->volumes[i]->name, req->name)) {
201 ubi_err(ubi, "volume \"%s\" exists (ID %d)",
202 req->name, i);
203 goto out_unlock;
204 }
205
206
207 vol->usable_leb_size = ubi->leb_size - ubi->leb_size % req->alignment;
208 vol->reserved_pebs = div_u64(req->bytes + vol->usable_leb_size - 1,
209 vol->usable_leb_size);
210
211
212 if (vol->reserved_pebs > ubi->avail_pebs) {
213 ubi_err(ubi, "not enough PEBs, only %d available",
214 ubi->avail_pebs);
215 if (ubi->corr_peb_count)
216 ubi_err(ubi, "%d PEBs are corrupted and not used",
217 ubi->corr_peb_count);
218 err = -ENOSPC;
219 goto out_unlock;
220 }
221 ubi->avail_pebs -= vol->reserved_pebs;
222 ubi->rsvd_pebs += vol->reserved_pebs;
223 spin_unlock(&ubi->volumes_lock);
224
225 vol->vol_id = vol_id;
226 vol->alignment = req->alignment;
227 vol->data_pad = ubi->leb_size % vol->alignment;
228 vol->vol_type = req->vol_type;
229 vol->name_len = req->name_len;
230 memcpy(vol->name, req->name, vol->name_len);
231 vol->ubi = ubi;
232
233
234
235
236
237 err = ubi_wl_flush(ubi, vol_id, UBI_ALL);
238 if (err)
239 goto out_acc;
240
241 eba_tbl = ubi_eba_create_table(vol, vol->reserved_pebs);
242 if (IS_ERR(eba_tbl)) {
243 err = PTR_ERR(eba_tbl);
244 goto out_acc;
245 }
246
247 ubi_eba_replace_table(vol, eba_tbl);
248
249 if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
250 vol->used_ebs = vol->reserved_pebs;
251 vol->last_eb_bytes = vol->usable_leb_size;
252 vol->used_bytes =
253 (long long)vol->used_ebs * vol->usable_leb_size;
254 } else {
255 vol->used_ebs = div_u64_rem(vol->used_bytes,
256 vol->usable_leb_size,
257 &vol->last_eb_bytes);
258 if (vol->last_eb_bytes != 0)
259 vol->used_ebs += 1;
260 else
261 vol->last_eb_bytes = vol->usable_leb_size;
262 }
263
264
265 spin_lock(&ubi->volumes_lock);
266 ubi->volumes[vol_id] = vol;
267 ubi->vol_count += 1;
268 spin_unlock(&ubi->volumes_lock);
269
270
271 cdev_init(&vol->cdev, &ubi_vol_cdev_operations);
272 vol->cdev.owner = THIS_MODULE;
273
274 vol->dev.devt = MKDEV(MAJOR(ubi->cdev.dev), vol_id + 1);
275 dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
276 err = cdev_device_add(&vol->cdev, &vol->dev);
277 if (err) {
278 ubi_err(ubi, "cannot add device");
279 goto out_mapping;
280 }
281
282
283 memset(&vtbl_rec, 0, sizeof(struct ubi_vtbl_record));
284 vtbl_rec.reserved_pebs = cpu_to_be32(vol->reserved_pebs);
285 vtbl_rec.alignment = cpu_to_be32(vol->alignment);
286 vtbl_rec.data_pad = cpu_to_be32(vol->data_pad);
287 vtbl_rec.name_len = cpu_to_be16(vol->name_len);
288 if (vol->vol_type == UBI_DYNAMIC_VOLUME)
289 vtbl_rec.vol_type = UBI_VID_DYNAMIC;
290 else
291 vtbl_rec.vol_type = UBI_VID_STATIC;
292
293 if (vol->skip_check)
294 vtbl_rec.flags |= UBI_VTBL_SKIP_CRC_CHECK_FLG;
295
296 memcpy(vtbl_rec.name, vol->name, vol->name_len);
297
298 err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
299 if (err)
300 goto out_sysfs;
301
302 ubi_volume_notify(ubi, vol, UBI_VOLUME_ADDED);
303 self_check_volumes(ubi);
304 return err;
305
306 out_sysfs:
307
308
309
310
311
312 cdev_device_del(&vol->cdev, &vol->dev);
313 out_mapping:
314 spin_lock(&ubi->volumes_lock);
315 ubi->volumes[vol_id] = NULL;
316 ubi->vol_count -= 1;
317 spin_unlock(&ubi->volumes_lock);
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
332
333
334
335
336
337
338
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
357
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
404
405
406
407
408
409
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
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
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
487
488
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
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
529
530
531
532
533
534
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
568
569
570
571
572
573
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
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
613
614
615
616
617
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
630
631
632
633
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
731 if (vol->skip_check) {
732 ubi_err(ubi, "bad skip_check");
733 goto fail;
734 }
735 } else {
736 if (vol->used_ebs < 0 || vol->used_ebs > vol->reserved_pebs) {
737 ubi_err(ubi, "bad used_ebs");
738 goto fail;
739 }
740 if (vol->last_eb_bytes < 0 ||
741 vol->last_eb_bytes > vol->usable_leb_size) {
742 ubi_err(ubi, "bad last_eb_bytes");
743 goto fail;
744 }
745 if (vol->used_bytes < 0 || vol->used_bytes > n ||
746 vol->used_bytes < n - vol->usable_leb_size) {
747 ubi_err(ubi, "bad used_bytes");
748 goto fail;
749 }
750 }
751
752 alignment = be32_to_cpu(ubi->vtbl[vol_id].alignment);
753 data_pad = be32_to_cpu(ubi->vtbl[vol_id].data_pad);
754 name_len = be16_to_cpu(ubi->vtbl[vol_id].name_len);
755 upd_marker = ubi->vtbl[vol_id].upd_marker;
756 name = &ubi->vtbl[vol_id].name[0];
757 if (ubi->vtbl[vol_id].vol_type == UBI_VID_DYNAMIC)
758 vol_type = UBI_DYNAMIC_VOLUME;
759 else
760 vol_type = UBI_STATIC_VOLUME;
761
762 if (alignment != vol->alignment || data_pad != vol->data_pad ||
763 upd_marker != vol->upd_marker || vol_type != vol->vol_type ||
764 name_len != vol->name_len || strncmp(name, vol->name, name_len)) {
765 ubi_err(ubi, "volume info is different");
766 goto fail;
767 }
768
769 spin_unlock(&ubi->volumes_lock);
770 return 0;
771
772 fail:
773 ubi_err(ubi, "self-check failed for volume %d", vol_id);
774 if (vol)
775 ubi_dump_vol_info(vol);
776 ubi_dump_vtbl_record(&ubi->vtbl[vol_id], vol_id);
777 dump_stack();
778 spin_unlock(&ubi->volumes_lock);
779 return -EINVAL;
780 }
781
782
783
784
785
786
787
788 static int self_check_volumes(struct ubi_device *ubi)
789 {
790 int i, err = 0;
791
792 if (!ubi_dbg_chk_gen(ubi))
793 return 0;
794
795 for (i = 0; i < ubi->vtbl_slots; i++) {
796 err = self_check_volume(ubi, i);
797 if (err)
798 break;
799 }
800
801 return err;
802 }