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