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