1 /* 2 * linux/fs/ocfs2/ioctl.c 3 * 4 * Copyright (C) 2006 Herbert Poetzl 5 * adapted from Remy Card's ext2/ioctl.c 6 */ 7 8 #include <linux/fs.h> 9 #include <linux/mount.h> 10 #include <linux/compat.h> 11 12 #include <cluster/masklog.h> 13 14 #include "ocfs2.h" 15 #include "alloc.h" 16 #include "dlmglue.h" 17 #include "file.h" 18 #include "inode.h" 19 #include "journal.h" 20 21 #include "ocfs2_fs.h" 22 #include "ioctl.h" 23 #include "resize.h" 24 #include "refcounttree.h" 25 #include "sysfile.h" 26 #include "dir.h" 27 #include "buffer_head_io.h" 28 #include "suballoc.h" 29 #include "move_extents.h" 30 31 #define o2info_from_user(a, b) \ 32 copy_from_user(&(a), (b), sizeof(a)) 33 #define o2info_to_user(a, b) \ 34 copy_to_user((typeof(a) __user *)b, &(a), sizeof(a)) 35 36 /* 37 * This call is void because we are already reporting an error that may 38 * be -EFAULT. The error will be returned from the ioctl(2) call. It's 39 * just a best-effort to tell userspace that this request caused the error. 40 */ 41 static inline void o2info_set_request_error(struct ocfs2_info_request *kreq, 42 struct ocfs2_info_request __user *req) 43 { 44 kreq->ir_flags |= OCFS2_INFO_FL_ERROR; 45 (void)put_user(kreq->ir_flags, (__u32 __user *)&(req->ir_flags)); 46 } 47 48 static inline void o2info_set_request_filled(struct ocfs2_info_request *req) 49 { 50 req->ir_flags |= OCFS2_INFO_FL_FILLED; 51 } 52 53 static inline void o2info_clear_request_filled(struct ocfs2_info_request *req) 54 { 55 req->ir_flags &= ~OCFS2_INFO_FL_FILLED; 56 } 57 58 static inline int o2info_coherent(struct ocfs2_info_request *req) 59 { 60 return (!(req->ir_flags & OCFS2_INFO_FL_NON_COHERENT)); 61 } 62 63 static int ocfs2_get_inode_attr(struct inode *inode, unsigned *flags) 64 { 65 int status; 66 67 status = ocfs2_inode_lock(inode, NULL, 0); 68 if (status < 0) { 69 mlog_errno(status); 70 return status; 71 } 72 ocfs2_get_inode_flags(OCFS2_I(inode)); 73 *flags = OCFS2_I(inode)->ip_attr; 74 ocfs2_inode_unlock(inode, 0); 75 76 return status; 77 } 78 79 static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags, 80 unsigned mask) 81 { 82 struct ocfs2_inode_info *ocfs2_inode = OCFS2_I(inode); 83 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 84 handle_t *handle = NULL; 85 struct buffer_head *bh = NULL; 86 unsigned oldflags; 87 int status; 88 89 mutex_lock(&inode->i_mutex); 90 91 status = ocfs2_inode_lock(inode, &bh, 1); 92 if (status < 0) { 93 mlog_errno(status); 94 goto bail; 95 } 96 97 status = -EACCES; 98 if (!inode_owner_or_capable(inode)) 99 goto bail_unlock; 100 101 if (!S_ISDIR(inode->i_mode)) 102 flags &= ~OCFS2_DIRSYNC_FL; 103 104 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 105 if (IS_ERR(handle)) { 106 status = PTR_ERR(handle); 107 mlog_errno(status); 108 goto bail_unlock; 109 } 110 111 oldflags = ocfs2_inode->ip_attr; 112 flags = flags & mask; 113 flags |= oldflags & ~mask; 114 115 /* 116 * The IMMUTABLE and APPEND_ONLY flags can only be changed by 117 * the relevant capability. 118 */ 119 status = -EPERM; 120 if ((oldflags & OCFS2_IMMUTABLE_FL) || ((flags ^ oldflags) & 121 (OCFS2_APPEND_FL | OCFS2_IMMUTABLE_FL))) { 122 if (!capable(CAP_LINUX_IMMUTABLE)) 123 goto bail_commit; 124 } 125 126 ocfs2_inode->ip_attr = flags; 127 ocfs2_set_inode_flags(inode); 128 129 status = ocfs2_mark_inode_dirty(handle, inode, bh); 130 if (status < 0) 131 mlog_errno(status); 132 133 bail_commit: 134 ocfs2_commit_trans(osb, handle); 135 bail_unlock: 136 ocfs2_inode_unlock(inode, 1); 137 bail: 138 mutex_unlock(&inode->i_mutex); 139 140 brelse(bh); 141 142 return status; 143 } 144 145 int ocfs2_info_handle_blocksize(struct inode *inode, 146 struct ocfs2_info_request __user *req) 147 { 148 int status = -EFAULT; 149 struct ocfs2_info_blocksize oib; 150 151 if (o2info_from_user(oib, req)) 152 goto bail; 153 154 oib.ib_blocksize = inode->i_sb->s_blocksize; 155 156 o2info_set_request_filled(&oib.ib_req); 157 158 if (o2info_to_user(oib, req)) 159 goto bail; 160 161 status = 0; 162 bail: 163 if (status) 164 o2info_set_request_error(&oib.ib_req, req); 165 166 return status; 167 } 168 169 int ocfs2_info_handle_clustersize(struct inode *inode, 170 struct ocfs2_info_request __user *req) 171 { 172 int status = -EFAULT; 173 struct ocfs2_info_clustersize oic; 174 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 175 176 if (o2info_from_user(oic, req)) 177 goto bail; 178 179 oic.ic_clustersize = osb->s_clustersize; 180 181 o2info_set_request_filled(&oic.ic_req); 182 183 if (o2info_to_user(oic, req)) 184 goto bail; 185 186 status = 0; 187 bail: 188 if (status) 189 o2info_set_request_error(&oic.ic_req, req); 190 191 return status; 192 } 193 194 int ocfs2_info_handle_maxslots(struct inode *inode, 195 struct ocfs2_info_request __user *req) 196 { 197 int status = -EFAULT; 198 struct ocfs2_info_maxslots oim; 199 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 200 201 if (o2info_from_user(oim, req)) 202 goto bail; 203 204 oim.im_max_slots = osb->max_slots; 205 206 o2info_set_request_filled(&oim.im_req); 207 208 if (o2info_to_user(oim, req)) 209 goto bail; 210 211 status = 0; 212 bail: 213 if (status) 214 o2info_set_request_error(&oim.im_req, req); 215 216 return status; 217 } 218 219 int ocfs2_info_handle_label(struct inode *inode, 220 struct ocfs2_info_request __user *req) 221 { 222 int status = -EFAULT; 223 struct ocfs2_info_label oil; 224 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 225 226 if (o2info_from_user(oil, req)) 227 goto bail; 228 229 memcpy(oil.il_label, osb->vol_label, OCFS2_MAX_VOL_LABEL_LEN); 230 231 o2info_set_request_filled(&oil.il_req); 232 233 if (o2info_to_user(oil, req)) 234 goto bail; 235 236 status = 0; 237 bail: 238 if (status) 239 o2info_set_request_error(&oil.il_req, req); 240 241 return status; 242 } 243 244 int ocfs2_info_handle_uuid(struct inode *inode, 245 struct ocfs2_info_request __user *req) 246 { 247 int status = -EFAULT; 248 struct ocfs2_info_uuid oiu; 249 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 250 251 if (o2info_from_user(oiu, req)) 252 goto bail; 253 254 memcpy(oiu.iu_uuid_str, osb->uuid_str, OCFS2_TEXT_UUID_LEN + 1); 255 256 o2info_set_request_filled(&oiu.iu_req); 257 258 if (o2info_to_user(oiu, req)) 259 goto bail; 260 261 status = 0; 262 bail: 263 if (status) 264 o2info_set_request_error(&oiu.iu_req, req); 265 266 return status; 267 } 268 269 int ocfs2_info_handle_fs_features(struct inode *inode, 270 struct ocfs2_info_request __user *req) 271 { 272 int status = -EFAULT; 273 struct ocfs2_info_fs_features oif; 274 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 275 276 if (o2info_from_user(oif, req)) 277 goto bail; 278 279 oif.if_compat_features = osb->s_feature_compat; 280 oif.if_incompat_features = osb->s_feature_incompat; 281 oif.if_ro_compat_features = osb->s_feature_ro_compat; 282 283 o2info_set_request_filled(&oif.if_req); 284 285 if (o2info_to_user(oif, req)) 286 goto bail; 287 288 status = 0; 289 bail: 290 if (status) 291 o2info_set_request_error(&oif.if_req, req); 292 293 return status; 294 } 295 296 int ocfs2_info_handle_journal_size(struct inode *inode, 297 struct ocfs2_info_request __user *req) 298 { 299 int status = -EFAULT; 300 struct ocfs2_info_journal_size oij; 301 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 302 303 if (o2info_from_user(oij, req)) 304 goto bail; 305 306 oij.ij_journal_size = osb->journal->j_inode->i_size; 307 308 o2info_set_request_filled(&oij.ij_req); 309 310 if (o2info_to_user(oij, req)) 311 goto bail; 312 313 status = 0; 314 bail: 315 if (status) 316 o2info_set_request_error(&oij.ij_req, req); 317 318 return status; 319 } 320 321 int ocfs2_info_scan_inode_alloc(struct ocfs2_super *osb, 322 struct inode *inode_alloc, u64 blkno, 323 struct ocfs2_info_freeinode *fi, u32 slot) 324 { 325 int status = 0, unlock = 0; 326 327 struct buffer_head *bh = NULL; 328 struct ocfs2_dinode *dinode_alloc = NULL; 329 330 if (inode_alloc) 331 mutex_lock(&inode_alloc->i_mutex); 332 333 if (o2info_coherent(&fi->ifi_req)) { 334 status = ocfs2_inode_lock(inode_alloc, &bh, 0); 335 if (status < 0) { 336 mlog_errno(status); 337 goto bail; 338 } 339 unlock = 1; 340 } else { 341 status = ocfs2_read_blocks_sync(osb, blkno, 1, &bh); 342 if (status < 0) { 343 mlog_errno(status); 344 goto bail; 345 } 346 } 347 348 dinode_alloc = (struct ocfs2_dinode *)bh->b_data; 349 350 fi->ifi_stat[slot].lfi_total = 351 le32_to_cpu(dinode_alloc->id1.bitmap1.i_total); 352 fi->ifi_stat[slot].lfi_free = 353 le32_to_cpu(dinode_alloc->id1.bitmap1.i_total) - 354 le32_to_cpu(dinode_alloc->id1.bitmap1.i_used); 355 356 bail: 357 if (unlock) 358 ocfs2_inode_unlock(inode_alloc, 0); 359 360 if (inode_alloc) 361 mutex_unlock(&inode_alloc->i_mutex); 362 363 brelse(bh); 364 365 return status; 366 } 367 368 int ocfs2_info_handle_freeinode(struct inode *inode, 369 struct ocfs2_info_request __user *req) 370 { 371 u32 i; 372 u64 blkno = -1; 373 char namebuf[40]; 374 int status = -EFAULT, type = INODE_ALLOC_SYSTEM_INODE; 375 struct ocfs2_info_freeinode *oifi = NULL; 376 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 377 struct inode *inode_alloc = NULL; 378 379 oifi = kzalloc(sizeof(struct ocfs2_info_freeinode), GFP_KERNEL); 380 if (!oifi) { 381 status = -ENOMEM; 382 mlog_errno(status); 383 goto out_err; 384 } 385 386 if (o2info_from_user(*oifi, req)) 387 goto bail; 388 389 oifi->ifi_slotnum = osb->max_slots; 390 391 for (i = 0; i < oifi->ifi_slotnum; i++) { 392 if (o2info_coherent(&oifi->ifi_req)) { 393 inode_alloc = ocfs2_get_system_file_inode(osb, type, i); 394 if (!inode_alloc) { 395 mlog(ML_ERROR, "unable to get alloc inode in " 396 "slot %u\n", i); 397 status = -EIO; 398 goto bail; 399 } 400 } else { 401 ocfs2_sprintf_system_inode_name(namebuf, 402 sizeof(namebuf), 403 type, i); 404 status = ocfs2_lookup_ino_from_name(osb->sys_root_inode, 405 namebuf, 406 strlen(namebuf), 407 &blkno); 408 if (status < 0) { 409 status = -ENOENT; 410 goto bail; 411 } 412 } 413 414 status = ocfs2_info_scan_inode_alloc(osb, inode_alloc, blkno, oifi, i); 415 if (status < 0) 416 goto bail; 417 418 iput(inode_alloc); 419 inode_alloc = NULL; 420 } 421 422 o2info_set_request_filled(&oifi->ifi_req); 423 424 if (o2info_to_user(*oifi, req)) 425 goto bail; 426 427 status = 0; 428 bail: 429 if (status) 430 o2info_set_request_error(&oifi->ifi_req, req); 431 432 kfree(oifi); 433 out_err: 434 return status; 435 } 436 437 static void o2ffg_update_histogram(struct ocfs2_info_free_chunk_list *hist, 438 unsigned int chunksize) 439 { 440 int index; 441 442 index = __ilog2_u32(chunksize); 443 if (index >= OCFS2_INFO_MAX_HIST) 444 index = OCFS2_INFO_MAX_HIST - 1; 445 446 hist->fc_chunks[index]++; 447 hist->fc_clusters[index] += chunksize; 448 } 449 450 static void o2ffg_update_stats(struct ocfs2_info_freefrag_stats *stats, 451 unsigned int chunksize) 452 { 453 if (chunksize > stats->ffs_max) 454 stats->ffs_max = chunksize; 455 456 if (chunksize < stats->ffs_min) 457 stats->ffs_min = chunksize; 458 459 stats->ffs_avg += chunksize; 460 stats->ffs_free_chunks_real++; 461 } 462 463 void ocfs2_info_update_ffg(struct ocfs2_info_freefrag *ffg, 464 unsigned int chunksize) 465 { 466 o2ffg_update_histogram(&(ffg->iff_ffs.ffs_fc_hist), chunksize); 467 o2ffg_update_stats(&(ffg->iff_ffs), chunksize); 468 } 469 470 int ocfs2_info_freefrag_scan_chain(struct ocfs2_super *osb, 471 struct inode *gb_inode, 472 struct ocfs2_dinode *gb_dinode, 473 struct ocfs2_chain_rec *rec, 474 struct ocfs2_info_freefrag *ffg, 475 u32 chunks_in_group) 476 { 477 int status = 0, used; 478 u64 blkno; 479 480 struct buffer_head *bh = NULL; 481 struct ocfs2_group_desc *bg = NULL; 482 483 unsigned int max_bits, num_clusters; 484 unsigned int offset = 0, cluster, chunk; 485 unsigned int chunk_free, last_chunksize = 0; 486 487 if (!le32_to_cpu(rec->c_free)) 488 goto bail; 489 490 do { 491 if (!bg) 492 blkno = le64_to_cpu(rec->c_blkno); 493 else 494 blkno = le64_to_cpu(bg->bg_next_group); 495 496 if (bh) { 497 brelse(bh); 498 bh = NULL; 499 } 500 501 if (o2info_coherent(&ffg->iff_req)) 502 status = ocfs2_read_group_descriptor(gb_inode, 503 gb_dinode, 504 blkno, &bh); 505 else 506 status = ocfs2_read_blocks_sync(osb, blkno, 1, &bh); 507 508 if (status < 0) { 509 mlog(ML_ERROR, "Can't read the group descriptor # " 510 "%llu from device.", (unsigned long long)blkno); 511 status = -EIO; 512 goto bail; 513 } 514 515 bg = (struct ocfs2_group_desc *)bh->b_data; 516 517 if (!le16_to_cpu(bg->bg_free_bits_count)) 518 continue; 519 520 max_bits = le16_to_cpu(bg->bg_bits); 521 offset = 0; 522 523 for (chunk = 0; chunk < chunks_in_group; chunk++) { 524 /* 525 * last chunk may be not an entire one. 526 */ 527 if ((offset + ffg->iff_chunksize) > max_bits) 528 num_clusters = max_bits - offset; 529 else 530 num_clusters = ffg->iff_chunksize; 531 532 chunk_free = 0; 533 for (cluster = 0; cluster < num_clusters; cluster++) { 534 used = ocfs2_test_bit(offset, 535 (unsigned long *)bg->bg_bitmap); 536 /* 537 * - chunk_free counts free clusters in #N chunk. 538 * - last_chunksize records the size(in) clusters 539 * for the last real free chunk being counted. 540 */ 541 if (!used) { 542 last_chunksize++; 543 chunk_free++; 544 } 545 546 if (used && last_chunksize) { 547 ocfs2_info_update_ffg(ffg, 548 last_chunksize); 549 last_chunksize = 0; 550 } 551 552 offset++; 553 } 554 555 if (chunk_free == ffg->iff_chunksize) 556 ffg->iff_ffs.ffs_free_chunks++; 557 } 558 559 /* 560 * need to update the info for last free chunk. 561 */ 562 if (last_chunksize) 563 ocfs2_info_update_ffg(ffg, last_chunksize); 564 565 } while (le64_to_cpu(bg->bg_next_group)); 566 567 bail: 568 brelse(bh); 569 570 return status; 571 } 572 573 int ocfs2_info_freefrag_scan_bitmap(struct ocfs2_super *osb, 574 struct inode *gb_inode, u64 blkno, 575 struct ocfs2_info_freefrag *ffg) 576 { 577 u32 chunks_in_group; 578 int status = 0, unlock = 0, i; 579 580 struct buffer_head *bh = NULL; 581 struct ocfs2_chain_list *cl = NULL; 582 struct ocfs2_chain_rec *rec = NULL; 583 struct ocfs2_dinode *gb_dinode = NULL; 584 585 if (gb_inode) 586 mutex_lock(&gb_inode->i_mutex); 587 588 if (o2info_coherent(&ffg->iff_req)) { 589 status = ocfs2_inode_lock(gb_inode, &bh, 0); 590 if (status < 0) { 591 mlog_errno(status); 592 goto bail; 593 } 594 unlock = 1; 595 } else { 596 status = ocfs2_read_blocks_sync(osb, blkno, 1, &bh); 597 if (status < 0) { 598 mlog_errno(status); 599 goto bail; 600 } 601 } 602 603 gb_dinode = (struct ocfs2_dinode *)bh->b_data; 604 cl = &(gb_dinode->id2.i_chain); 605 606 /* 607 * Chunksize(in) clusters from userspace should be 608 * less than clusters in a group. 609 */ 610 if (ffg->iff_chunksize > le16_to_cpu(cl->cl_cpg)) { 611 status = -EINVAL; 612 goto bail; 613 } 614 615 memset(&ffg->iff_ffs, 0, sizeof(struct ocfs2_info_freefrag_stats)); 616 617 ffg->iff_ffs.ffs_min = ~0U; 618 ffg->iff_ffs.ffs_clusters = 619 le32_to_cpu(gb_dinode->id1.bitmap1.i_total); 620 ffg->iff_ffs.ffs_free_clusters = ffg->iff_ffs.ffs_clusters - 621 le32_to_cpu(gb_dinode->id1.bitmap1.i_used); 622 623 chunks_in_group = le16_to_cpu(cl->cl_cpg) / ffg->iff_chunksize + 1; 624 625 for (i = 0; i < le16_to_cpu(cl->cl_next_free_rec); i++) { 626 rec = &(cl->cl_recs[i]); 627 status = ocfs2_info_freefrag_scan_chain(osb, gb_inode, 628 gb_dinode, 629 rec, ffg, 630 chunks_in_group); 631 if (status) 632 goto bail; 633 } 634 635 if (ffg->iff_ffs.ffs_free_chunks_real) 636 ffg->iff_ffs.ffs_avg = (ffg->iff_ffs.ffs_avg / 637 ffg->iff_ffs.ffs_free_chunks_real); 638 bail: 639 if (unlock) 640 ocfs2_inode_unlock(gb_inode, 0); 641 642 if (gb_inode) 643 mutex_unlock(&gb_inode->i_mutex); 644 645 if (gb_inode) 646 iput(gb_inode); 647 648 brelse(bh); 649 650 return status; 651 } 652 653 int ocfs2_info_handle_freefrag(struct inode *inode, 654 struct ocfs2_info_request __user *req) 655 { 656 u64 blkno = -1; 657 char namebuf[40]; 658 int status = -EFAULT, type = GLOBAL_BITMAP_SYSTEM_INODE; 659 660 struct ocfs2_info_freefrag *oiff; 661 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 662 struct inode *gb_inode = NULL; 663 664 oiff = kzalloc(sizeof(struct ocfs2_info_freefrag), GFP_KERNEL); 665 if (!oiff) { 666 status = -ENOMEM; 667 mlog_errno(status); 668 goto out_err; 669 } 670 671 if (o2info_from_user(*oiff, req)) 672 goto bail; 673 /* 674 * chunksize from userspace should be power of 2. 675 */ 676 if ((oiff->iff_chunksize & (oiff->iff_chunksize - 1)) || 677 (!oiff->iff_chunksize)) { 678 status = -EINVAL; 679 goto bail; 680 } 681 682 if (o2info_coherent(&oiff->iff_req)) { 683 gb_inode = ocfs2_get_system_file_inode(osb, type, 684 OCFS2_INVALID_SLOT); 685 if (!gb_inode) { 686 mlog(ML_ERROR, "unable to get global_bitmap inode\n"); 687 status = -EIO; 688 goto bail; 689 } 690 } else { 691 ocfs2_sprintf_system_inode_name(namebuf, sizeof(namebuf), type, 692 OCFS2_INVALID_SLOT); 693 status = ocfs2_lookup_ino_from_name(osb->sys_root_inode, 694 namebuf, 695 strlen(namebuf), 696 &blkno); 697 if (status < 0) { 698 status = -ENOENT; 699 goto bail; 700 } 701 } 702 703 status = ocfs2_info_freefrag_scan_bitmap(osb, gb_inode, blkno, oiff); 704 if (status < 0) 705 goto bail; 706 707 o2info_set_request_filled(&oiff->iff_req); 708 709 if (o2info_to_user(*oiff, req)) 710 goto bail; 711 712 status = 0; 713 bail: 714 if (status) 715 o2info_set_request_error(&oiff->iff_req, req); 716 717 kfree(oiff); 718 out_err: 719 return status; 720 } 721 722 int ocfs2_info_handle_unknown(struct inode *inode, 723 struct ocfs2_info_request __user *req) 724 { 725 int status = -EFAULT; 726 struct ocfs2_info_request oir; 727 728 if (o2info_from_user(oir, req)) 729 goto bail; 730 731 o2info_clear_request_filled(&oir); 732 733 if (o2info_to_user(oir, req)) 734 goto bail; 735 736 status = 0; 737 bail: 738 if (status) 739 o2info_set_request_error(&oir, req); 740 741 return status; 742 } 743 744 /* 745 * Validate and distinguish OCFS2_IOC_INFO requests. 746 * 747 * - validate the magic number. 748 * - distinguish different requests. 749 * - validate size of different requests. 750 */ 751 int ocfs2_info_handle_request(struct inode *inode, 752 struct ocfs2_info_request __user *req) 753 { 754 int status = -EFAULT; 755 struct ocfs2_info_request oir; 756 757 if (o2info_from_user(oir, req)) 758 goto bail; 759 760 status = -EINVAL; 761 if (oir.ir_magic != OCFS2_INFO_MAGIC) 762 goto bail; 763 764 switch (oir.ir_code) { 765 case OCFS2_INFO_BLOCKSIZE: 766 if (oir.ir_size == sizeof(struct ocfs2_info_blocksize)) 767 status = ocfs2_info_handle_blocksize(inode, req); 768 break; 769 case OCFS2_INFO_CLUSTERSIZE: 770 if (oir.ir_size == sizeof(struct ocfs2_info_clustersize)) 771 status = ocfs2_info_handle_clustersize(inode, req); 772 break; 773 case OCFS2_INFO_MAXSLOTS: 774 if (oir.ir_size == sizeof(struct ocfs2_info_maxslots)) 775 status = ocfs2_info_handle_maxslots(inode, req); 776 break; 777 case OCFS2_INFO_LABEL: 778 if (oir.ir_size == sizeof(struct ocfs2_info_label)) 779 status = ocfs2_info_handle_label(inode, req); 780 break; 781 case OCFS2_INFO_UUID: 782 if (oir.ir_size == sizeof(struct ocfs2_info_uuid)) 783 status = ocfs2_info_handle_uuid(inode, req); 784 break; 785 case OCFS2_INFO_FS_FEATURES: 786 if (oir.ir_size == sizeof(struct ocfs2_info_fs_features)) 787 status = ocfs2_info_handle_fs_features(inode, req); 788 break; 789 case OCFS2_INFO_JOURNAL_SIZE: 790 if (oir.ir_size == sizeof(struct ocfs2_info_journal_size)) 791 status = ocfs2_info_handle_journal_size(inode, req); 792 break; 793 case OCFS2_INFO_FREEINODE: 794 if (oir.ir_size == sizeof(struct ocfs2_info_freeinode)) 795 status = ocfs2_info_handle_freeinode(inode, req); 796 break; 797 case OCFS2_INFO_FREEFRAG: 798 if (oir.ir_size == sizeof(struct ocfs2_info_freefrag)) 799 status = ocfs2_info_handle_freefrag(inode, req); 800 break; 801 default: 802 status = ocfs2_info_handle_unknown(inode, req); 803 break; 804 } 805 806 bail: 807 return status; 808 } 809 810 int ocfs2_get_request_ptr(struct ocfs2_info *info, int idx, 811 u64 *req_addr, int compat_flag) 812 { 813 int status = -EFAULT; 814 u64 __user *bp = NULL; 815 816 if (compat_flag) { 817 #ifdef CONFIG_COMPAT 818 /* 819 * pointer bp stores the base address of a pointers array, 820 * which collects all addresses of separate request. 821 */ 822 bp = (u64 __user *)(unsigned long)compat_ptr(info->oi_requests); 823 #else 824 BUG(); 825 #endif 826 } else 827 bp = (u64 __user *)(unsigned long)(info->oi_requests); 828 829 if (o2info_from_user(*req_addr, bp + idx)) 830 goto bail; 831 832 status = 0; 833 bail: 834 return status; 835 } 836 837 /* 838 * OCFS2_IOC_INFO handles an array of requests passed from userspace. 839 * 840 * ocfs2_info_handle() recevies a large info aggregation, grab and 841 * validate the request count from header, then break it into small 842 * pieces, later specific handlers can handle them one by one. 843 * 844 * Idea here is to make each separate request small enough to ensure 845 * a better backward&forward compatibility, since a small piece of 846 * request will be less likely to be broken if disk layout get changed. 847 */ 848 int ocfs2_info_handle(struct inode *inode, struct ocfs2_info *info, 849 int compat_flag) 850 { 851 int i, status = 0; 852 u64 req_addr; 853 struct ocfs2_info_request __user *reqp; 854 855 if ((info->oi_count > OCFS2_INFO_MAX_REQUEST) || 856 (!info->oi_requests)) { 857 status = -EINVAL; 858 goto bail; 859 } 860 861 for (i = 0; i < info->oi_count; i++) { 862 863 status = ocfs2_get_request_ptr(info, i, &req_addr, compat_flag); 864 if (status) 865 break; 866 867 reqp = (struct ocfs2_info_request *)(unsigned long)req_addr; 868 if (!reqp) { 869 status = -EINVAL; 870 goto bail; 871 } 872 873 status = ocfs2_info_handle_request(inode, reqp); 874 if (status) 875 break; 876 } 877 878 bail: 879 return status; 880 } 881 882 long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 883 { 884 struct inode *inode = filp->f_path.dentry->d_inode; 885 unsigned int flags; 886 int new_clusters; 887 int status; 888 struct ocfs2_space_resv sr; 889 struct ocfs2_new_group_input input; 890 struct reflink_arguments args; 891 const char *old_path, *new_path; 892 bool preserve; 893 struct ocfs2_info info; 894 895 switch (cmd) { 896 case OCFS2_IOC_GETFLAGS: 897 status = ocfs2_get_inode_attr(inode, &flags); 898 if (status < 0) 899 return status; 900 901 flags &= OCFS2_FL_VISIBLE; 902 return put_user(flags, (int __user *) arg); 903 case OCFS2_IOC_SETFLAGS: 904 if (get_user(flags, (int __user *) arg)) 905 return -EFAULT; 906 907 status = mnt_want_write_file(filp); 908 if (status) 909 return status; 910 status = ocfs2_set_inode_attr(inode, flags, 911 OCFS2_FL_MODIFIABLE); 912 mnt_drop_write_file(filp); 913 return status; 914 case OCFS2_IOC_RESVSP: 915 case OCFS2_IOC_RESVSP64: 916 case OCFS2_IOC_UNRESVSP: 917 case OCFS2_IOC_UNRESVSP64: 918 if (copy_from_user(&sr, (int __user *) arg, sizeof(sr))) 919 return -EFAULT; 920 921 return ocfs2_change_file_space(filp, cmd, &sr); 922 case OCFS2_IOC_GROUP_EXTEND: 923 if (!capable(CAP_SYS_RESOURCE)) 924 return -EPERM; 925 926 if (get_user(new_clusters, (int __user *)arg)) 927 return -EFAULT; 928 929 return ocfs2_group_extend(inode, new_clusters); 930 case OCFS2_IOC_GROUP_ADD: 931 case OCFS2_IOC_GROUP_ADD64: 932 if (!capable(CAP_SYS_RESOURCE)) 933 return -EPERM; 934 935 if (copy_from_user(&input, (int __user *) arg, sizeof(input))) 936 return -EFAULT; 937 938 return ocfs2_group_add(inode, &input); 939 case OCFS2_IOC_REFLINK: 940 if (copy_from_user(&args, (struct reflink_arguments *)arg, 941 sizeof(args))) 942 return -EFAULT; 943 old_path = (const char *)(unsigned long)args.old_path; 944 new_path = (const char *)(unsigned long)args.new_path; 945 preserve = (args.preserve != 0); 946 947 return ocfs2_reflink_ioctl(inode, old_path, new_path, preserve); 948 case OCFS2_IOC_INFO: 949 if (copy_from_user(&info, (struct ocfs2_info __user *)arg, 950 sizeof(struct ocfs2_info))) 951 return -EFAULT; 952 953 return ocfs2_info_handle(inode, &info, 0); 954 case FITRIM: 955 { 956 struct super_block *sb = inode->i_sb; 957 struct fstrim_range range; 958 int ret = 0; 959 960 if (!capable(CAP_SYS_ADMIN)) 961 return -EPERM; 962 963 if (copy_from_user(&range, (struct fstrim_range *)arg, 964 sizeof(range))) 965 return -EFAULT; 966 967 ret = ocfs2_trim_fs(sb, &range); 968 if (ret < 0) 969 return ret; 970 971 if (copy_to_user((struct fstrim_range *)arg, &range, 972 sizeof(range))) 973 return -EFAULT; 974 975 return 0; 976 } 977 case OCFS2_IOC_MOVE_EXT: 978 return ocfs2_ioctl_move_extents(filp, (void __user *)arg); 979 default: 980 return -ENOTTY; 981 } 982 } 983 984 #ifdef CONFIG_COMPAT 985 long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg) 986 { 987 bool preserve; 988 struct reflink_arguments args; 989 struct inode *inode = file->f_path.dentry->d_inode; 990 struct ocfs2_info info; 991 992 switch (cmd) { 993 case OCFS2_IOC32_GETFLAGS: 994 cmd = OCFS2_IOC_GETFLAGS; 995 break; 996 case OCFS2_IOC32_SETFLAGS: 997 cmd = OCFS2_IOC_SETFLAGS; 998 break; 999 case OCFS2_IOC_RESVSP: 1000 case OCFS2_IOC_RESVSP64: 1001 case OCFS2_IOC_UNRESVSP: 1002 case OCFS2_IOC_UNRESVSP64: 1003 case OCFS2_IOC_GROUP_EXTEND: 1004 case OCFS2_IOC_GROUP_ADD: 1005 case OCFS2_IOC_GROUP_ADD64: 1006 case FITRIM: 1007 break; 1008 case OCFS2_IOC_REFLINK: 1009 if (copy_from_user(&args, (struct reflink_arguments *)arg, 1010 sizeof(args))) 1011 return -EFAULT; 1012 preserve = (args.preserve != 0); 1013 1014 return ocfs2_reflink_ioctl(inode, compat_ptr(args.old_path), 1015 compat_ptr(args.new_path), preserve); 1016 case OCFS2_IOC_INFO: 1017 if (copy_from_user(&info, (struct ocfs2_info __user *)arg, 1018 sizeof(struct ocfs2_info))) 1019 return -EFAULT; 1020 1021 return ocfs2_info_handle(inode, &info, 1); 1022 case OCFS2_IOC_MOVE_EXT: 1023 break; 1024 default: 1025 return -ENOIOCTLCMD; 1026 } 1027 1028 return ocfs2_ioctl(file, cmd, arg); 1029 } 1030 #endif 1031