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