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