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 includes implementation of UBI character device operations. 23 * 24 * There are two kinds of character devices in UBI: UBI character devices and 25 * UBI volume character devices. UBI character devices allow users to 26 * manipulate whole volumes: create, remove, and re-size them. Volume character 27 * devices provide volume I/O capabilities. 28 * 29 * Major and minor numbers are assigned dynamically to both UBI and volume 30 * character devices. 31 * 32 * Well, there is the third kind of character devices - the UBI control 33 * character device, which allows to manipulate by UBI devices - create and 34 * delete them. In other words, it is used for attaching and detaching MTD 35 * devices. 36 */ 37 38 #include <linux/module.h> 39 #include <linux/stat.h> 40 #include <linux/slab.h> 41 #include <linux/ioctl.h> 42 #include <linux/capability.h> 43 #include <linux/uaccess.h> 44 #include <linux/compat.h> 45 #include <linux/math64.h> 46 #include <mtd/ubi-user.h> 47 #include "ubi.h" 48 49 /** 50 * get_exclusive - get exclusive access to an UBI volume. 51 * @desc: volume descriptor 52 * 53 * This function changes UBI volume open mode to "exclusive". Returns previous 54 * mode value (positive integer) in case of success and a negative error code 55 * in case of failure. 56 */ 57 static int get_exclusive(struct ubi_volume_desc *desc) 58 { 59 int users, err; 60 struct ubi_volume *vol = desc->vol; 61 62 spin_lock(&vol->ubi->volumes_lock); 63 users = vol->readers + vol->writers + vol->exclusive; 64 ubi_assert(users > 0); 65 if (users > 1) { 66 ubi_err("%d users for volume %d", users, vol->vol_id); 67 err = -EBUSY; 68 } else { 69 vol->readers = vol->writers = 0; 70 vol->exclusive = 1; 71 err = desc->mode; 72 desc->mode = UBI_EXCLUSIVE; 73 } 74 spin_unlock(&vol->ubi->volumes_lock); 75 76 return err; 77 } 78 79 /** 80 * revoke_exclusive - revoke exclusive mode. 81 * @desc: volume descriptor 82 * @mode: new mode to switch to 83 */ 84 static void revoke_exclusive(struct ubi_volume_desc *desc, int mode) 85 { 86 struct ubi_volume *vol = desc->vol; 87 88 spin_lock(&vol->ubi->volumes_lock); 89 ubi_assert(vol->readers == 0 && vol->writers == 0); 90 ubi_assert(vol->exclusive == 1 && desc->mode == UBI_EXCLUSIVE); 91 vol->exclusive = 0; 92 if (mode == UBI_READONLY) 93 vol->readers = 1; 94 else if (mode == UBI_READWRITE) 95 vol->writers = 1; 96 else 97 vol->exclusive = 1; 98 spin_unlock(&vol->ubi->volumes_lock); 99 100 desc->mode = mode; 101 } 102 103 static int vol_cdev_open(struct inode *inode, struct file *file) 104 { 105 struct ubi_volume_desc *desc; 106 int vol_id = iminor(inode) - 1, mode, ubi_num; 107 108 ubi_num = ubi_major2num(imajor(inode)); 109 if (ubi_num < 0) 110 return ubi_num; 111 112 if (file->f_mode & FMODE_WRITE) 113 mode = UBI_READWRITE; 114 else 115 mode = UBI_READONLY; 116 117 dbg_gen("open device %d, volume %d, mode %d", 118 ubi_num, vol_id, mode); 119 120 desc = ubi_open_volume(ubi_num, vol_id, mode); 121 if (IS_ERR(desc)) 122 return PTR_ERR(desc); 123 124 file->private_data = desc; 125 return 0; 126 } 127 128 static int vol_cdev_release(struct inode *inode, struct file *file) 129 { 130 struct ubi_volume_desc *desc = file->private_data; 131 struct ubi_volume *vol = desc->vol; 132 133 dbg_gen("release device %d, volume %d, mode %d", 134 vol->ubi->ubi_num, vol->vol_id, desc->mode); 135 136 if (vol->updating) { 137 ubi_warn("update of volume %d not finished, volume is damaged", 138 vol->vol_id); 139 ubi_assert(!vol->changing_leb); 140 vol->updating = 0; 141 vfree(vol->upd_buf); 142 } else if (vol->changing_leb) { 143 dbg_gen("only %lld of %lld bytes received for atomic LEB change" 144 " for volume %d:%d, cancel", vol->upd_received, 145 vol->upd_bytes, vol->ubi->ubi_num, vol->vol_id); 146 vol->changing_leb = 0; 147 vfree(vol->upd_buf); 148 } 149 150 ubi_close_volume(desc); 151 return 0; 152 } 153 154 static loff_t vol_cdev_llseek(struct file *file, loff_t offset, int origin) 155 { 156 struct ubi_volume_desc *desc = file->private_data; 157 struct ubi_volume *vol = desc->vol; 158 loff_t new_offset; 159 160 if (vol->updating) { 161 /* Update is in progress, seeking is prohibited */ 162 ubi_err("updating"); 163 return -EBUSY; 164 } 165 166 switch (origin) { 167 case 0: /* SEEK_SET */ 168 new_offset = offset; 169 break; 170 case 1: /* SEEK_CUR */ 171 new_offset = file->f_pos + offset; 172 break; 173 case 2: /* SEEK_END */ 174 new_offset = vol->used_bytes + offset; 175 break; 176 default: 177 return -EINVAL; 178 } 179 180 if (new_offset < 0 || new_offset > vol->used_bytes) { 181 ubi_err("bad seek %lld", new_offset); 182 return -EINVAL; 183 } 184 185 dbg_gen("seek volume %d, offset %lld, origin %d, new offset %lld", 186 vol->vol_id, offset, origin, new_offset); 187 188 file->f_pos = new_offset; 189 return new_offset; 190 } 191 192 static int vol_cdev_fsync(struct file *file, loff_t start, loff_t end, int datasync) 193 { 194 struct ubi_volume_desc *desc = file->private_data; 195 struct ubi_device *ubi = desc->vol->ubi; 196 struct inode *inode = file->f_path.dentry->d_inode; 197 int err; 198 mutex_lock(&inode->i_mutex); 199 err = ubi_sync(ubi->ubi_num); 200 mutex_unlock(&inode->i_mutex); 201 return err; 202 } 203 204 205 static ssize_t vol_cdev_read(struct file *file, __user char *buf, size_t count, 206 loff_t *offp) 207 { 208 struct ubi_volume_desc *desc = file->private_data; 209 struct ubi_volume *vol = desc->vol; 210 struct ubi_device *ubi = vol->ubi; 211 int err, lnum, off, len, tbuf_size; 212 size_t count_save = count; 213 void *tbuf; 214 215 dbg_gen("read %zd bytes from offset %lld of volume %d", 216 count, *offp, vol->vol_id); 217 218 if (vol->updating) { 219 ubi_err("updating"); 220 return -EBUSY; 221 } 222 if (vol->upd_marker) { 223 ubi_err("damaged volume, update marker is set"); 224 return -EBADF; 225 } 226 if (*offp == vol->used_bytes || count == 0) 227 return 0; 228 229 if (vol->corrupted) 230 dbg_gen("read from corrupted volume %d", vol->vol_id); 231 232 if (*offp + count > vol->used_bytes) 233 count_save = count = vol->used_bytes - *offp; 234 235 tbuf_size = vol->usable_leb_size; 236 if (count < tbuf_size) 237 tbuf_size = ALIGN(count, ubi->min_io_size); 238 tbuf = vmalloc(tbuf_size); 239 if (!tbuf) 240 return -ENOMEM; 241 242 len = count > tbuf_size ? tbuf_size : count; 243 lnum = div_u64_rem(*offp, vol->usable_leb_size, &off); 244 245 do { 246 cond_resched(); 247 248 if (off + len >= vol->usable_leb_size) 249 len = vol->usable_leb_size - off; 250 251 err = ubi_eba_read_leb(ubi, vol, lnum, tbuf, off, len, 0); 252 if (err) 253 break; 254 255 off += len; 256 if (off == vol->usable_leb_size) { 257 lnum += 1; 258 off -= vol->usable_leb_size; 259 } 260 261 count -= len; 262 *offp += len; 263 264 err = copy_to_user(buf, tbuf, len); 265 if (err) { 266 err = -EFAULT; 267 break; 268 } 269 270 buf += len; 271 len = count > tbuf_size ? tbuf_size : count; 272 } while (count); 273 274 vfree(tbuf); 275 return err ? err : count_save - count; 276 } 277 278 /* 279 * This function allows to directly write to dynamic UBI volumes, without 280 * issuing the volume update operation. 281 */ 282 static ssize_t vol_cdev_direct_write(struct file *file, const char __user *buf, 283 size_t count, loff_t *offp) 284 { 285 struct ubi_volume_desc *desc = file->private_data; 286 struct ubi_volume *vol = desc->vol; 287 struct ubi_device *ubi = vol->ubi; 288 int lnum, off, len, tbuf_size, err = 0; 289 size_t count_save = count; 290 char *tbuf; 291 292 if (!vol->direct_writes) 293 return -EPERM; 294 295 dbg_gen("requested: write %zd bytes to offset %lld of volume %u", 296 count, *offp, vol->vol_id); 297 298 if (vol->vol_type == UBI_STATIC_VOLUME) 299 return -EROFS; 300 301 lnum = div_u64_rem(*offp, vol->usable_leb_size, &off); 302 if (off & (ubi->min_io_size - 1)) { 303 ubi_err("unaligned position"); 304 return -EINVAL; 305 } 306 307 if (*offp + count > vol->used_bytes) 308 count_save = count = vol->used_bytes - *offp; 309 310 /* We can write only in fractions of the minimum I/O unit */ 311 if (count & (ubi->min_io_size - 1)) { 312 ubi_err("unaligned write length"); 313 return -EINVAL; 314 } 315 316 tbuf_size = vol->usable_leb_size; 317 if (count < tbuf_size) 318 tbuf_size = ALIGN(count, ubi->min_io_size); 319 tbuf = vmalloc(tbuf_size); 320 if (!tbuf) 321 return -ENOMEM; 322 323 len = count > tbuf_size ? tbuf_size : count; 324 325 while (count) { 326 cond_resched(); 327 328 if (off + len >= vol->usable_leb_size) 329 len = vol->usable_leb_size - off; 330 331 err = copy_from_user(tbuf, buf, len); 332 if (err) { 333 err = -EFAULT; 334 break; 335 } 336 337 err = ubi_eba_write_leb(ubi, vol, lnum, tbuf, off, len); 338 if (err) 339 break; 340 341 off += len; 342 if (off == vol->usable_leb_size) { 343 lnum += 1; 344 off -= vol->usable_leb_size; 345 } 346 347 count -= len; 348 *offp += len; 349 buf += len; 350 len = count > tbuf_size ? tbuf_size : count; 351 } 352 353 vfree(tbuf); 354 return err ? err : count_save - count; 355 } 356 357 static ssize_t vol_cdev_write(struct file *file, const char __user *buf, 358 size_t count, loff_t *offp) 359 { 360 int err = 0; 361 struct ubi_volume_desc *desc = file->private_data; 362 struct ubi_volume *vol = desc->vol; 363 struct ubi_device *ubi = vol->ubi; 364 365 if (!vol->updating && !vol->changing_leb) 366 return vol_cdev_direct_write(file, buf, count, offp); 367 368 if (vol->updating) 369 err = ubi_more_update_data(ubi, vol, buf, count); 370 else 371 err = ubi_more_leb_change_data(ubi, vol, buf, count); 372 373 if (err < 0) { 374 ubi_err("cannot accept more %zd bytes of data, error %d", 375 count, err); 376 return err; 377 } 378 379 if (err) { 380 /* 381 * The operation is finished, @err contains number of actually 382 * written bytes. 383 */ 384 count = err; 385 386 if (vol->changing_leb) { 387 revoke_exclusive(desc, UBI_READWRITE); 388 return count; 389 } 390 391 err = ubi_check_volume(ubi, vol->vol_id); 392 if (err < 0) 393 return err; 394 395 if (err) { 396 ubi_warn("volume %d on UBI device %d is corrupted", 397 vol->vol_id, ubi->ubi_num); 398 vol->corrupted = 1; 399 } 400 vol->checked = 1; 401 ubi_volume_notify(ubi, vol, UBI_VOLUME_UPDATED); 402 revoke_exclusive(desc, UBI_READWRITE); 403 } 404 405 return count; 406 } 407 408 static long vol_cdev_ioctl(struct file *file, unsigned int cmd, 409 unsigned long arg) 410 { 411 int err = 0; 412 struct ubi_volume_desc *desc = file->private_data; 413 struct ubi_volume *vol = desc->vol; 414 struct ubi_device *ubi = vol->ubi; 415 void __user *argp = (void __user *)arg; 416 417 switch (cmd) { 418 /* Volume update command */ 419 case UBI_IOCVOLUP: 420 { 421 int64_t bytes, rsvd_bytes; 422 423 if (!capable(CAP_SYS_RESOURCE)) { 424 err = -EPERM; 425 break; 426 } 427 428 err = copy_from_user(&bytes, argp, sizeof(int64_t)); 429 if (err) { 430 err = -EFAULT; 431 break; 432 } 433 434 if (desc->mode == UBI_READONLY) { 435 err = -EROFS; 436 break; 437 } 438 439 rsvd_bytes = (long long)vol->reserved_pebs * 440 ubi->leb_size-vol->data_pad; 441 if (bytes < 0 || bytes > rsvd_bytes) { 442 err = -EINVAL; 443 break; 444 } 445 446 err = get_exclusive(desc); 447 if (err < 0) 448 break; 449 450 err = ubi_start_update(ubi, vol, bytes); 451 if (bytes == 0) 452 revoke_exclusive(desc, UBI_READWRITE); 453 break; 454 } 455 456 /* Atomic logical eraseblock change command */ 457 case UBI_IOCEBCH: 458 { 459 struct ubi_leb_change_req req; 460 461 err = copy_from_user(&req, argp, 462 sizeof(struct ubi_leb_change_req)); 463 if (err) { 464 err = -EFAULT; 465 break; 466 } 467 468 if (desc->mode == UBI_READONLY || 469 vol->vol_type == UBI_STATIC_VOLUME) { 470 err = -EROFS; 471 break; 472 } 473 474 /* Validate the request */ 475 err = -EINVAL; 476 if (req.lnum < 0 || req.lnum >= vol->reserved_pebs || 477 req.bytes < 0 || req.lnum >= vol->usable_leb_size) 478 break; 479 480 err = get_exclusive(desc); 481 if (err < 0) 482 break; 483 484 err = ubi_start_leb_change(ubi, vol, &req); 485 if (req.bytes == 0) 486 revoke_exclusive(desc, UBI_READWRITE); 487 break; 488 } 489 490 /* Logical eraseblock erasure command */ 491 case UBI_IOCEBER: 492 { 493 int32_t lnum; 494 495 err = get_user(lnum, (__user int32_t *)argp); 496 if (err) { 497 err = -EFAULT; 498 break; 499 } 500 501 if (desc->mode == UBI_READONLY || 502 vol->vol_type == UBI_STATIC_VOLUME) { 503 err = -EROFS; 504 break; 505 } 506 507 if (lnum < 0 || lnum >= vol->reserved_pebs) { 508 err = -EINVAL; 509 break; 510 } 511 512 dbg_gen("erase LEB %d:%d", vol->vol_id, lnum); 513 err = ubi_eba_unmap_leb(ubi, vol, lnum); 514 if (err) 515 break; 516 517 err = ubi_wl_flush(ubi, UBI_ALL, UBI_ALL); 518 break; 519 } 520 521 /* Logical eraseblock map command */ 522 case UBI_IOCEBMAP: 523 { 524 struct ubi_map_req req; 525 526 err = copy_from_user(&req, argp, sizeof(struct ubi_map_req)); 527 if (err) { 528 err = -EFAULT; 529 break; 530 } 531 err = ubi_leb_map(desc, req.lnum); 532 break; 533 } 534 535 /* Logical eraseblock un-map command */ 536 case UBI_IOCEBUNMAP: 537 { 538 int32_t lnum; 539 540 err = get_user(lnum, (__user int32_t *)argp); 541 if (err) { 542 err = -EFAULT; 543 break; 544 } 545 err = ubi_leb_unmap(desc, lnum); 546 break; 547 } 548 549 /* Check if logical eraseblock is mapped command */ 550 case UBI_IOCEBISMAP: 551 { 552 int32_t lnum; 553 554 err = get_user(lnum, (__user int32_t *)argp); 555 if (err) { 556 err = -EFAULT; 557 break; 558 } 559 err = ubi_is_mapped(desc, lnum); 560 break; 561 } 562 563 /* Set volume property command */ 564 case UBI_IOCSETVOLPROP: 565 { 566 struct ubi_set_vol_prop_req req; 567 568 err = copy_from_user(&req, argp, 569 sizeof(struct ubi_set_vol_prop_req)); 570 if (err) { 571 err = -EFAULT; 572 break; 573 } 574 switch (req.property) { 575 case UBI_VOL_PROP_DIRECT_WRITE: 576 mutex_lock(&ubi->device_mutex); 577 desc->vol->direct_writes = !!req.value; 578 mutex_unlock(&ubi->device_mutex); 579 break; 580 default: 581 err = -EINVAL; 582 break; 583 } 584 break; 585 } 586 587 default: 588 err = -ENOTTY; 589 break; 590 } 591 return err; 592 } 593 594 /** 595 * verify_mkvol_req - verify volume creation request. 596 * @ubi: UBI device description object 597 * @req: the request to check 598 * 599 * This function zero if the request is correct, and %-EINVAL if not. 600 */ 601 static int verify_mkvol_req(const struct ubi_device *ubi, 602 const struct ubi_mkvol_req *req) 603 { 604 int n, err = -EINVAL; 605 606 if (req->bytes < 0 || req->alignment < 0 || req->vol_type < 0 || 607 req->name_len < 0) 608 goto bad; 609 610 if ((req->vol_id < 0 || req->vol_id >= ubi->vtbl_slots) && 611 req->vol_id != UBI_VOL_NUM_AUTO) 612 goto bad; 613 614 if (req->alignment == 0) 615 goto bad; 616 617 if (req->bytes == 0) 618 goto bad; 619 620 if (req->vol_type != UBI_DYNAMIC_VOLUME && 621 req->vol_type != UBI_STATIC_VOLUME) 622 goto bad; 623 624 if (req->alignment > ubi->leb_size) 625 goto bad; 626 627 n = req->alignment & (ubi->min_io_size - 1); 628 if (req->alignment != 1 && n) 629 goto bad; 630 631 if (!req->name[0] || !req->name_len) 632 goto bad; 633 634 if (req->name_len > UBI_VOL_NAME_MAX) { 635 err = -ENAMETOOLONG; 636 goto bad; 637 } 638 639 n = strnlen(req->name, req->name_len + 1); 640 if (n != req->name_len) 641 goto bad; 642 643 return 0; 644 645 bad: 646 ubi_err("bad volume creation request"); 647 ubi_dump_mkvol_req(req); 648 return err; 649 } 650 651 /** 652 * verify_rsvol_req - verify volume re-size request. 653 * @ubi: UBI device description object 654 * @req: the request to check 655 * 656 * This function returns zero if the request is correct, and %-EINVAL if not. 657 */ 658 static int verify_rsvol_req(const struct ubi_device *ubi, 659 const struct ubi_rsvol_req *req) 660 { 661 if (req->bytes <= 0) 662 return -EINVAL; 663 664 if (req->vol_id < 0 || req->vol_id >= ubi->vtbl_slots) 665 return -EINVAL; 666 667 return 0; 668 } 669 670 /** 671 * rename_volumes - rename UBI volumes. 672 * @ubi: UBI device description object 673 * @req: volumes re-name request 674 * 675 * This is a helper function for the volume re-name IOCTL which validates the 676 * the request, opens the volume and calls corresponding volumes management 677 * function. Returns zero in case of success and a negative error code in case 678 * of failure. 679 */ 680 static int rename_volumes(struct ubi_device *ubi, 681 struct ubi_rnvol_req *req) 682 { 683 int i, n, err; 684 struct list_head rename_list; 685 struct ubi_rename_entry *re, *re1; 686 687 if (req->count < 0 || req->count > UBI_MAX_RNVOL) 688 return -EINVAL; 689 690 if (req->count == 0) 691 return 0; 692 693 /* Validate volume IDs and names in the request */ 694 for (i = 0; i < req->count; i++) { 695 if (req->ents[i].vol_id < 0 || 696 req->ents[i].vol_id >= ubi->vtbl_slots) 697 return -EINVAL; 698 if (req->ents[i].name_len < 0) 699 return -EINVAL; 700 if (req->ents[i].name_len > UBI_VOL_NAME_MAX) 701 return -ENAMETOOLONG; 702 req->ents[i].name[req->ents[i].name_len] = '\0'; 703 n = strlen(req->ents[i].name); 704 if (n != req->ents[i].name_len) 705 err = -EINVAL; 706 } 707 708 /* Make sure volume IDs and names are unique */ 709 for (i = 0; i < req->count - 1; i++) { 710 for (n = i + 1; n < req->count; n++) { 711 if (req->ents[i].vol_id == req->ents[n].vol_id) { 712 ubi_err("duplicated volume id %d", 713 req->ents[i].vol_id); 714 return -EINVAL; 715 } 716 if (!strcmp(req->ents[i].name, req->ents[n].name)) { 717 ubi_err("duplicated volume name \"%s\"", 718 req->ents[i].name); 719 return -EINVAL; 720 } 721 } 722 } 723 724 /* Create the re-name list */ 725 INIT_LIST_HEAD(&rename_list); 726 for (i = 0; i < req->count; i++) { 727 int vol_id = req->ents[i].vol_id; 728 int name_len = req->ents[i].name_len; 729 const char *name = req->ents[i].name; 730 731 re = kzalloc(sizeof(struct ubi_rename_entry), GFP_KERNEL); 732 if (!re) { 733 err = -ENOMEM; 734 goto out_free; 735 } 736 737 re->desc = ubi_open_volume(ubi->ubi_num, vol_id, UBI_EXCLUSIVE); 738 if (IS_ERR(re->desc)) { 739 err = PTR_ERR(re->desc); 740 ubi_err("cannot open volume %d, error %d", vol_id, err); 741 kfree(re); 742 goto out_free; 743 } 744 745 /* Skip this re-naming if the name does not really change */ 746 if (re->desc->vol->name_len == name_len && 747 !memcmp(re->desc->vol->name, name, name_len)) { 748 ubi_close_volume(re->desc); 749 kfree(re); 750 continue; 751 } 752 753 re->new_name_len = name_len; 754 memcpy(re->new_name, name, name_len); 755 list_add_tail(&re->list, &rename_list); 756 dbg_msg("will rename volume %d from \"%s\" to \"%s\"", 757 vol_id, re->desc->vol->name, name); 758 } 759 760 if (list_empty(&rename_list)) 761 return 0; 762 763 /* Find out the volumes which have to be removed */ 764 list_for_each_entry(re, &rename_list, list) { 765 struct ubi_volume_desc *desc; 766 int no_remove_needed = 0; 767 768 /* 769 * Volume @re->vol_id is going to be re-named to 770 * @re->new_name, while its current name is @name. If a volume 771 * with name @re->new_name currently exists, it has to be 772 * removed, unless it is also re-named in the request (@req). 773 */ 774 list_for_each_entry(re1, &rename_list, list) { 775 if (re->new_name_len == re1->desc->vol->name_len && 776 !memcmp(re->new_name, re1->desc->vol->name, 777 re1->desc->vol->name_len)) { 778 no_remove_needed = 1; 779 break; 780 } 781 } 782 783 if (no_remove_needed) 784 continue; 785 786 /* 787 * It seems we need to remove volume with name @re->new_name, 788 * if it exists. 789 */ 790 desc = ubi_open_volume_nm(ubi->ubi_num, re->new_name, 791 UBI_EXCLUSIVE); 792 if (IS_ERR(desc)) { 793 err = PTR_ERR(desc); 794 if (err == -ENODEV) 795 /* Re-naming into a non-existing volume name */ 796 continue; 797 798 /* The volume exists but busy, or an error occurred */ 799 ubi_err("cannot open volume \"%s\", error %d", 800 re->new_name, err); 801 goto out_free; 802 } 803 804 re1 = kzalloc(sizeof(struct ubi_rename_entry), GFP_KERNEL); 805 if (!re1) { 806 err = -ENOMEM; 807 ubi_close_volume(desc); 808 goto out_free; 809 } 810 811 re1->remove = 1; 812 re1->desc = desc; 813 list_add(&re1->list, &rename_list); 814 dbg_msg("will remove volume %d, name \"%s\"", 815 re1->desc->vol->vol_id, re1->desc->vol->name); 816 } 817 818 mutex_lock(&ubi->device_mutex); 819 err = ubi_rename_volumes(ubi, &rename_list); 820 mutex_unlock(&ubi->device_mutex); 821 822 out_free: 823 list_for_each_entry_safe(re, re1, &rename_list, list) { 824 ubi_close_volume(re->desc); 825 list_del(&re->list); 826 kfree(re); 827 } 828 return err; 829 } 830 831 static long ubi_cdev_ioctl(struct file *file, unsigned int cmd, 832 unsigned long arg) 833 { 834 int err = 0; 835 struct ubi_device *ubi; 836 struct ubi_volume_desc *desc; 837 void __user *argp = (void __user *)arg; 838 839 if (!capable(CAP_SYS_RESOURCE)) 840 return -EPERM; 841 842 ubi = ubi_get_by_major(imajor(file->f_mapping->host)); 843 if (!ubi) 844 return -ENODEV; 845 846 switch (cmd) { 847 /* Create volume command */ 848 case UBI_IOCMKVOL: 849 { 850 struct ubi_mkvol_req req; 851 852 dbg_gen("create volume"); 853 err = copy_from_user(&req, argp, sizeof(struct ubi_mkvol_req)); 854 if (err) { 855 err = -EFAULT; 856 break; 857 } 858 859 err = verify_mkvol_req(ubi, &req); 860 if (err) 861 break; 862 863 mutex_lock(&ubi->device_mutex); 864 err = ubi_create_volume(ubi, &req); 865 mutex_unlock(&ubi->device_mutex); 866 if (err) 867 break; 868 869 err = put_user(req.vol_id, (__user int32_t *)argp); 870 if (err) 871 err = -EFAULT; 872 873 break; 874 } 875 876 /* Remove volume command */ 877 case UBI_IOCRMVOL: 878 { 879 int vol_id; 880 881 dbg_gen("remove volume"); 882 err = get_user(vol_id, (__user int32_t *)argp); 883 if (err) { 884 err = -EFAULT; 885 break; 886 } 887 888 desc = ubi_open_volume(ubi->ubi_num, vol_id, UBI_EXCLUSIVE); 889 if (IS_ERR(desc)) { 890 err = PTR_ERR(desc); 891 break; 892 } 893 894 mutex_lock(&ubi->device_mutex); 895 err = ubi_remove_volume(desc, 0); 896 mutex_unlock(&ubi->device_mutex); 897 898 /* 899 * The volume is deleted (unless an error occurred), and the 900 * 'struct ubi_volume' object will be freed when 901 * 'ubi_close_volume()' will call 'put_device()'. 902 */ 903 ubi_close_volume(desc); 904 break; 905 } 906 907 /* Re-size volume command */ 908 case UBI_IOCRSVOL: 909 { 910 int pebs; 911 struct ubi_rsvol_req req; 912 913 dbg_gen("re-size volume"); 914 err = copy_from_user(&req, argp, sizeof(struct ubi_rsvol_req)); 915 if (err) { 916 err = -EFAULT; 917 break; 918 } 919 920 err = verify_rsvol_req(ubi, &req); 921 if (err) 922 break; 923 924 desc = ubi_open_volume(ubi->ubi_num, req.vol_id, UBI_EXCLUSIVE); 925 if (IS_ERR(desc)) { 926 err = PTR_ERR(desc); 927 break; 928 } 929 930 pebs = div_u64(req.bytes + desc->vol->usable_leb_size - 1, 931 desc->vol->usable_leb_size); 932 933 mutex_lock(&ubi->device_mutex); 934 err = ubi_resize_volume(desc, pebs); 935 mutex_unlock(&ubi->device_mutex); 936 ubi_close_volume(desc); 937 break; 938 } 939 940 /* Re-name volumes command */ 941 case UBI_IOCRNVOL: 942 { 943 struct ubi_rnvol_req *req; 944 945 dbg_msg("re-name volumes"); 946 req = kmalloc(sizeof(struct ubi_rnvol_req), GFP_KERNEL); 947 if (!req) { 948 err = -ENOMEM; 949 break; 950 }; 951 952 err = copy_from_user(req, argp, sizeof(struct ubi_rnvol_req)); 953 if (err) { 954 err = -EFAULT; 955 kfree(req); 956 break; 957 } 958 959 err = rename_volumes(ubi, req); 960 kfree(req); 961 break; 962 } 963 964 default: 965 err = -ENOTTY; 966 break; 967 } 968 969 ubi_put_device(ubi); 970 return err; 971 } 972 973 static long ctrl_cdev_ioctl(struct file *file, unsigned int cmd, 974 unsigned long arg) 975 { 976 int err = 0; 977 void __user *argp = (void __user *)arg; 978 979 if (!capable(CAP_SYS_RESOURCE)) 980 return -EPERM; 981 982 switch (cmd) { 983 /* Attach an MTD device command */ 984 case UBI_IOCATT: 985 { 986 struct ubi_attach_req req; 987 struct mtd_info *mtd; 988 989 dbg_gen("attach MTD device"); 990 err = copy_from_user(&req, argp, sizeof(struct ubi_attach_req)); 991 if (err) { 992 err = -EFAULT; 993 break; 994 } 995 996 if (req.mtd_num < 0 || 997 (req.ubi_num < 0 && req.ubi_num != UBI_DEV_NUM_AUTO)) { 998 err = -EINVAL; 999 break; 1000 } 1001 1002 mtd = get_mtd_device(NULL, req.mtd_num); 1003 if (IS_ERR(mtd)) { 1004 err = PTR_ERR(mtd); 1005 break; 1006 } 1007 1008 /* 1009 * Note, further request verification is done by 1010 * 'ubi_attach_mtd_dev()'. 1011 */ 1012 mutex_lock(&ubi_devices_mutex); 1013 err = ubi_attach_mtd_dev(mtd, req.ubi_num, req.vid_hdr_offset); 1014 mutex_unlock(&ubi_devices_mutex); 1015 if (err < 0) 1016 put_mtd_device(mtd); 1017 else 1018 /* @err contains UBI device number */ 1019 err = put_user(err, (__user int32_t *)argp); 1020 1021 break; 1022 } 1023 1024 /* Detach an MTD device command */ 1025 case UBI_IOCDET: 1026 { 1027 int ubi_num; 1028 1029 dbg_gen("detach MTD device"); 1030 err = get_user(ubi_num, (__user int32_t *)argp); 1031 if (err) { 1032 err = -EFAULT; 1033 break; 1034 } 1035 1036 mutex_lock(&ubi_devices_mutex); 1037 err = ubi_detach_mtd_dev(ubi_num, 0); 1038 mutex_unlock(&ubi_devices_mutex); 1039 break; 1040 } 1041 1042 default: 1043 err = -ENOTTY; 1044 break; 1045 } 1046 1047 return err; 1048 } 1049 1050 #ifdef CONFIG_COMPAT 1051 static long vol_cdev_compat_ioctl(struct file *file, unsigned int cmd, 1052 unsigned long arg) 1053 { 1054 unsigned long translated_arg = (unsigned long)compat_ptr(arg); 1055 1056 return vol_cdev_ioctl(file, cmd, translated_arg); 1057 } 1058 1059 static long ubi_cdev_compat_ioctl(struct file *file, unsigned int cmd, 1060 unsigned long arg) 1061 { 1062 unsigned long translated_arg = (unsigned long)compat_ptr(arg); 1063 1064 return ubi_cdev_ioctl(file, cmd, translated_arg); 1065 } 1066 1067 static long ctrl_cdev_compat_ioctl(struct file *file, unsigned int cmd, 1068 unsigned long arg) 1069 { 1070 unsigned long translated_arg = (unsigned long)compat_ptr(arg); 1071 1072 return ctrl_cdev_ioctl(file, cmd, translated_arg); 1073 } 1074 #else 1075 #define vol_cdev_compat_ioctl NULL 1076 #define ubi_cdev_compat_ioctl NULL 1077 #define ctrl_cdev_compat_ioctl NULL 1078 #endif 1079 1080 /* UBI volume character device operations */ 1081 const struct file_operations ubi_vol_cdev_operations = { 1082 .owner = THIS_MODULE, 1083 .open = vol_cdev_open, 1084 .release = vol_cdev_release, 1085 .llseek = vol_cdev_llseek, 1086 .read = vol_cdev_read, 1087 .write = vol_cdev_write, 1088 .fsync = vol_cdev_fsync, 1089 .unlocked_ioctl = vol_cdev_ioctl, 1090 .compat_ioctl = vol_cdev_compat_ioctl, 1091 }; 1092 1093 /* UBI character device operations */ 1094 const struct file_operations ubi_cdev_operations = { 1095 .owner = THIS_MODULE, 1096 .llseek = no_llseek, 1097 .unlocked_ioctl = ubi_cdev_ioctl, 1098 .compat_ioctl = ubi_cdev_compat_ioctl, 1099 }; 1100 1101 /* UBI control character device operations */ 1102 const struct file_operations ubi_ctrl_cdev_operations = { 1103 .owner = THIS_MODULE, 1104 .unlocked_ioctl = ctrl_cdev_ioctl, 1105 .compat_ioctl = ctrl_cdev_compat_ioctl, 1106 .llseek = no_llseek, 1107 }; 1108