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