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 revoke_exclusive(desc, UBI_READWRITE); 430 break; 431 } 432 433 /* Atomic logical eraseblock change command */ 434 case UBI_IOCEBCH: 435 { 436 struct ubi_leb_change_req req; 437 438 err = copy_from_user(&req, argp, 439 sizeof(struct ubi_leb_change_req)); 440 if (err) { 441 err = -EFAULT; 442 break; 443 } 444 445 if (desc->mode == UBI_READONLY || 446 vol->vol_type == UBI_STATIC_VOLUME) { 447 err = -EROFS; 448 break; 449 } 450 451 /* Validate the request */ 452 err = -EINVAL; 453 if (req.lnum < 0 || req.lnum >= vol->reserved_pebs || 454 req.bytes < 0 || req.lnum >= vol->usable_leb_size) 455 break; 456 457 err = get_exclusive(desc); 458 if (err < 0) 459 break; 460 461 err = ubi_start_leb_change(ubi, vol, &req); 462 if (req.bytes == 0) 463 revoke_exclusive(desc, UBI_READWRITE); 464 break; 465 } 466 467 /* Logical eraseblock erasure command */ 468 case UBI_IOCEBER: 469 { 470 int32_t lnum; 471 472 err = get_user(lnum, (__user int32_t *)argp); 473 if (err) { 474 err = -EFAULT; 475 break; 476 } 477 478 if (desc->mode == UBI_READONLY || 479 vol->vol_type == UBI_STATIC_VOLUME) { 480 err = -EROFS; 481 break; 482 } 483 484 if (lnum < 0 || lnum >= vol->reserved_pebs) { 485 err = -EINVAL; 486 break; 487 } 488 489 dbg_gen("erase LEB %d:%d", vol->vol_id, lnum); 490 err = ubi_eba_unmap_leb(ubi, vol, lnum); 491 if (err) 492 break; 493 494 err = ubi_wl_flush(ubi, UBI_ALL, UBI_ALL); 495 break; 496 } 497 498 /* Logical eraseblock map command */ 499 case UBI_IOCEBMAP: 500 { 501 struct ubi_map_req req; 502 503 err = copy_from_user(&req, argp, sizeof(struct ubi_map_req)); 504 if (err) { 505 err = -EFAULT; 506 break; 507 } 508 err = ubi_leb_map(desc, req.lnum); 509 break; 510 } 511 512 /* Logical eraseblock un-map command */ 513 case UBI_IOCEBUNMAP: 514 { 515 int32_t lnum; 516 517 err = get_user(lnum, (__user int32_t *)argp); 518 if (err) { 519 err = -EFAULT; 520 break; 521 } 522 err = ubi_leb_unmap(desc, lnum); 523 break; 524 } 525 526 /* Check if logical eraseblock is mapped command */ 527 case UBI_IOCEBISMAP: 528 { 529 int32_t lnum; 530 531 err = get_user(lnum, (__user int32_t *)argp); 532 if (err) { 533 err = -EFAULT; 534 break; 535 } 536 err = ubi_is_mapped(desc, lnum); 537 break; 538 } 539 540 /* Set volume property command */ 541 case UBI_IOCSETVOLPROP: 542 { 543 struct ubi_set_vol_prop_req req; 544 545 err = copy_from_user(&req, argp, 546 sizeof(struct ubi_set_vol_prop_req)); 547 if (err) { 548 err = -EFAULT; 549 break; 550 } 551 switch (req.property) { 552 case UBI_VOL_PROP_DIRECT_WRITE: 553 mutex_lock(&ubi->device_mutex); 554 desc->vol->direct_writes = !!req.value; 555 mutex_unlock(&ubi->device_mutex); 556 break; 557 default: 558 err = -EINVAL; 559 break; 560 } 561 break; 562 } 563 564 /* Create a R/O block device on top of the UBI volume */ 565 case UBI_IOCVOLCRBLK: 566 { 567 struct ubi_volume_info vi; 568 569 ubi_get_volume_info(desc, &vi); 570 err = ubiblock_create(&vi); 571 break; 572 } 573 574 /* Remove the R/O block device */ 575 case UBI_IOCVOLRMBLK: 576 { 577 struct ubi_volume_info vi; 578 579 ubi_get_volume_info(desc, &vi); 580 err = ubiblock_remove(&vi); 581 break; 582 } 583 584 default: 585 err = -ENOTTY; 586 break; 587 } 588 return err; 589 } 590 591 /** 592 * verify_mkvol_req - verify volume creation request. 593 * @ubi: UBI device description object 594 * @req: the request to check 595 * 596 * This function zero if the request is correct, and %-EINVAL if not. 597 */ 598 static int verify_mkvol_req(const struct ubi_device *ubi, 599 const struct ubi_mkvol_req *req) 600 { 601 int n, err = -EINVAL; 602 603 if (req->bytes < 0 || req->alignment < 0 || req->vol_type < 0 || 604 req->name_len < 0) 605 goto bad; 606 607 if ((req->vol_id < 0 || req->vol_id >= ubi->vtbl_slots) && 608 req->vol_id != UBI_VOL_NUM_AUTO) 609 goto bad; 610 611 if (req->alignment == 0) 612 goto bad; 613 614 if (req->bytes == 0) 615 goto bad; 616 617 if (req->vol_type != UBI_DYNAMIC_VOLUME && 618 req->vol_type != UBI_STATIC_VOLUME) 619 goto bad; 620 621 if (req->alignment > ubi->leb_size) 622 goto bad; 623 624 n = req->alignment & (ubi->min_io_size - 1); 625 if (req->alignment != 1 && n) 626 goto bad; 627 628 if (!req->name[0] || !req->name_len) 629 goto bad; 630 631 if (req->name_len > UBI_VOL_NAME_MAX) { 632 err = -ENAMETOOLONG; 633 goto bad; 634 } 635 636 n = strnlen(req->name, req->name_len + 1); 637 if (n != req->name_len) 638 goto bad; 639 640 return 0; 641 642 bad: 643 ubi_err("bad volume creation request"); 644 ubi_dump_mkvol_req(req); 645 return err; 646 } 647 648 /** 649 * verify_rsvol_req - verify volume re-size request. 650 * @ubi: UBI device description object 651 * @req: the request to check 652 * 653 * This function returns zero if the request is correct, and %-EINVAL if not. 654 */ 655 static int verify_rsvol_req(const struct ubi_device *ubi, 656 const struct ubi_rsvol_req *req) 657 { 658 if (req->bytes <= 0) 659 return -EINVAL; 660 661 if (req->vol_id < 0 || req->vol_id >= ubi->vtbl_slots) 662 return -EINVAL; 663 664 return 0; 665 } 666 667 /** 668 * rename_volumes - rename UBI volumes. 669 * @ubi: UBI device description object 670 * @req: volumes re-name request 671 * 672 * This is a helper function for the volume re-name IOCTL which validates the 673 * the request, opens the volume and calls corresponding volumes management 674 * function. Returns zero in case of success and a negative error code in case 675 * of failure. 676 */ 677 static int rename_volumes(struct ubi_device *ubi, 678 struct ubi_rnvol_req *req) 679 { 680 int i, n, err; 681 struct list_head rename_list; 682 struct ubi_rename_entry *re, *re1; 683 684 if (req->count < 0 || req->count > UBI_MAX_RNVOL) 685 return -EINVAL; 686 687 if (req->count == 0) 688 return 0; 689 690 /* Validate volume IDs and names in the request */ 691 for (i = 0; i < req->count; i++) { 692 if (req->ents[i].vol_id < 0 || 693 req->ents[i].vol_id >= ubi->vtbl_slots) 694 return -EINVAL; 695 if (req->ents[i].name_len < 0) 696 return -EINVAL; 697 if (req->ents[i].name_len > UBI_VOL_NAME_MAX) 698 return -ENAMETOOLONG; 699 req->ents[i].name[req->ents[i].name_len] = '\0'; 700 n = strlen(req->ents[i].name); 701 if (n != req->ents[i].name_len) 702 err = -EINVAL; 703 } 704 705 /* Make sure volume IDs and names are unique */ 706 for (i = 0; i < req->count - 1; i++) { 707 for (n = i + 1; n < req->count; n++) { 708 if (req->ents[i].vol_id == req->ents[n].vol_id) { 709 ubi_err("duplicated volume id %d", 710 req->ents[i].vol_id); 711 return -EINVAL; 712 } 713 if (!strcmp(req->ents[i].name, req->ents[n].name)) { 714 ubi_err("duplicated volume name \"%s\"", 715 req->ents[i].name); 716 return -EINVAL; 717 } 718 } 719 } 720 721 /* Create the re-name list */ 722 INIT_LIST_HEAD(&rename_list); 723 for (i = 0; i < req->count; i++) { 724 int vol_id = req->ents[i].vol_id; 725 int name_len = req->ents[i].name_len; 726 const char *name = req->ents[i].name; 727 728 re = kzalloc(sizeof(struct ubi_rename_entry), GFP_KERNEL); 729 if (!re) { 730 err = -ENOMEM; 731 goto out_free; 732 } 733 734 re->desc = ubi_open_volume(ubi->ubi_num, vol_id, UBI_READWRITE); 735 if (IS_ERR(re->desc)) { 736 err = PTR_ERR(re->desc); 737 ubi_err("cannot open volume %d, error %d", vol_id, err); 738 kfree(re); 739 goto out_free; 740 } 741 742 /* Skip this re-naming if the name does not really change */ 743 if (re->desc->vol->name_len == name_len && 744 !memcmp(re->desc->vol->name, name, name_len)) { 745 ubi_close_volume(re->desc); 746 kfree(re); 747 continue; 748 } 749 750 re->new_name_len = name_len; 751 memcpy(re->new_name, name, name_len); 752 list_add_tail(&re->list, &rename_list); 753 dbg_gen("will rename volume %d from \"%s\" to \"%s\"", 754 vol_id, re->desc->vol->name, name); 755 } 756 757 if (list_empty(&rename_list)) 758 return 0; 759 760 /* Find out the volumes which have to be removed */ 761 list_for_each_entry(re, &rename_list, list) { 762 struct ubi_volume_desc *desc; 763 int no_remove_needed = 0; 764 765 /* 766 * Volume @re->vol_id is going to be re-named to 767 * @re->new_name, while its current name is @name. If a volume 768 * with name @re->new_name currently exists, it has to be 769 * removed, unless it is also re-named in the request (@req). 770 */ 771 list_for_each_entry(re1, &rename_list, list) { 772 if (re->new_name_len == re1->desc->vol->name_len && 773 !memcmp(re->new_name, re1->desc->vol->name, 774 re1->desc->vol->name_len)) { 775 no_remove_needed = 1; 776 break; 777 } 778 } 779 780 if (no_remove_needed) 781 continue; 782 783 /* 784 * It seems we need to remove volume with name @re->new_name, 785 * if it exists. 786 */ 787 desc = ubi_open_volume_nm(ubi->ubi_num, re->new_name, 788 UBI_EXCLUSIVE); 789 if (IS_ERR(desc)) { 790 err = PTR_ERR(desc); 791 if (err == -ENODEV) 792 /* Re-naming into a non-existing volume name */ 793 continue; 794 795 /* The volume exists but busy, or an error occurred */ 796 ubi_err("cannot open volume \"%s\", error %d", 797 re->new_name, err); 798 goto out_free; 799 } 800 801 re1 = kzalloc(sizeof(struct ubi_rename_entry), GFP_KERNEL); 802 if (!re1) { 803 err = -ENOMEM; 804 ubi_close_volume(desc); 805 goto out_free; 806 } 807 808 re1->remove = 1; 809 re1->desc = desc; 810 list_add(&re1->list, &rename_list); 811 dbg_gen("will remove volume %d, name \"%s\"", 812 re1->desc->vol->vol_id, re1->desc->vol->name); 813 } 814 815 mutex_lock(&ubi->device_mutex); 816 err = ubi_rename_volumes(ubi, &rename_list); 817 mutex_unlock(&ubi->device_mutex); 818 819 out_free: 820 list_for_each_entry_safe(re, re1, &rename_list, list) { 821 ubi_close_volume(re->desc); 822 list_del(&re->list); 823 kfree(re); 824 } 825 return err; 826 } 827 828 static long ubi_cdev_ioctl(struct file *file, unsigned int cmd, 829 unsigned long arg) 830 { 831 int err = 0; 832 struct ubi_device *ubi; 833 struct ubi_volume_desc *desc; 834 void __user *argp = (void __user *)arg; 835 836 if (!capable(CAP_SYS_RESOURCE)) 837 return -EPERM; 838 839 ubi = ubi_get_by_major(imajor(file->f_mapping->host)); 840 if (!ubi) 841 return -ENODEV; 842 843 switch (cmd) { 844 /* Create volume command */ 845 case UBI_IOCMKVOL: 846 { 847 struct ubi_mkvol_req req; 848 849 dbg_gen("create volume"); 850 err = copy_from_user(&req, argp, sizeof(struct ubi_mkvol_req)); 851 if (err) { 852 err = -EFAULT; 853 break; 854 } 855 856 err = verify_mkvol_req(ubi, &req); 857 if (err) 858 break; 859 860 mutex_lock(&ubi->device_mutex); 861 err = ubi_create_volume(ubi, &req); 862 mutex_unlock(&ubi->device_mutex); 863 if (err) 864 break; 865 866 err = put_user(req.vol_id, (__user int32_t *)argp); 867 if (err) 868 err = -EFAULT; 869 870 break; 871 } 872 873 /* Remove volume command */ 874 case UBI_IOCRMVOL: 875 { 876 int vol_id; 877 878 dbg_gen("remove volume"); 879 err = get_user(vol_id, (__user int32_t *)argp); 880 if (err) { 881 err = -EFAULT; 882 break; 883 } 884 885 desc = ubi_open_volume(ubi->ubi_num, vol_id, UBI_EXCLUSIVE); 886 if (IS_ERR(desc)) { 887 err = PTR_ERR(desc); 888 break; 889 } 890 891 mutex_lock(&ubi->device_mutex); 892 err = ubi_remove_volume(desc, 0); 893 mutex_unlock(&ubi->device_mutex); 894 895 /* 896 * The volume is deleted (unless an error occurred), and the 897 * 'struct ubi_volume' object will be freed when 898 * 'ubi_close_volume()' will call 'put_device()'. 899 */ 900 ubi_close_volume(desc); 901 break; 902 } 903 904 /* Re-size volume command */ 905 case UBI_IOCRSVOL: 906 { 907 int pebs; 908 struct ubi_rsvol_req req; 909 910 dbg_gen("re-size volume"); 911 err = copy_from_user(&req, argp, sizeof(struct ubi_rsvol_req)); 912 if (err) { 913 err = -EFAULT; 914 break; 915 } 916 917 err = verify_rsvol_req(ubi, &req); 918 if (err) 919 break; 920 921 desc = ubi_open_volume(ubi->ubi_num, req.vol_id, UBI_EXCLUSIVE); 922 if (IS_ERR(desc)) { 923 err = PTR_ERR(desc); 924 break; 925 } 926 927 pebs = div_u64(req.bytes + desc->vol->usable_leb_size - 1, 928 desc->vol->usable_leb_size); 929 930 mutex_lock(&ubi->device_mutex); 931 err = ubi_resize_volume(desc, pebs); 932 mutex_unlock(&ubi->device_mutex); 933 ubi_close_volume(desc); 934 break; 935 } 936 937 /* Re-name volumes command */ 938 case UBI_IOCRNVOL: 939 { 940 struct ubi_rnvol_req *req; 941 942 dbg_gen("re-name volumes"); 943 req = kmalloc(sizeof(struct ubi_rnvol_req), GFP_KERNEL); 944 if (!req) { 945 err = -ENOMEM; 946 break; 947 }; 948 949 err = copy_from_user(req, argp, sizeof(struct ubi_rnvol_req)); 950 if (err) { 951 err = -EFAULT; 952 kfree(req); 953 break; 954 } 955 956 err = rename_volumes(ubi, req); 957 kfree(req); 958 break; 959 } 960 961 default: 962 err = -ENOTTY; 963 break; 964 } 965 966 ubi_put_device(ubi); 967 return err; 968 } 969 970 static long ctrl_cdev_ioctl(struct file *file, unsigned int cmd, 971 unsigned long arg) 972 { 973 int err = 0; 974 void __user *argp = (void __user *)arg; 975 976 if (!capable(CAP_SYS_RESOURCE)) 977 return -EPERM; 978 979 switch (cmd) { 980 /* Attach an MTD device command */ 981 case UBI_IOCATT: 982 { 983 struct ubi_attach_req req; 984 struct mtd_info *mtd; 985 986 dbg_gen("attach MTD device"); 987 err = copy_from_user(&req, argp, sizeof(struct ubi_attach_req)); 988 if (err) { 989 err = -EFAULT; 990 break; 991 } 992 993 if (req.mtd_num < 0 || 994 (req.ubi_num < 0 && req.ubi_num != UBI_DEV_NUM_AUTO)) { 995 err = -EINVAL; 996 break; 997 } 998 999 mtd = get_mtd_device(NULL, req.mtd_num); 1000 if (IS_ERR(mtd)) { 1001 err = PTR_ERR(mtd); 1002 break; 1003 } 1004 1005 /* 1006 * Note, further request verification is done by 1007 * 'ubi_attach_mtd_dev()'. 1008 */ 1009 mutex_lock(&ubi_devices_mutex); 1010 err = ubi_attach_mtd_dev(mtd, req.ubi_num, req.vid_hdr_offset, 1011 req.max_beb_per1024); 1012 mutex_unlock(&ubi_devices_mutex); 1013 if (err < 0) 1014 put_mtd_device(mtd); 1015 else 1016 /* @err contains UBI device number */ 1017 err = put_user(err, (__user int32_t *)argp); 1018 1019 break; 1020 } 1021 1022 /* Detach an MTD device command */ 1023 case UBI_IOCDET: 1024 { 1025 int ubi_num; 1026 1027 dbg_gen("detach MTD device"); 1028 err = get_user(ubi_num, (__user int32_t *)argp); 1029 if (err) { 1030 err = -EFAULT; 1031 break; 1032 } 1033 1034 mutex_lock(&ubi_devices_mutex); 1035 err = ubi_detach_mtd_dev(ubi_num, 0); 1036 mutex_unlock(&ubi_devices_mutex); 1037 break; 1038 } 1039 1040 default: 1041 err = -ENOTTY; 1042 break; 1043 } 1044 1045 return err; 1046 } 1047 1048 #ifdef CONFIG_COMPAT 1049 static long vol_cdev_compat_ioctl(struct file *file, unsigned int cmd, 1050 unsigned long arg) 1051 { 1052 unsigned long translated_arg = (unsigned long)compat_ptr(arg); 1053 1054 return vol_cdev_ioctl(file, cmd, translated_arg); 1055 } 1056 1057 static long ubi_cdev_compat_ioctl(struct file *file, unsigned int cmd, 1058 unsigned long arg) 1059 { 1060 unsigned long translated_arg = (unsigned long)compat_ptr(arg); 1061 1062 return ubi_cdev_ioctl(file, cmd, translated_arg); 1063 } 1064 1065 static long ctrl_cdev_compat_ioctl(struct file *file, unsigned int cmd, 1066 unsigned long arg) 1067 { 1068 unsigned long translated_arg = (unsigned long)compat_ptr(arg); 1069 1070 return ctrl_cdev_ioctl(file, cmd, translated_arg); 1071 } 1072 #else 1073 #define vol_cdev_compat_ioctl NULL 1074 #define ubi_cdev_compat_ioctl NULL 1075 #define ctrl_cdev_compat_ioctl NULL 1076 #endif 1077 1078 /* UBI volume character device operations */ 1079 const struct file_operations ubi_vol_cdev_operations = { 1080 .owner = THIS_MODULE, 1081 .open = vol_cdev_open, 1082 .release = vol_cdev_release, 1083 .llseek = vol_cdev_llseek, 1084 .read = vol_cdev_read, 1085 .write = vol_cdev_write, 1086 .fsync = vol_cdev_fsync, 1087 .unlocked_ioctl = vol_cdev_ioctl, 1088 .compat_ioctl = vol_cdev_compat_ioctl, 1089 }; 1090 1091 /* UBI character device operations */ 1092 const struct file_operations ubi_cdev_operations = { 1093 .owner = THIS_MODULE, 1094 .llseek = no_llseek, 1095 .unlocked_ioctl = ubi_cdev_ioctl, 1096 .compat_ioctl = ubi_cdev_compat_ioctl, 1097 }; 1098 1099 /* UBI control character device operations */ 1100 const struct file_operations ubi_ctrl_cdev_operations = { 1101 .owner = THIS_MODULE, 1102 .unlocked_ioctl = ctrl_cdev_ioctl, 1103 .compat_ioctl = ctrl_cdev_compat_ioctl, 1104 .llseek = no_llseek, 1105 }; 1106