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 #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         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         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 = i_size_read(osb->journal->j_inode);
 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                 status = -EFAULT;
 711                 goto bail;
 712         }
 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 __user *)(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 = file_inode(filp);
 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 __user *old_path;
 894         const char __user *new_path;
 895         bool preserve;
 896         struct ocfs2_info info;
 897         void __user *argp = (void __user *)arg;
 898
 899         switch (cmd) {
 900         case OCFS2_IOC_GETFLAGS:
 901                 status = ocfs2_get_inode_attr(inode, &flags);
 902                 if (status < 0)
 903                         return status;
 904
 905                 flags &= OCFS2_FL_VISIBLE;
 906                 return put_user(flags, (int __user *) arg);
 907         case OCFS2_IOC_SETFLAGS:
 908                 if (get_user(flags, (int __user *) arg))
 909                         return -EFAULT;
 910
 911                 status = mnt_want_write_file(filp);
 912                 if (status)
 913                         return status;
 914                 status = ocfs2_set_inode_attr(inode, flags,
 915                         OCFS2_FL_MODIFIABLE);
 916                 mnt_drop_write_file(filp);
 917                 return status;
 918         case OCFS2_IOC_RESVSP:
 919         case OCFS2_IOC_RESVSP64:
 920         case OCFS2_IOC_UNRESVSP:
 921         case OCFS2_IOC_UNRESVSP64:
 922                 if (copy_from_user(&sr, (int __user *) arg, sizeof(sr)))
 923                         return -EFAULT;
 924
 925                 return ocfs2_change_file_space(filp, cmd, &sr);
 926         case OCFS2_IOC_GROUP_EXTEND:
 927                 if (!capable(CAP_SYS_RESOURCE))
 928                         return -EPERM;
 929
 930                 if (get_user(new_clusters, (int __user *)arg))
 931                         return -EFAULT;
 932
 933                 status = mnt_want_write_file(filp);
 934                 if (status)
 935                         return status;
 936                 status = ocfs2_group_extend(inode, new_clusters);
 937                 mnt_drop_write_file(filp);
 938                 return status;
 939         case OCFS2_IOC_GROUP_ADD:
 940         case OCFS2_IOC_GROUP_ADD64:
 941                 if (!capable(CAP_SYS_RESOURCE))
 942                         return -EPERM;
 943
 944                 if (copy_from_user(&input, (int __user *) arg, sizeof(input)))
 945                         return -EFAULT;
 946
 947                 status = mnt_want_write_file(filp);
 948                 if (status)
 949                         return status;
 950                 status = ocfs2_group_add(inode, &input);
 951                 mnt_drop_write_file(filp);
 952                 return status;
 953         case OCFS2_IOC_REFLINK:
 954                 if (copy_from_user(&args, argp, sizeof(args)))
 955                         return -EFAULT;
 956                 old_path = (const char __user *)(unsigned long)args.old_path;
 957                 new_path = (const char __user *)(unsigned long)args.new_path;
 958                 preserve = (args.preserve != 0);
 959
 960                 return ocfs2_reflink_ioctl(inode, old_path, new_path, preserve);
 961         case OCFS2_IOC_INFO:
 962                 if (copy_from_user(&info, argp, sizeof(struct ocfs2_info)))
 963                         return -EFAULT;
 964
 965                 return ocfs2_info_handle(inode, &info, 0);
 966         case FITRIM:
 967         {
 968                 struct super_block *sb = inode->i_sb;
 969                 struct fstrim_range range;
 970                 int ret = 0;
 971
 972                 if (!capable(CAP_SYS_ADMIN))
 973                         return -EPERM;
 974
 975                 if (copy_from_user(&range, argp, sizeof(range)))
 976                         return -EFAULT;
 977
 978                 ret = ocfs2_trim_fs(sb, &range);
 979                 if (ret < 0)
 980                         return ret;
 981
 982                 if (copy_to_user(argp, &range, sizeof(range)))
 983                         return -EFAULT;
 984
 985                 return 0;
 986         }
 987         case OCFS2_IOC_MOVE_EXT:
 988                 return ocfs2_ioctl_move_extents(filp, argp);
 989         default:
 990                 return -ENOTTY;
 991         }
 992 }
 993
 994 #ifdef CONFIG_COMPAT
 995 long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 996 {
 997         bool preserve;
 998         struct reflink_arguments args;
 999         struct inode *inode = file_inode(file);
1000         struct ocfs2_info info;
1001         void __user *argp = (void __user *)arg;
1002
1003         switch (cmd) {
1004         case OCFS2_IOC32_GETFLAGS:
1005                 cmd = OCFS2_IOC_GETFLAGS;
1006                 break;
1007         case OCFS2_IOC32_SETFLAGS:
1008                 cmd = OCFS2_IOC_SETFLAGS;
1009                 break;
1010         case OCFS2_IOC_RESVSP:
1011         case OCFS2_IOC_RESVSP64:
1012         case OCFS2_IOC_UNRESVSP:
1013         case OCFS2_IOC_UNRESVSP64:
1014         case OCFS2_IOC_GROUP_EXTEND:
1015         case OCFS2_IOC_GROUP_ADD:
1016         case OCFS2_IOC_GROUP_ADD64:
1017         case FITRIM:
1018                 break;
1019         case OCFS2_IOC_REFLINK:
1020                 if (copy_from_user(&args, argp, sizeof(args)))
1021                         return -EFAULT;
1022                 preserve = (args.preserve != 0);
1023
1024                 return ocfs2_reflink_ioctl(inode, compat_ptr(args.old_path),
1025                                            compat_ptr(args.new_path), preserve);
1026         case OCFS2_IOC_INFO:
1027                 if (copy_from_user(&info, argp, sizeof(struct ocfs2_info)))
1028                         return -EFAULT;
1029
1030                 return ocfs2_info_handle(inode, &info, 1);
1031         case OCFS2_IOC_MOVE_EXT:
1032                 break;
1033         default:
1034                 return -ENOIOCTLCMD;
1035         }
1036
1037         return ocfs2_ioctl(file, cmd, arg);
1038 }
1039 #endif