fs/ocfs2/ioctl.c

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