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 for volume %d:%d, cancel", 144 vol->upd_received, vol->upd_bytes, vol->ubi->ubi_num, 145 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 159 if (vol->updating) { 160 /* Update is in progress, seeking is prohibited */ 161 ubi_err("updating"); 162 return -EBUSY; 163 } 164 165 return fixed_size_llseek(file, offset, origin, vol->used_bytes); 166 } 167 168 static int vol_cdev_fsync(struct file *file, loff_t start, loff_t end, 169 int datasync) 170 { 171 struct ubi_volume_desc *desc = file->private_data; 172 struct ubi_device *ubi = desc->vol->ubi; 173 struct inode *inode = file_inode(file); 174 int err; 175 mutex_lock(&inode->i_mutex); 176 err = ubi_sync(ubi->ubi_num); 177 mutex_unlock(&inode->i_mutex); 178 return err; 179 } 180 181 182 static ssize_t vol_cdev_read(struct file *file, __user char *buf, size_t count, 183 loff_t *offp) 184 { 185 struct ubi_volume_desc *desc = file->private_data; 186 struct ubi_volume *vol = desc->vol; 187 struct ubi_device *ubi = vol->ubi; 188 int err, lnum, off, len, tbuf_size; 189 size_t count_save = count; 190 void *tbuf; 191 192 dbg_gen("read %zd bytes from offset %lld of volume %d", 193 count, *offp, vol->vol_id); 194 195 if (vol->updating) { 196 ubi_err("updating"); 197 return -EBUSY; 198 } 199 if (vol->upd_marker) { 200 ubi_err("damaged volume, update marker is set"); 201 return -EBADF; 202 } 203 if (*offp == vol->used_bytes || count == 0) 204 return 0; 205 206 if (vol->corrupted) 207 dbg_gen("read from corrupted volume %d", vol->vol_id); 208 209 if (*offp + count > vol->used_bytes) 210 count_save = count = vol->used_bytes - *offp; 211 212 tbuf_size = vol->usable_leb_size; 213 if (count < tbuf_size) 214 tbuf_size = ALIGN(count, ubi->min_io_size); 215 tbuf = vmalloc(tbuf_size); 216 if (!tbuf) 217 return -ENOMEM; 218 219 len = count > tbuf_size ? tbuf_size : count; 220 lnum = div_u64_rem(*offp, vol->usable_leb_size, &off); 221 222 do { 223 cond_resched(); 224 225 if (off + len >= vol->usable_leb_size) 226 len = vol->usable_leb_size - off; 227 228 err = ubi_eba_read_leb(ubi, vol, lnum, tbuf, off, len, 0); 229 if (err) 230 break; 231 232 off += len; 233 if (off == vol->usable_leb_size) { 234 lnum += 1; 235 off -= vol->usable_leb_size; 236 } 237 238 count -= len; 239 *offp += len; 240 241 err = copy_to_user(buf, tbuf, len); 242 if (err) { 243 err = -EFAULT; 244 break; 245 } 246 247 buf += len; 248 len = count > tbuf_size ? tbuf_size : count; 249 } while (count); 250 251 vfree(tbuf); 252 return err ? err : count_save - count; 253 } 254 255 /* 256 * This function allows to directly write to dynamic UBI volumes, without 257 * issuing the volume update operation. 258 */ 259 static ssize_t vol_cdev_direct_write(struct file *file, const char __user *buf, 260 size_t count, loff_t *offp) 261 { 262 struct ubi_volume_desc *desc = file->private_data; 263 struct ubi_volume *vol = desc->vol; 264 struct ubi_device *ubi = vol->ubi; 265 int lnum, off, len, tbuf_size, err = 0; 266 size_t count_save = count; 267 char *tbuf; 268 269 if (!vol->direct_writes) 270 return -EPERM; 271 272 dbg_gen("requested: write %zd bytes to offset %lld of volume %u", 273 count, *offp, vol->vol_id); 274 275 if (vol->vol_type == UBI_STATIC_VOLUME) 276 return -EROFS; 277 278 lnum = div_u64_rem(*offp, vol->usable_leb_size, &off); 279 if (off & (ubi->min_io_size - 1)) { 280 ubi_err("unaligned position"); 281 return -EINVAL; 282 } 283 284 if (*offp + count > vol->used_bytes) 285 count_save = count = vol->used_bytes - *offp; 286 287 /* We can write only in fractions of the minimum I/O unit */ 288 if (count & (ubi->min_io_size - 1)) { 289 ubi_err("unaligned write length"); 290 return -EINVAL; 291 } 292 293 tbuf_size = vol->usable_leb_size; 294 if (count < tbuf_size) 295 tbuf_size = ALIGN(count, ubi->min_io_size); 296 tbuf = vmalloc(tbuf_size); 297 if (!tbuf) 298 return -ENOMEM; 299 300 len = count > tbuf_size ? tbuf_size : count; 301 302 while (count) { 303 cond_resched(); 304 305 if (off + len >= vol->usable_leb_size) 306 len = vol->usable_leb_size - off; 307 308 err = copy_from_user(tbuf, buf, len); 309 if (err) { 310 err = -EFAULT; 311 break; 312 } 313 314 err = ubi_eba_write_leb(ubi, vol, lnum, tbuf, off, len); 315 if (err) 316 break; 317 318 off += len; 319 if (off == vol->usable_leb_size) { 320 lnum += 1; 321 off -= vol->usable_leb_size; 322 } 323 324 count -= len; 325 *offp += len; 326 buf += len; 327 len = count > tbuf_size ? tbuf_size : count; 328 } 329 330 vfree(tbuf); 331 return err ? err : count_save - count; 332 } 333 334 static ssize_t vol_cdev_write(struct file *file, const char __user *buf, 335 size_t count, loff_t *offp) 336 { 337 int err = 0; 338 struct ubi_volume_desc *desc = file->private_data; 339 struct ubi_volume *vol = desc->vol; 340 struct ubi_device *ubi = vol->ubi; 341 342 if (!vol->updating && !vol->changing_leb) 343 return vol_cdev_direct_write(file, buf, count, offp); 344 345 if (vol->updating) 346 err = ubi_more_update_data(ubi, vol, buf, count); 347 else 348 err = ubi_more_leb_change_data(ubi, vol, buf, count); 349 350 if (err < 0) { 351 ubi_err("cannot accept more %zd bytes of data, error %d", 352 count, err); 353 return err; 354 } 355 356 if (err) { 357 /* 358 * The operation is finished, @err contains number of actually 359 * written bytes. 360 */ 361 count = err; 362 363 if (vol->changing_leb) { 364 revoke_exclusive(desc, UBI_READWRITE); 365 return count; 366 } 367 368 err = ubi_check_volume(ubi, vol->vol_id); 369 if (err < 0) 370 return err; 371 372 if (err) { 373 ubi_warn("volume %d on UBI device %d is corrupted", 374 vol->vol_id, ubi->ubi_num); 375 vol->corrupted = 1; 376 } 377 vol->checked = 1; 378 ubi_volume_notify(ubi, vol, UBI_VOLUME_UPDATED); 379 revoke_exclusive(desc, UBI_READWRITE); 380 } 381 382 return count; 383 } 384 385 static long vol_cdev_ioctl(struct file *file, unsigned int cmd, 386 unsigned long arg) 387 { 388 int err = 0; 389 struct ubi_volume_desc *desc = file->private_data; 390 struct ubi_volume *vol = desc->vol; 391 struct ubi_device *ubi = vol->ubi; 392 void __user *argp = (void __user *)arg; 393 394 switch (cmd) { 395 /* Volume update command */ 396 case UBI_IOCVOLUP: 397 { 398 int64_t bytes, rsvd_bytes; 399 400 if (!capable(CAP_SYS_RESOURCE)) { 401 err = -EPERM; 402 break; 403 } 404 405 err = copy_from_user(&bytes, argp, sizeof(int64_t)); 406 if (err) { 407 err = -EFAULT; 408 break; 409 } 410 411 if (desc->mode == UBI_READONLY) { 412 err = -EROFS; 413 break; 414 } 415 416 rsvd_bytes = (long long)vol->reserved_pebs * 417 ubi->leb_size-vol->data_pad; 418 if (bytes < 0 || bytes > rsvd_bytes) { 419 err = -EINVAL; 420 break; 421 } 422 423 err = get_exclusive(desc); 424 if (err < 0) 425 break; 426 427 err = ubi_start_update(ubi, vol, bytes); 428 if (bytes == 0) { 429 ubi_volume_notify(ubi, vol, UBI_VOLUME_UPDATED); 430 revoke_exclusive(desc, UBI_READWRITE); 431 } 432 break; 433 } 434 435 /* Atomic logical eraseblock change command */ 436 case UBI_IOCEBCH: 437 { 438 struct ubi_leb_change_req req; 439 440 err = copy_from_user(&req, argp, 441 sizeof(struct ubi_leb_change_req)); 442 if (err) { 443 err = -EFAULT; 444 break; 445 } 446 447 if (desc->mode == UBI_READONLY || 448 vol->vol_type == UBI_STATIC_VOLUME) { 449 err = -EROFS; 450 break; 451 } 452 453 /* Validate the request */ 454 err = -EINVAL; 455 if (req.lnum < 0 || req.lnum >= vol->reserved_pebs || 456 req.bytes < 0 || req.lnum >= vol->usable_leb_size) 457 break; 458 459 err = get_exclusive(desc); 460 if (err < 0) 461 break; 462 463 err = ubi_start_leb_change(ubi, vol, &req); 464 if (req.bytes == 0) 465 revoke_exclusive(desc, UBI_READWRITE); 466 break; 467 } 468 469 /* Logical eraseblock erasure command */ 470 case UBI_IOCEBER: 471 { 472 int32_t lnum; 473 474 err = get_user(lnum, (__user int32_t *)argp); 475 if (err) { 476 err = -EFAULT; 477 break; 478 } 479 480 if (desc->mode == UBI_READONLY || 481 vol->vol_type == UBI_STATIC_VOLUME) { 482 err = -EROFS; 483 break; 484 } 485 486 if (lnum < 0 || lnum >= vol->reserved_pebs) { 487 err = -EINVAL; 488 break; 489 } 490 491 dbg_gen("erase LEB %d:%d", vol->vol_id, lnum); 492 err = ubi_eba_unmap_leb(ubi, vol, lnum); 493 if (err) 494 break; 495 496 err = ubi_wl_flush(ubi, UBI_ALL, UBI_ALL); 497 break; 498 } 499 500 /* Logical eraseblock map command */ 501 case UBI_IOCEBMAP: 502 { 503 struct ubi_map_req req; 504 505 err = copy_from_user(&req, argp, sizeof(struct ubi_map_req)); 506 if (err) { 507 err = -EFAULT; 508 break; 509 } 510 err = ubi_leb_map(desc, req.lnum); 511 break; 512 } 513 514 /* Logical eraseblock un-map command */ 515 case UBI_IOCEBUNMAP: 516 { 517 int32_t lnum; 518 519 err = get_user(lnum, (__user int32_t *)argp); 520 if (err) { 521 err = -EFAULT; 522 break; 523 } 524 err = ubi_leb_unmap(desc, lnum); 525 break; 526 } 527 528 /* Check if logical eraseblock is mapped command */ 529 case UBI_IOCEBISMAP: 530 { 531 int32_t lnum; 532 533 err = get_user(lnum, (__user int32_t *)argp); 534 if (err) { 535 err = -EFAULT; 536 break; 537 } 538 err = ubi_is_mapped(desc, lnum); 539 break; 540 } 541 542 /* Set volume property command */ 543 case UBI_IOCSETVOLPROP: 544 { 545 struct ubi_set_vol_prop_req req; 546 547 err = copy_from_user(&req, argp, 548 sizeof(struct ubi_set_vol_prop_req)); 549 if (err) { 550 err = -EFAULT; 551 break; 552 } 553 switch (req.property) { 554 case UBI_VOL_PROP_DIRECT_WRITE: 555 mutex_lock(&ubi->device_mutex); 556 desc->vol->direct_writes = !!req.value; 557 mutex_unlock(&ubi->device_mutex); 558 break; 559 default: 560 err = -EINVAL; 561 break; 562 } 563 break; 564 } 565 566 /* Create a R/O block device on top of the UBI volume */ 567 case UBI_IOCVOLCRBLK: 568 { 569 struct ubi_volume_info vi; 570 571 ubi_get_volume_info(desc, &vi); 572 err = ubiblock_create(&vi); 573 break; 574 } 575 576 /* Remove the R/O block device */ 577 case UBI_IOCVOLRMBLK: 578 { 579 struct ubi_volume_info vi; 580 581 ubi_get_volume_info(desc, &vi); 582 err = ubiblock_remove(&vi); 583 break; 584 } 585 586 default: 587 err = -ENOTTY; 588 break; 589 } 590 return err; 591 } 592 593 /** 594 * verify_mkvol_req - verify volume creation request. 595 * @ubi: UBI device description object 596 * @req: the request to check 597 * 598 * This function zero if the request is correct, and %-EINVAL if not. 599 */ 600 static int verify_mkvol_req(const struct ubi_device *ubi, 601 const struct ubi_mkvol_req *req) 602 { 603 int n, err = -EINVAL; 604 605 if (req->bytes < 0 || req->alignment < 0 || req->vol_type < 0 || 606 req->name_len < 0) 607 goto bad; 608 609 if ((req->vol_id < 0 || req->vol_id >= ubi->vtbl_slots) && 610 req->vol_id != UBI_VOL_NUM_AUTO) 611 goto bad; 612 613 if (req->alignment == 0) 614 goto bad; 615 616 if (req->bytes == 0) 617 goto bad; 618 619 if (req->vol_type != UBI_DYNAMIC_VOLUME && 620 req->vol_type != UBI_STATIC_VOLUME) 621 goto bad; 622 623 if (req->alignment > ubi->leb_size) 624 goto bad; 625 626 n = req->alignment & (ubi->min_io_size - 1); 627 if (req->alignment != 1 && n) 628 goto bad; 629 630 if (!req->name[0] || !req->name_len) 631 goto bad; 632 633 if (req->name_len > UBI_VOL_NAME_MAX) { 634 err = -ENAMETOOLONG; 635 goto bad; 636 } 637 638 n = strnlen(req->name, req->name_len + 1); 639 if (n != req->name_len) 640 goto bad; 641 642 return 0; 643 644 bad: 645 ubi_err("bad volume creation request"); 646 ubi_dump_mkvol_req(req); 647 return err; 648 } 649 650 /** 651 * verify_rsvol_req - verify volume re-size request. 652 * @ubi: UBI device description object 653 * @req: the request to check 654 * 655 * This function returns zero if the request is correct, and %-EINVAL if not. 656 */ 657 static int verify_rsvol_req(const struct ubi_device *ubi, 658 const struct ubi_rsvol_req *req) 659 { 660 if (req->bytes <= 0) 661 return -EINVAL; 662 663 if (req->vol_id < 0 || req->vol_id >= ubi->vtbl_slots) 664 return -EINVAL; 665 666 return 0; 667 } 668 669 /** 670 * rename_volumes - rename UBI volumes. 671 * @ubi: UBI device description object 672 * @req: volumes re-name request 673 * 674 * This is a helper function for the volume re-name IOCTL which validates the 675 * the request, opens the volume and calls corresponding volumes management 676 * function. Returns zero in case of success and a negative error code in case 677 * of failure. 678 */ 679 static int rename_volumes(struct ubi_device *ubi, 680 struct ubi_rnvol_req *req) 681 { 682 int i, n, err; 683 struct list_head rename_list; 684 struct ubi_rename_entry *re, *re1; 685 686 if (req->count < 0 || req->count > UBI_MAX_RNVOL) 687 return -EINVAL; 688 689 if (req->count == 0) 690 return 0; 691 692 /* Validate volume IDs and names in the request */ 693 for (i = 0; i < req->count; i++) { 694 if (req->ents[i].vol_id < 0 || 695 req->ents[i].vol_id >= ubi->vtbl_slots) 696 return -EINVAL; 697 if (req->ents[i].name_len < 0) 698 return -EINVAL; 699 if (req->ents[i].name_len > UBI_VOL_NAME_MAX) 700 return -ENAMETOOLONG; 701 req->ents[i].name[req->ents[i].name_len] = '\0'; 702 n = strlen(req->ents[i].name); 703 if (n != req->ents[i].name_len) 704 return -EINVAL; 705 } 706 707 /* Make sure volume IDs and names are unique */ 708 for (i = 0; i < req->count - 1; i++) { 709 for (n = i + 1; n < req->count; n++) { 710 if (req->ents[i].vol_id == req->ents[n].vol_id) { 711 ubi_err("duplicated volume id %d", 712 req->ents[i].vol_id); 713 return -EINVAL; 714 } 715 if (!strcmp(req->ents[i].name, req->ents[n].name)) { 716 ubi_err("duplicated volume name \"%s\"", 717 req->ents[i].name); 718 return -EINVAL; 719 } 720 } 721 } 722 723 /* Create the re-name list */ 724 INIT_LIST_HEAD(&rename_list); 725 for (i = 0; i < req->count; i++) { 726 int vol_id = req->ents[i].vol_id; 727 int name_len = req->ents[i].name_len; 728 const char *name = req->ents[i].name; 729 730 re = kzalloc(sizeof(struct ubi_rename_entry), GFP_KERNEL); 731 if (!re) { 732 err = -ENOMEM; 733 goto out_free; 734 } 735 736 re->desc = ubi_open_volume(ubi->ubi_num, vol_id, UBI_READWRITE); 737 if (IS_ERR(re->desc)) { 738 err = PTR_ERR(re->desc); 739 ubi_err("cannot open volume %d, error %d", vol_id, err); 740 kfree(re); 741 goto out_free; 742 } 743 744 /* Skip this re-naming if the name does not really change */ 745 if (re->desc->vol->name_len == name_len && 746 !memcmp(re->desc->vol->name, name, name_len)) { 747 ubi_close_volume(re->desc); 748 kfree(re); 749 continue; 750 } 751 752 re->new_name_len = name_len; 753 memcpy(re->new_name, name, name_len); 754 list_add_tail(&re->list, &rename_list); 755 dbg_gen("will rename volume %d from \"%s\" to \"%s\"", 756 vol_id, re->desc->vol->name, name); 757 } 758 759 if (list_empty(&rename_list)) 760 return 0; 761 762 /* Find out the volumes which have to be removed */ 763 list_for_each_entry(re, &rename_list, list) { 764 struct ubi_volume_desc *desc; 765 int no_remove_needed = 0; 766 767 /* 768 * Volume @re->vol_id is going to be re-named to 769 * @re->new_name, while its current name is @name. If a volume 770 * with name @re->new_name currently exists, it has to be 771 * removed, unless it is also re-named in the request (@req). 772 */ 773 list_for_each_entry(re1, &rename_list, list) { 774 if (re->new_name_len == re1->desc->vol->name_len && 775 !memcmp(re->new_name, re1->desc->vol->name, 776 re1->desc->vol->name_len)) { 777 no_remove_needed = 1; 778 break; 779 } 780 } 781 782 if (no_remove_needed) 783 continue; 784 785 /* 786 * It seems we need to remove volume with name @re->new_name, 787 * if it exists. 788 */ 789 desc = ubi_open_volume_nm(ubi->ubi_num, re->new_name, 790 UBI_EXCLUSIVE); 791 if (IS_ERR(desc)) { 792 err = PTR_ERR(desc); 793 if (err == -ENODEV) 794 /* Re-naming into a non-existing volume name */ 795 continue; 796 797 /* The volume exists but busy, or an error occurred */ 798 ubi_err("cannot open volume \"%s\", error %d", 799 re->new_name, err); 800 goto out_free; 801 } 802 803 re1 = kzalloc(sizeof(struct ubi_rename_entry), GFP_KERNEL); 804 if (!re1) { 805 err = -ENOMEM; 806 ubi_close_volume(desc); 807 goto out_free; 808 } 809 810 re1->remove = 1; 811 re1->desc = desc; 812 list_add(&re1->list, &rename_list); 813 dbg_gen("will remove volume %d, name \"%s\"", 814 re1->desc->vol->vol_id, re1->desc->vol->name); 815 } 816 817 mutex_lock(&ubi->device_mutex); 818 err = ubi_rename_volumes(ubi, &rename_list); 819 mutex_unlock(&ubi->device_mutex); 820 821 out_free: 822 list_for_each_entry_safe(re, re1, &rename_list, list) { 823 ubi_close_volume(re->desc); 824 list_del(&re->list); 825 kfree(re); 826 } 827 return err; 828 } 829 830 static long ubi_cdev_ioctl(struct file *file, unsigned int cmd, 831 unsigned long arg) 832 { 833 int err = 0; 834 struct ubi_device *ubi; 835 struct ubi_volume_desc *desc; 836 void __user *argp = (void __user *)arg; 837 838 if (!capable(CAP_SYS_RESOURCE)) 839 return -EPERM; 840 841 ubi = ubi_get_by_major(imajor(file->f_mapping->host)); 842 if (!ubi) 843 return -ENODEV; 844 845 switch (cmd) { 846 /* Create volume command */ 847 case UBI_IOCMKVOL: 848 { 849 struct ubi_mkvol_req req; 850 851 dbg_gen("create volume"); 852 err = copy_from_user(&req, argp, sizeof(struct ubi_mkvol_req)); 853 if (err) { 854 err = -EFAULT; 855 break; 856 } 857 858 err = verify_mkvol_req(ubi, &req); 859 if (err) 860 break; 861 862 mutex_lock(&ubi->device_mutex); 863 err = ubi_create_volume(ubi, &req); 864 mutex_unlock(&ubi->device_mutex); 865 if (err) 866 break; 867 868 err = put_user(req.vol_id, (__user int32_t *)argp); 869 if (err) 870 err = -EFAULT; 871 872 break; 873 } 874 875 /* Remove volume command */ 876 case UBI_IOCRMVOL: 877 { 878 int vol_id; 879 880 dbg_gen("remove volume"); 881 err = get_user(vol_id, (__user int32_t *)argp); 882 if (err) { 883 err = -EFAULT; 884 break; 885 } 886 887 desc = ubi_open_volume(ubi->ubi_num, vol_id, UBI_EXCLUSIVE); 888 if (IS_ERR(desc)) { 889 err = PTR_ERR(desc); 890 break; 891 } 892 893 mutex_lock(&ubi->device_mutex); 894 err = ubi_remove_volume(desc, 0); 895 mutex_unlock(&ubi->device_mutex); 896 897 /* 898 * The volume is deleted (unless an error occurred), and the 899 * 'struct ubi_volume' object will be freed when 900 * 'ubi_close_volume()' will call 'put_device()'. 901 */ 902 ubi_close_volume(desc); 903 break; 904 } 905 906 /* Re-size volume command */ 907 case UBI_IOCRSVOL: 908 { 909 int pebs; 910 struct ubi_rsvol_req req; 911 912 dbg_gen("re-size volume"); 913 err = copy_from_user(&req, argp, sizeof(struct ubi_rsvol_req)); 914 if (err) { 915 err = -EFAULT; 916 break; 917 } 918 919 err = verify_rsvol_req(ubi, &req); 920 if (err) 921 break; 922 923 desc = ubi_open_volume(ubi->ubi_num, req.vol_id, UBI_EXCLUSIVE); 924 if (IS_ERR(desc)) { 925 err = PTR_ERR(desc); 926 break; 927 } 928 929 pebs = div_u64(req.bytes + desc->vol->usable_leb_size - 1, 930 desc->vol->usable_leb_size); 931 932 mutex_lock(&ubi->device_mutex); 933 err = ubi_resize_volume(desc, pebs); 934 mutex_unlock(&ubi->device_mutex); 935 ubi_close_volume(desc); 936 break; 937 } 938 939 /* Re-name volumes command */ 940 case UBI_IOCRNVOL: 941 { 942 struct ubi_rnvol_req *req; 943 944 dbg_gen("re-name volumes"); 945 req = kmalloc(sizeof(struct ubi_rnvol_req), GFP_KERNEL); 946 if (!req) { 947 err = -ENOMEM; 948 break; 949 }; 950 951 err = copy_from_user(req, argp, sizeof(struct ubi_rnvol_req)); 952 if (err) { 953 err = -EFAULT; 954 kfree(req); 955 break; 956 } 957 958 err = rename_volumes(ubi, req); 959 kfree(req); 960 break; 961 } 962 963 default: 964 err = -ENOTTY; 965 break; 966 } 967 968 ubi_put_device(ubi); 969 return err; 970 } 971 972 static long ctrl_cdev_ioctl(struct file *file, unsigned int cmd, 973 unsigned long arg) 974 { 975 int err = 0; 976 void __user *argp = (void __user *)arg; 977 978 if (!capable(CAP_SYS_RESOURCE)) 979 return -EPERM; 980 981 switch (cmd) { 982 /* Attach an MTD device command */ 983 case UBI_IOCATT: 984 { 985 struct ubi_attach_req req; 986 struct mtd_info *mtd; 987 988 dbg_gen("attach MTD device"); 989 err = copy_from_user(&req, argp, sizeof(struct ubi_attach_req)); 990 if (err) { 991 err = -EFAULT; 992 break; 993 } 994 995 if (req.mtd_num < 0 || 996 (req.ubi_num < 0 && req.ubi_num != UBI_DEV_NUM_AUTO)) { 997 err = -EINVAL; 998 break; 999 } 1000 1001 mtd = get_mtd_device(NULL, req.mtd_num); 1002 if (IS_ERR(mtd)) { 1003 err = PTR_ERR(mtd); 1004 break; 1005 } 1006 1007 /* 1008 * Note, further request verification is done by 1009 * 'ubi_attach_mtd_dev()'. 1010 */ 1011 mutex_lock(&ubi_devices_mutex); 1012 err = ubi_attach_mtd_dev(mtd, req.ubi_num, req.vid_hdr_offset, 1013 req.max_beb_per1024); 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