1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (c) International Business Machines Corp., 2006 4 * 5 * Author: Artem Bityutskiy (Битюцкий Артём) 6 */ 7 8 /* 9 * This file contains implementation of volume creation, deletion, updating and 10 * resizing. 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 /* Device attributes corresponding to files in '/<sysfs>/class/ubi/ubiX_Y' */ 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 * "Show" method for files in '/<sysfs>/class/ubi/ubiX_Y/'. 44 * 45 * Consider a situation: 46 * A. process 1 opens a sysfs file related to volume Y, say 47 * /<sysfs>/class/ubi/ubiX_Y/reserved_ebs; 48 * B. process 2 removes volume Y; 49 * C. process 1 starts reading the /<sysfs>/class/ubi/ubiX_Y/reserved_ebs file; 50 * 51 * In this situation, this function will return %-ENODEV because it will find 52 * out that the volume was removed from the @ubi->volumes array. 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 /* Take a reference to prevent volume removal */ 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 /* This must be a bug */ 99 ret = -EINVAL; 100 101 /* We've done the operation, drop volume and UBI device references */ 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 /* Release method for volume devices */ 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 * ubi_create_volume - create volume. 135 * @ubi: UBI device description object 136 * @req: volume creation request 137 * 138 * This function creates volume described by @req. If @req->vol_id id 139 * %UBI_VOL_NUM_AUTO, this function automatically assign ID to the new volume 140 * and saves it in @req->vol_id. Returns zero in case of success and a negative 141 * error code in case of failure. Note, the caller has to have the 142 * @ubi->device_mutex locked. 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 /* Find unused volume ID */ 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 /* Ensure that this volume does not exist */ 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 /* Ensure that the name is unique */ 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 /* Calculate how many eraseblocks are requested */ 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 /* Reserve physical eraseblocks */ 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 * Finish all pending erases because there may be some LEBs belonging 235 * to the same volume ID. 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 /* Make volume "available" before it becomes accessible via sysfs */ 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 /* Register character device for the volume */ 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 /* Fill volume table record */ 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 * We have registered our device, we should not free the volume 309 * description object in this function in case of an error - it is 310 * freed by the release function. 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 * 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 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 * self_check_volumes - check information about all volumes. 784 * @ubi: UBI device description object 785 * 786 * Returns zero if volumes are all right and a a negative error code if not. 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 } 803