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