fs/ocfs2/ioctl.c

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