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 19static int self_check_volumes(struct ubi_device *ubi); 20 21static 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' */ 25static struct device_attribute attr_vol_reserved_ebs = 26 __ATTR(reserved_ebs, S_IRUGO, vol_attribute_show, NULL); 27static struct device_attribute attr_vol_type = 28 __ATTR(type, S_IRUGO, vol_attribute_show, NULL); 29static struct device_attribute attr_vol_name = 30 __ATTR(name, S_IRUGO, vol_attribute_show, NULL); 31static struct device_attribute attr_vol_corrupted = 32 __ATTR(corrupted, S_IRUGO, vol_attribute_show, NULL); 33static struct device_attribute attr_vol_alignment = 34 __ATTR(alignment, S_IRUGO, vol_attribute_show, NULL); 35static struct device_attribute attr_vol_usable_eb_size = 36 __ATTR(usable_eb_size, S_IRUGO, vol_attribute_show, NULL); 37static struct device_attribute attr_vol_data_bytes = 38 __ATTR(data_bytes, S_IRUGO, vol_attribute_show, NULL); 39static 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 */ 54static 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 104static 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}; 115ATTRIBUTE_GROUPS(volume_dev); 116 117/* Release method for volume devices */ 118static 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 */ 138int 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 300out_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); 307out_mapping: 308 spin_lock(&ubi->volumes_lock); 309 ubi->volumes[vol_id] = NULL; 310 ubi->vol_count -= 1; 311 spin_unlock(&ubi->volumes_lock); 312out_acc: 313 spin_lock(&ubi->volumes_lock); 314 ubi->rsvd_pebs -= vol->reserved_pebs; 315 ubi->avail_pebs += vol->reserved_pebs; 316out_unlock: 317 spin_unlock(&ubi->volumes_lock); 318 put_device(&vol->dev); 319 ubi_err(ubi, "cannot create volume %d, error %d", vol_id, err); 320 return err; 321} 322 323/** 324 * ubi_remove_volume - remove volume. 325 * @desc: volume descriptor 326 * @no_vtbl: do not change volume table if not zero 327 * 328 * This function removes volume described by @desc. The volume has to be opened 329 * in "exclusive" mode. Returns zero in case of success and a negative error 330 * code in case of failure. The caller has to have the @ubi->device_mutex 331 * locked. 332 */ 333int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl) 334{ 335 struct ubi_volume *vol = desc->vol; 336 struct ubi_device *ubi = vol->ubi; 337 int i, err, vol_id = vol->vol_id, reserved_pebs = vol->reserved_pebs; 338 339 dbg_gen("remove device %d, volume %d", ubi->ubi_num, vol_id); 340 ubi_assert(desc->mode == UBI_EXCLUSIVE); 341 ubi_assert(vol == ubi->volumes[vol_id]); 342 343 if (ubi->ro_mode) 344 return -EROFS; 345 346 spin_lock(&ubi->volumes_lock); 347 if (vol->ref_count > 1) { 348 /* 349 * The volume is busy, probably someone is reading one of its 350 * sysfs files. 351 */ 352 err = -EBUSY; 353 goto out_unlock; 354 } 355 ubi->volumes[vol_id] = NULL; 356 spin_unlock(&ubi->volumes_lock); 357 358 if (!no_vtbl) { 359 err = ubi_change_vtbl_record(ubi, vol_id, NULL); 360 if (err) 361 goto out_err; 362 } 363 364 for (i = 0; i < vol->reserved_pebs; i++) { 365 err = ubi_eba_unmap_leb(ubi, vol, i); 366 if (err) 367 goto out_err; 368 } 369 370 cdev_device_del(&vol->cdev, &vol->dev); 371 put_device(&vol->dev); 372 373 spin_lock(&ubi->volumes_lock); 374 ubi->rsvd_pebs -= reserved_pebs; 375 ubi->avail_pebs += reserved_pebs; 376 ubi_update_reserved(ubi); 377 ubi->vol_count -= 1; 378 spin_unlock(&ubi->volumes_lock); 379 380 ubi_volume_notify(ubi, vol, UBI_VOLUME_REMOVED); 381 if (!no_vtbl) 382 self_check_volumes(ubi); 383 384 return 0; 385 386out_err: 387 ubi_err(ubi, "cannot remove volume %d, error %d", vol_id, err); 388 spin_lock(&ubi->volumes_lock); 389 ubi->volumes[vol_id] = vol; 390out_unlock: 391 spin_unlock(&ubi->volumes_lock); 392 return err; 393} 394 395/** 396 * ubi_resize_volume - re-size volume. 397 * @desc: volume descriptor 398 * @reserved_pebs: new size in physical eraseblocks 399 * 400 * This function re-sizes the volume and returns zero in case of success, and a 401 * negative error code in case of failure. The caller has to have the 402 * @ubi->device_mutex locked. 403 */ 404int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs) 405{ 406 int i, err, pebs; 407 struct ubi_volume *vol = desc->vol; 408 struct ubi_device *ubi = vol->ubi; 409 struct ubi_vtbl_record vtbl_rec; 410 struct ubi_eba_table *new_eba_tbl = NULL; 411 int vol_id = vol->vol_id; 412 413 if (ubi->ro_mode) 414 return -EROFS; 415 416 dbg_gen("re-size device %d, volume %d to from %d to %d PEBs", 417 ubi->ubi_num, vol_id, vol->reserved_pebs, reserved_pebs); 418 419 if (vol->vol_type == UBI_STATIC_VOLUME && 420 reserved_pebs < vol->used_ebs) { 421 ubi_err(ubi, "too small size %d, %d LEBs contain data", 422 reserved_pebs, vol->used_ebs); 423 return -EINVAL; 424 } 425 426 /* If the size is the same, we have nothing to do */ 427 if (reserved_pebs == vol->reserved_pebs) 428 return 0; 429 430 new_eba_tbl = ubi_eba_create_table(vol, reserved_pebs); 431 if (IS_ERR(new_eba_tbl)) 432 return PTR_ERR(new_eba_tbl); 433 434 spin_lock(&ubi->volumes_lock); 435 if (vol->ref_count > 1) { 436 spin_unlock(&ubi->volumes_lock); 437 err = -EBUSY; 438 goto out_free; 439 } 440 spin_unlock(&ubi->volumes_lock); 441 442 /* Reserve physical eraseblocks */ 443 pebs = reserved_pebs - vol->reserved_pebs; 444 if (pebs > 0) { 445 spin_lock(&ubi->volumes_lock); 446 if (pebs > ubi->avail_pebs) { 447 ubi_err(ubi, "not enough PEBs: requested %d, available %d", 448 pebs, ubi->avail_pebs); 449 if (ubi->corr_peb_count) 450 ubi_err(ubi, "%d PEBs are corrupted and not used", 451 ubi->corr_peb_count); 452 spin_unlock(&ubi->volumes_lock); 453 err = -ENOSPC; 454 goto out_free; 455 } 456 ubi->avail_pebs -= pebs; 457 ubi->rsvd_pebs += pebs; 458 ubi_eba_copy_table(vol, new_eba_tbl, vol->reserved_pebs); 459 ubi_eba_replace_table(vol, new_eba_tbl); 460 spin_unlock(&ubi->volumes_lock); 461 } 462 463 if (pebs < 0) { 464 for (i = 0; i < -pebs; i++) { 465 err = ubi_eba_unmap_leb(ubi, vol, reserved_pebs + i); 466 if (err) 467 goto out_free; 468 } 469 spin_lock(&ubi->volumes_lock); 470 ubi->rsvd_pebs += pebs; 471 ubi->avail_pebs -= pebs; 472 ubi_update_reserved(ubi); 473 ubi_eba_copy_table(vol, new_eba_tbl, reserved_pebs); 474 ubi_eba_replace_table(vol, new_eba_tbl); 475 spin_unlock(&ubi->volumes_lock); 476 } 477 478 /* 479 * When we shrink a volume we have to flush all pending (erase) work. 480 * Otherwise it can happen that upon next attach UBI finds a LEB with 481 * lnum > highest_lnum and refuses to attach. 482 */ 483 if (pebs < 0) { 484 err = ubi_wl_flush(ubi, vol_id, UBI_ALL); 485 if (err) 486 goto out_acc; 487 } 488 489 /* Change volume table record */ 490 vtbl_rec = ubi->vtbl[vol_id]; 491 vtbl_rec.reserved_pebs = cpu_to_be32(reserved_pebs); 492 err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec); 493 if (err) 494 goto out_acc; 495 496 vol->reserved_pebs = reserved_pebs; 497 if (vol->vol_type == UBI_DYNAMIC_VOLUME) { 498 vol->used_ebs = reserved_pebs; 499 vol->last_eb_bytes = vol->usable_leb_size; 500 vol->used_bytes = 501 (long long)vol->used_ebs * vol->usable_leb_size; 502 } 503 504 ubi_volume_notify(ubi, vol, UBI_VOLUME_RESIZED); 505 self_check_volumes(ubi); 506 return err; 507 508out_acc: 509 if (pebs > 0) { 510 spin_lock(&ubi->volumes_lock); 511 ubi->rsvd_pebs -= pebs; 512 ubi->avail_pebs += pebs; 513 spin_unlock(&ubi->volumes_lock); 514 } 515 return err; 516 517out_free: 518 ubi_eba_destroy_table(new_eba_tbl); 519 return err; 520} 521 522/** 523 * ubi_rename_volumes - re-name UBI volumes. 524 * @ubi: UBI device description object 525 * @rename_list: list of &struct ubi_rename_entry objects 526 * 527 * This function re-names or removes volumes specified in the re-name list. 528 * Returns zero in case of success and a negative error code in case of 529 * failure. 530 */ 531int ubi_rename_volumes(struct ubi_device *ubi, struct list_head *rename_list) 532{ 533 int err; 534 struct ubi_rename_entry *re; 535 536 err = ubi_vtbl_rename_volumes(ubi, rename_list); 537 if (err) 538 return err; 539 540 list_for_each_entry(re, rename_list, list) { 541 if (re->remove) { 542 err = ubi_remove_volume(re->desc, 1); 543 if (err) 544 break; 545 } else { 546 struct ubi_volume *vol = re->desc->vol; 547 548 spin_lock(&ubi->volumes_lock); 549 vol->name_len = re->new_name_len; 550 memcpy(vol->name, re->new_name, re->new_name_len + 1); 551 spin_unlock(&ubi->volumes_lock); 552 ubi_volume_notify(ubi, vol, UBI_VOLUME_RENAMED); 553 } 554 } 555 556 if (!err) 557 self_check_volumes(ubi); 558 return err; 559} 560 561/** 562 * ubi_add_volume - add volume. 563 * @ubi: UBI device description object 564 * @vol: volume description object 565 * 566 * This function adds an existing volume and initializes all its data 567 * structures. Returns zero in case of success and a negative error code in 568 * case of failure. 569 */ 570int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol) 571{ 572 int err, vol_id = vol->vol_id; 573 dev_t dev; 574 575 dbg_gen("add volume %d", vol_id); 576 577 /* Register character device for the volume */ 578 cdev_init(&vol->cdev, &ubi_vol_cdev_operations); 579 vol->cdev.owner = THIS_MODULE; 580 dev = MKDEV(MAJOR(ubi->cdev.dev), vol->vol_id + 1); 581 err = cdev_add(&vol->cdev, dev, 1); 582 if (err) { 583 ubi_err(ubi, "cannot add character device for volume %d, error %d", 584 vol_id, err); 585 vol_release(&vol->dev); 586 return err; 587 } 588 589 vol->dev.release = vol_release; 590 vol->dev.parent = &ubi->dev; 591 vol->dev.devt = dev; 592 vol->dev.class = &ubi_class; 593 vol->dev.groups = volume_dev_groups; 594 dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id); 595 err = device_register(&vol->dev); 596 if (err) { 597 cdev_del(&vol->cdev); 598 put_device(&vol->dev); 599 return err; 600 } 601 602 self_check_volumes(ubi); 603 return err; 604} 605 606/** 607 * ubi_free_volume - free volume. 608 * @ubi: UBI device description object 609 * @vol: volume description object 610 * 611 * This function frees all resources for volume @vol but does not remove it. 612 * Used only when the UBI device is detached. 613 */ 614void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol) 615{ 616 dbg_gen("free volume %d", vol->vol_id); 617 618 ubi->volumes[vol->vol_id] = NULL; 619 cdev_del(&vol->cdev); 620 device_unregister(&vol->dev); 621} 622 623/** 624 * self_check_volume - check volume information. 625 * @ubi: UBI device description object 626 * @vol_id: volume ID 627 * 628 * Returns zero if volume is all right and a negative error code if not. 629 */ 630static int self_check_volume(struct ubi_device *ubi, int vol_id) 631{ 632 int idx = vol_id2idx(ubi, vol_id); 633 int reserved_pebs, alignment, data_pad, vol_type, name_len, upd_marker; 634 const struct ubi_volume *vol; 635 long long n; 636 const char *name; 637 638 spin_lock(&ubi->volumes_lock); 639 reserved_pebs = be32_to_cpu(ubi->vtbl[vol_id].reserved_pebs); 640 vol = ubi->volumes[idx]; 641 642 if (!vol) { 643 if (reserved_pebs) { 644 ubi_err(ubi, "no volume info, but volume exists"); 645 goto fail; 646 } 647 spin_unlock(&ubi->volumes_lock); 648 return 0; 649 } 650 651 if (vol->reserved_pebs < 0 || vol->alignment < 0 || vol->data_pad < 0 || 652 vol->name_len < 0) { 653 ubi_err(ubi, "negative values"); 654 goto fail; 655 } 656 if (vol->alignment > ubi->leb_size || vol->alignment == 0) { 657 ubi_err(ubi, "bad alignment"); 658 goto fail; 659 } 660 661 n = vol->alignment & (ubi->min_io_size - 1); 662 if (vol->alignment != 1 && n) { 663 ubi_err(ubi, "alignment is not multiple of min I/O unit"); 664 goto fail; 665 } 666 667 n = ubi->leb_size % vol->alignment; 668 if (vol->data_pad != n) { 669 ubi_err(ubi, "bad data_pad, has to be %lld", n); 670 goto fail; 671 } 672 673 if (vol->vol_type != UBI_DYNAMIC_VOLUME && 674 vol->vol_type != UBI_STATIC_VOLUME) { 675 ubi_err(ubi, "bad vol_type"); 676 goto fail; 677 } 678 679 if (vol->upd_marker && vol->corrupted) { 680 ubi_err(ubi, "update marker and corrupted simultaneously"); 681 goto fail; 682 } 683 684 if (vol->reserved_pebs > ubi->good_peb_count) { 685 ubi_err(ubi, "too large reserved_pebs"); 686 goto fail; 687 } 688 689 n = ubi->leb_size - vol->data_pad; 690 if (vol->usable_leb_size != ubi->leb_size - vol->data_pad) { 691 ubi_err(ubi, "bad usable_leb_size, has to be %lld", n); 692 goto fail; 693 } 694 695 if (vol->name_len > UBI_VOL_NAME_MAX) { 696 ubi_err(ubi, "too long volume name, max is %d", 697 UBI_VOL_NAME_MAX); 698 goto fail; 699 } 700 701 n = strnlen(vol->name, vol->name_len + 1); 702 if (n != vol->name_len) { 703 ubi_err(ubi, "bad name_len %lld", n); 704 goto fail; 705 } 706 707 n = (long long)vol->used_ebs * vol->usable_leb_size; 708 if (vol->vol_type == UBI_DYNAMIC_VOLUME) { 709 if (vol->corrupted) { 710 ubi_err(ubi, "corrupted dynamic volume"); 711 goto fail; 712 } 713 if (vol->used_ebs != vol->reserved_pebs) { 714 ubi_err(ubi, "bad used_ebs"); 715 goto fail; 716 } 717 if (vol->last_eb_bytes != vol->usable_leb_size) { 718 ubi_err(ubi, "bad last_eb_bytes"); 719 goto fail; 720 } 721 if (vol->used_bytes != n) { 722 ubi_err(ubi, "bad used_bytes"); 723 goto fail; 724 } 725 726 if (vol->skip_check) { 727 ubi_err(ubi, "bad skip_check"); 728 goto fail; 729 } 730 } else { 731 if (vol->used_ebs < 0 || vol->used_ebs > vol->reserved_pebs) { 732 ubi_err(ubi, "bad used_ebs"); 733 goto fail; 734 } 735 if (vol->last_eb_bytes < 0 || 736 vol->last_eb_bytes > vol->usable_leb_size) { 737 ubi_err(ubi, "bad last_eb_bytes"); 738 goto fail; 739 } 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"); 743 goto fail; 744 } 745 } 746 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; 754 else 755 vol_type = UBI_STATIC_VOLUME; 756 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"); 761 goto fail; 762 } 763 764 spin_unlock(&ubi->volumes_lock); 765 return 0; 766 767fail: 768 ubi_err(ubi, "self-check failed for volume %d", vol_id); 769 if (vol) 770 ubi_dump_vol_info(vol); 771 ubi_dump_vtbl_record(&ubi->vtbl[vol_id], vol_id); 772 dump_stack(); 773 spin_unlock(&ubi->volumes_lock); 774 return -EINVAL; 775} 776 777/** 778 * self_check_volumes - check information about all volumes. 779 * @ubi: UBI device description object 780 * 781 * Returns zero if volumes are all right and a negative error code if not. 782 */ 783static int self_check_volumes(struct ubi_device *ubi) 784{ 785 int i, err = 0; 786 787 if (!ubi_dbg_chk_gen(ubi)) 788 return 0; 789 790 for (i = 0; i < ubi->vtbl_slots; i++) { 791 err = self_check_volume(ubi, i); 792 if (err) 793 break; 794 } 795 796 return err; 797} 798