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 struct ubi_eba_table *old_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 458 ubi->avail_pebs -= pebs; 459 ubi->rsvd_pebs += pebs; 460 ubi_eba_copy_table(vol, new_eba_tbl, vol->reserved_pebs); 461 old_eba_tbl = vol->eba_tbl; 462 vol->eba_tbl = new_eba_tbl; 463 vol->reserved_pebs = reserved_pebs; 464 spin_unlock(&ubi->volumes_lock); 465 } 466 467 if (pebs < 0) { 468 for (i = 0; i < -pebs; i++) { 469 err = ubi_eba_unmap_leb(ubi, vol, reserved_pebs + i); 470 if (err) 471 goto out_free; 472 } 473 spin_lock(&ubi->volumes_lock); 474 ubi->rsvd_pebs += pebs; 475 ubi->avail_pebs -= pebs; 476 ubi_update_reserved(ubi); 477 ubi_eba_copy_table(vol, new_eba_tbl, reserved_pebs); 478 old_eba_tbl = vol->eba_tbl; 479 vol->eba_tbl = new_eba_tbl; 480 vol->reserved_pebs = reserved_pebs; 481 spin_unlock(&ubi->volumes_lock); 482 } 483 484 /* 485 * When we shrink a volume we have to flush all pending (erase) work. 486 * Otherwise it can happen that upon next attach UBI finds a LEB with 487 * lnum > highest_lnum and refuses to attach. 488 */ 489 if (pebs < 0) { 490 err = ubi_wl_flush(ubi, vol_id, UBI_ALL); 491 if (err) 492 goto out_acc; 493 } 494 495 /* Change volume table record */ 496 vtbl_rec = ubi->vtbl[vol_id]; 497 vtbl_rec.reserved_pebs = cpu_to_be32(reserved_pebs); 498 err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec); 499 if (err) 500 goto out_acc; 501 502 if (vol->vol_type == UBI_DYNAMIC_VOLUME) { 503 vol->used_ebs = reserved_pebs; 504 vol->last_eb_bytes = vol->usable_leb_size; 505 vol->used_bytes = 506 (long long)vol->used_ebs * vol->usable_leb_size; 507 } 508 /* destroy old table */ 509 ubi_eba_destroy_table(old_eba_tbl); 510 ubi_volume_notify(ubi, vol, UBI_VOLUME_RESIZED); 511 self_check_volumes(ubi); 512 return err; 513 514out_acc: 515 spin_lock(&ubi->volumes_lock); 516 vol->reserved_pebs = reserved_pebs - pebs; 517 if (pebs > 0) { 518 ubi->rsvd_pebs -= pebs; 519 ubi->avail_pebs += pebs; 520 ubi_eba_copy_table(vol, old_eba_tbl, vol->reserved_pebs); 521 } else { 522 ubi_eba_copy_table(vol, old_eba_tbl, reserved_pebs); 523 } 524 vol->eba_tbl = old_eba_tbl; 525 spin_unlock(&ubi->volumes_lock); 526out_free: 527 ubi_eba_destroy_table(new_eba_tbl); 528 return err; 529} 530 531/** 532 * ubi_rename_volumes - re-name UBI volumes. 533 * @ubi: UBI device description object 534 * @rename_list: list of &struct ubi_rename_entry objects 535 * 536 * This function re-names or removes volumes specified in the re-name list. 537 * Returns zero in case of success and a negative error code in case of 538 * failure. 539 */ 540int ubi_rename_volumes(struct ubi_device *ubi, struct list_head *rename_list) 541{ 542 int err; 543 struct ubi_rename_entry *re; 544 545 err = ubi_vtbl_rename_volumes(ubi, rename_list); 546 if (err) 547 return err; 548 549 list_for_each_entry(re, rename_list, list) { 550 if (re->remove) { 551 err = ubi_remove_volume(re->desc, 1); 552 if (err) 553 break; 554 } else { 555 struct ubi_volume *vol = re->desc->vol; 556 557 spin_lock(&ubi->volumes_lock); 558 vol->name_len = re->new_name_len; 559 memcpy(vol->name, re->new_name, re->new_name_len + 1); 560 spin_unlock(&ubi->volumes_lock); 561 ubi_volume_notify(ubi, vol, UBI_VOLUME_RENAMED); 562 } 563 } 564 565 if (!err) 566 self_check_volumes(ubi); 567 return err; 568} 569 570/** 571 * ubi_add_volume - add volume. 572 * @ubi: UBI device description object 573 * @vol: volume description object 574 * 575 * This function adds an existing volume and initializes all its data 576 * structures. Returns zero in case of success and a negative error code in 577 * case of failure. 578 */ 579int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol) 580{ 581 int err, vol_id = vol->vol_id; 582 dev_t dev; 583 584 dbg_gen("add volume %d", vol_id); 585 586 /* Register character device for the volume */ 587 cdev_init(&vol->cdev, &ubi_vol_cdev_operations); 588 vol->cdev.owner = THIS_MODULE; 589 dev = MKDEV(MAJOR(ubi->cdev.dev), vol->vol_id + 1); 590 err = cdev_add(&vol->cdev, dev, 1); 591 if (err) { 592 ubi_err(ubi, "cannot add character device for volume %d, error %d", 593 vol_id, err); 594 vol_release(&vol->dev); 595 return err; 596 } 597 598 vol->dev.release = vol_release; 599 vol->dev.parent = &ubi->dev; 600 vol->dev.devt = dev; 601 vol->dev.class = &ubi_class; 602 vol->dev.groups = volume_dev_groups; 603 dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id); 604 err = device_register(&vol->dev); 605 if (err) { 606 cdev_del(&vol->cdev); 607 put_device(&vol->dev); 608 return err; 609 } 610 611 self_check_volumes(ubi); 612 return err; 613} 614 615/** 616 * ubi_free_volume - free volume. 617 * @ubi: UBI device description object 618 * @vol: volume description object 619 * 620 * This function frees all resources for volume @vol but does not remove it. 621 * Used only when the UBI device is detached. 622 */ 623void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol) 624{ 625 dbg_gen("free volume %d", vol->vol_id); 626 627 ubi->volumes[vol->vol_id] = NULL; 628 cdev_del(&vol->cdev); 629 device_unregister(&vol->dev); 630} 631 632/** 633 * self_check_volume - check volume information. 634 * @ubi: UBI device description object 635 * @vol_id: volume ID 636 * 637 * Returns zero if volume is all right and a a negative error code if not. 638 */ 639static int self_check_volume(struct ubi_device *ubi, int vol_id) 640{ 641 int idx = vol_id2idx(ubi, vol_id); 642 int reserved_pebs, alignment, data_pad, vol_type, name_len, upd_marker; 643 const struct ubi_volume *vol; 644 long long n; 645 const char *name; 646 647 spin_lock(&ubi->volumes_lock); 648 reserved_pebs = be32_to_cpu(ubi->vtbl[vol_id].reserved_pebs); 649 vol = ubi->volumes[idx]; 650 651 if (!vol) { 652 if (reserved_pebs) { 653 ubi_err(ubi, "no volume info, but volume exists"); 654 goto fail; 655 } 656 spin_unlock(&ubi->volumes_lock); 657 return 0; 658 } 659 660 if (vol->reserved_pebs < 0 || vol->alignment < 0 || vol->data_pad < 0 || 661 vol->name_len < 0) { 662 ubi_err(ubi, "negative values"); 663 goto fail; 664 } 665 if (vol->alignment > ubi->leb_size || vol->alignment == 0) { 666 ubi_err(ubi, "bad alignment"); 667 goto fail; 668 } 669 670 n = vol->alignment & (ubi->min_io_size - 1); 671 if (vol->alignment != 1 && n) { 672 ubi_err(ubi, "alignment is not multiple of min I/O unit"); 673 goto fail; 674 } 675 676 n = ubi->leb_size % vol->alignment; 677 if (vol->data_pad != n) { 678 ubi_err(ubi, "bad data_pad, has to be %lld", n); 679 goto fail; 680 } 681 682 if (vol->vol_type != UBI_DYNAMIC_VOLUME && 683 vol->vol_type != UBI_STATIC_VOLUME) { 684 ubi_err(ubi, "bad vol_type"); 685 goto fail; 686 } 687 688 if (vol->upd_marker && vol->corrupted) { 689 ubi_err(ubi, "update marker and corrupted simultaneously"); 690 goto fail; 691 } 692 693 if (vol->reserved_pebs > ubi->good_peb_count) { 694 ubi_err(ubi, "too large reserved_pebs"); 695 goto fail; 696 } 697 698 n = ubi->leb_size - vol->data_pad; 699 if (vol->usable_leb_size != ubi->leb_size - vol->data_pad) { 700 ubi_err(ubi, "bad usable_leb_size, has to be %lld", n); 701 goto fail; 702 } 703 704 if (vol->name_len > UBI_VOL_NAME_MAX) { 705 ubi_err(ubi, "too long volume name, max is %d", 706 UBI_VOL_NAME_MAX); 707 goto fail; 708 } 709 710 n = strnlen(vol->name, vol->name_len + 1); 711 if (n != vol->name_len) { 712 ubi_err(ubi, "bad name_len %lld", n); 713 goto fail; 714 } 715 716 n = (long long)vol->used_ebs * vol->usable_leb_size; 717 if (vol->vol_type == UBI_DYNAMIC_VOLUME) { 718 if (vol->corrupted) { 719 ubi_err(ubi, "corrupted dynamic volume"); 720 goto fail; 721 } 722 if (vol->used_ebs != vol->reserved_pebs) { 723 ubi_err(ubi, "bad used_ebs"); 724 goto fail; 725 } 726 if (vol->last_eb_bytes != vol->usable_leb_size) { 727 ubi_err(ubi, "bad last_eb_bytes"); 728 goto fail; 729 } 730 if (vol->used_bytes != n) { 731 ubi_err(ubi, "bad used_bytes"); 732 goto fail; 733 } 734 735 if (vol->skip_check) { 736 ubi_err(ubi, "bad skip_check"); 737 goto fail; 738 } 739 } else { 740 if (vol->used_ebs < 0 || vol->used_ebs > vol->reserved_pebs) { 741 ubi_err(ubi, "bad used_ebs"); 742 goto fail; 743 } 744 if (vol->last_eb_bytes < 0 || 745 vol->last_eb_bytes > vol->usable_leb_size) { 746 ubi_err(ubi, "bad last_eb_bytes"); 747 goto fail; 748 } 749 if (vol->used_bytes < 0 || vol->used_bytes > n || 750 vol->used_bytes < n - vol->usable_leb_size) { 751 ubi_err(ubi, "bad used_bytes"); 752 goto fail; 753 } 754 } 755 756 alignment = be32_to_cpu(ubi->vtbl[vol_id].alignment); 757 data_pad = be32_to_cpu(ubi->vtbl[vol_id].data_pad); 758 name_len = be16_to_cpu(ubi->vtbl[vol_id].name_len); 759 upd_marker = ubi->vtbl[vol_id].upd_marker; 760 name = &ubi->vtbl[vol_id].name[0]; 761 if (ubi->vtbl[vol_id].vol_type == UBI_VID_DYNAMIC) 762 vol_type = UBI_DYNAMIC_VOLUME; 763 else 764 vol_type = UBI_STATIC_VOLUME; 765 766 if (alignment != vol->alignment || data_pad != vol->data_pad || 767 upd_marker != vol->upd_marker || vol_type != vol->vol_type || 768 name_len != vol->name_len || strncmp(name, vol->name, name_len)) { 769 ubi_err(ubi, "volume info is different"); 770 goto fail; 771 } 772 773 spin_unlock(&ubi->volumes_lock); 774 return 0; 775 776fail: 777 ubi_err(ubi, "self-check failed for volume %d", vol_id); 778 if (vol) 779 ubi_dump_vol_info(vol); 780 ubi_dump_vtbl_record(&ubi->vtbl[vol_id], vol_id); 781 dump_stack(); 782 spin_unlock(&ubi->volumes_lock); 783 return -EINVAL; 784} 785 786/** 787 * self_check_volumes - check information about all volumes. 788 * @ubi: UBI device description object 789 * 790 * Returns zero if volumes are all right and a a negative error code if not. 791 */ 792static int self_check_volumes(struct ubi_device *ubi) 793{ 794 int i, err = 0; 795 796 if (!ubi_dbg_chk_gen(ubi)) 797 return 0; 798 799 for (i = 0; i < ubi->vtbl_slots; i++) { 800 err = self_check_volume(ubi, i); 801 if (err) 802 break; 803 } 804 805 return err; 806} 807