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