fs/overlayfs/util.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2011 Novell Inc.
   4  * Copyright (C) 2016 Red Hat, Inc.
   5  */
   6
   7 #include <linux/fs.h>
   8 #include <linux/mount.h>
   9 #include <linux/slab.h>
  10 #include <linux/cred.h>
  11 #include <linux/xattr.h>
  12 #include <linux/exportfs.h>
  13 #include <linux/file.h>
  14 #include <linux/fileattr.h>
  15 #include <linux/uuid.h>
  16 #include <linux/namei.h>
  17 #include <linux/ratelimit.h>
  18 #include "overlayfs.h"
  19
  20 /* Get write access to upper mnt - may fail if upper sb was remounted ro */
  21 int ovl_get_write_access(struct dentry *dentry)
  22 {
  23         struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
  24         return mnt_get_write_access(ovl_upper_mnt(ofs));
  25 }
  26
  27 /* Get write access to upper sb - may block if upper sb is frozen */
  28 void ovl_start_write(struct dentry *dentry)
  29 {
  30         struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
  31         sb_start_write(ovl_upper_mnt(ofs)->mnt_sb);
  32 }
  33
  34 int ovl_want_write(struct dentry *dentry)
  35 {
  36         struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
  37         return mnt_want_write(ovl_upper_mnt(ofs));
  38 }
  39
  40 void ovl_put_write_access(struct dentry *dentry)
  41 {
  42         struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
  43         mnt_put_write_access(ovl_upper_mnt(ofs));
  44 }
  45
  46 void ovl_end_write(struct dentry *dentry)
  47 {
  48         struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
  49         sb_end_write(ovl_upper_mnt(ofs)->mnt_sb);
  50 }
  51
  52 void ovl_drop_write(struct dentry *dentry)
  53 {
  54         struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
  55         mnt_drop_write(ovl_upper_mnt(ofs));
  56 }
  57
  58 struct dentry *ovl_workdir(struct dentry *dentry)
  59 {
  60         struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
  61         return ofs->workdir;
  62 }
  63
  64 const struct cred *ovl_override_creds(struct super_block *sb)
  65 {
  66         struct ovl_fs *ofs = OVL_FS(sb);
  67
  68         return override_creds(ofs->creator_cred);
  69 }
  70
  71 /*
  72  * Check if underlying fs supports file handles and try to determine encoding
  73  * type, in order to deduce maximum inode number used by fs.
  74  *
  75  * Return 0 if file handles are not supported.
  76  * Return 1 (FILEID_INO32_GEN) if fs uses the default 32bit inode encoding.
  77  * Return -1 if fs uses a non default encoding with unknown inode size.
  78  */
  79 int ovl_can_decode_fh(struct super_block *sb)
  80 {
  81         if (!capable(CAP_DAC_READ_SEARCH))
  82                 return 0;
  83
  84         if (!exportfs_can_decode_fh(sb->s_export_op))
  85                 return 0;
  86
  87         return sb->s_export_op->encode_fh ? -1 : FILEID_INO32_GEN;
  88 }
  89
  90 struct dentry *ovl_indexdir(struct super_block *sb)
  91 {
  92         struct ovl_fs *ofs = OVL_FS(sb);
  93
  94         return ofs->config.index ? ofs->workdir : NULL;
  95 }
  96
  97 /* Index all files on copy up. For now only enabled for NFS export */
  98 bool ovl_index_all(struct super_block *sb)
  99 {
 100         struct ovl_fs *ofs = OVL_FS(sb);
 101
 102         return ofs->config.nfs_export && ofs->config.index;
 103 }
 104
 105 /* Verify lower origin on lookup. For now only enabled for NFS export */
 106 bool ovl_verify_lower(struct super_block *sb)
 107 {
 108         struct ovl_fs *ofs = OVL_FS(sb);
 109
 110         return ofs->config.nfs_export && ofs->config.index;
 111 }
 112
 113 struct ovl_path *ovl_stack_alloc(unsigned int n)
 114 {
 115         return kcalloc(n, sizeof(struct ovl_path), GFP_KERNEL);
 116 }
 117
 118 void ovl_stack_cpy(struct ovl_path *dst, struct ovl_path *src, unsigned int n)
 119 {
 120         unsigned int i;
 121
 122         memcpy(dst, src, sizeof(struct ovl_path) * n);
 123         for (i = 0; i < n; i++)
 124                 dget(src[i].dentry);
 125 }
 126
 127 void ovl_stack_put(struct ovl_path *stack, unsigned int n)
 128 {
 129         unsigned int i;
 130
 131         for (i = 0; stack && i < n; i++)
 132                 dput(stack[i].dentry);
 133 }
 134
 135 void ovl_stack_free(struct ovl_path *stack, unsigned int n)
 136 {
 137         ovl_stack_put(stack, n);
 138         kfree(stack);
 139 }
 140
 141 struct ovl_entry *ovl_alloc_entry(unsigned int numlower)
 142 {
 143         size_t size = offsetof(struct ovl_entry, __lowerstack[numlower]);
 144         struct ovl_entry *oe = kzalloc(size, GFP_KERNEL);
 145
 146         if (oe)
 147                 oe->__numlower = numlower;
 148
 149         return oe;
 150 }
 151
 152 void ovl_free_entry(struct ovl_entry *oe)
 153 {
 154         ovl_stack_put(ovl_lowerstack(oe), ovl_numlower(oe));
 155         kfree(oe);
 156 }
 157
 158 #define OVL_D_REVALIDATE (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE)
 159
 160 bool ovl_dentry_remote(struct dentry *dentry)
 161 {
 162         return dentry->d_flags & OVL_D_REVALIDATE;
 163 }
 164
 165 void ovl_dentry_update_reval(struct dentry *dentry, struct dentry *realdentry)
 166 {
 167         if (!ovl_dentry_remote(realdentry))
 168                 return;
 169
 170         spin_lock(&dentry->d_lock);
 171         dentry->d_flags |= realdentry->d_flags & OVL_D_REVALIDATE;
 172         spin_unlock(&dentry->d_lock);
 173 }
 174
 175 void ovl_dentry_init_reval(struct dentry *dentry, struct dentry *upperdentry,
 176                            struct ovl_entry *oe)
 177 {
 178         return ovl_dentry_init_flags(dentry, upperdentry, oe, OVL_D_REVALIDATE);
 179 }
 180
 181 void ovl_dentry_init_flags(struct dentry *dentry, struct dentry *upperdentry,
 182                            struct ovl_entry *oe, unsigned int mask)
 183 {
 184         struct ovl_path *lowerstack = ovl_lowerstack(oe);
 185         unsigned int i, flags = 0;
 186
 187         if (upperdentry)
 188                 flags |= upperdentry->d_flags;
 189         for (i = 0; i < ovl_numlower(oe) && lowerstack[i].dentry; i++)
 190                 flags |= lowerstack[i].dentry->d_flags;
 191
 192         spin_lock(&dentry->d_lock);
 193         dentry->d_flags &= ~mask;
 194         dentry->d_flags |= flags & mask;
 195         spin_unlock(&dentry->d_lock);
 196 }
 197
 198 bool ovl_dentry_weird(struct dentry *dentry)
 199 {
 200         return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT |
 201                                   DCACHE_MANAGE_TRANSIT |
 202                                   DCACHE_OP_HASH |
 203                                   DCACHE_OP_COMPARE);
 204 }
 205
 206 enum ovl_path_type ovl_path_type(struct dentry *dentry)
 207 {
 208         struct ovl_entry *oe = OVL_E(dentry);
 209         enum ovl_path_type type = 0;
 210
 211         if (ovl_dentry_upper(dentry)) {
 212                 type = __OVL_PATH_UPPER;
 213
 214                 /*
 215                  * Non-dir dentry can hold lower dentry of its copy up origin.
 216                  */
 217                 if (ovl_numlower(oe)) {
 218                         if (ovl_test_flag(OVL_CONST_INO, d_inode(dentry)))
 219                                 type |= __OVL_PATH_ORIGIN;
 220                         if (d_is_dir(dentry) ||
 221                             !ovl_has_upperdata(d_inode(dentry)))
 222                                 type |= __OVL_PATH_MERGE;
 223                 }
 224         } else {
 225                 if (ovl_numlower(oe) > 1)
 226                         type |= __OVL_PATH_MERGE;
 227         }
 228         return type;
 229 }
 230
 231 void ovl_path_upper(struct dentry *dentry, struct path *path)
 232 {
 233         struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
 234
 235         path->mnt = ovl_upper_mnt(ofs);
 236         path->dentry = ovl_dentry_upper(dentry);
 237 }
 238
 239 void ovl_path_lower(struct dentry *dentry, struct path *path)
 240 {
 241         struct ovl_entry *oe = OVL_E(dentry);
 242         struct ovl_path *lowerpath = ovl_lowerstack(oe);
 243
 244         if (ovl_numlower(oe)) {
 245                 path->mnt = lowerpath->layer->mnt;
 246                 path->dentry = lowerpath->dentry;
 247         } else {
 248                 *path = (struct path) { };
 249         }
 250 }
 251
 252 void ovl_path_lowerdata(struct dentry *dentry, struct path *path)
 253 {
 254         struct ovl_entry *oe = OVL_E(dentry);
 255         struct ovl_path *lowerdata = ovl_lowerdata(oe);
 256         struct dentry *lowerdata_dentry = ovl_lowerdata_dentry(oe);
 257
 258         if (lowerdata_dentry) {
 259                 path->dentry = lowerdata_dentry;
 260                 /*
 261                  * Pairs with smp_wmb() in ovl_dentry_set_lowerdata().
 262                  * Make sure that if lowerdata->dentry is visible, then
 263                  * datapath->layer is visible as well.
 264                  */
 265                 smp_rmb();
 266                 path->mnt = READ_ONCE(lowerdata->layer)->mnt;
 267         } else {
 268                 *path = (struct path) { };
 269         }
 270 }
 271
 272 enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path)
 273 {
 274         enum ovl_path_type type = ovl_path_type(dentry);
 275
 276         if (!OVL_TYPE_UPPER(type))
 277                 ovl_path_lower(dentry, path);
 278         else
 279                 ovl_path_upper(dentry, path);
 280
 281         return type;
 282 }
 283
 284 enum ovl_path_type ovl_path_realdata(struct dentry *dentry, struct path *path)
 285 {
 286         enum ovl_path_type type = ovl_path_type(dentry);
 287
 288         WARN_ON_ONCE(d_is_dir(dentry));
 289
 290         if (!OVL_TYPE_UPPER(type) || OVL_TYPE_MERGE(type))
 291                 ovl_path_lowerdata(dentry, path);
 292         else
 293                 ovl_path_upper(dentry, path);
 294
 295         return type;
 296 }
 297
 298 struct dentry *ovl_dentry_upper(struct dentry *dentry)
 299 {
 300         return ovl_upperdentry_dereference(OVL_I(d_inode(dentry)));
 301 }
 302
 303 struct dentry *ovl_dentry_lower(struct dentry *dentry)
 304 {
 305         struct ovl_entry *oe = OVL_E(dentry);
 306
 307         return ovl_numlower(oe) ? ovl_lowerstack(oe)->dentry : NULL;
 308 }
 309
 310 const struct ovl_layer *ovl_layer_lower(struct dentry *dentry)
 311 {
 312         struct ovl_entry *oe = OVL_E(dentry);
 313
 314         return ovl_numlower(oe) ? ovl_lowerstack(oe)->layer : NULL;
 315 }
 316
 317 /*
 318  * ovl_dentry_lower() could return either a data dentry or metacopy dentry
 319  * depending on what is stored in lowerstack[0]. At times we need to find
 320  * lower dentry which has data (and not metacopy dentry). This helper
 321  * returns the lower data dentry.
 322  */
 323 struct dentry *ovl_dentry_lowerdata(struct dentry *dentry)
 324 {
 325         return ovl_lowerdata_dentry(OVL_E(dentry));
 326 }
 327
 328 int ovl_dentry_set_lowerdata(struct dentry *dentry, struct ovl_path *datapath)
 329 {
 330         struct ovl_entry *oe = OVL_E(dentry);
 331         struct ovl_path *lowerdata = ovl_lowerdata(oe);
 332         struct dentry *datadentry = datapath->dentry;
 333
 334         if (WARN_ON_ONCE(ovl_numlower(oe) <= 1))
 335                 return -EIO;
 336
 337         WRITE_ONCE(lowerdata->layer, datapath->layer);
 338         /*
 339          * Pairs with smp_rmb() in ovl_path_lowerdata().
 340          * Make sure that if lowerdata->dentry is visible, then
 341          * lowerdata->layer is visible as well.
 342          */
 343         smp_wmb();
 344         WRITE_ONCE(lowerdata->dentry, dget(datadentry));
 345
 346         ovl_dentry_update_reval(dentry, datadentry);
 347
 348         return 0;
 349 }
 350
 351 struct dentry *ovl_dentry_real(struct dentry *dentry)
 352 {
 353         return ovl_dentry_upper(dentry) ?: ovl_dentry_lower(dentry);
 354 }
 355
 356 struct dentry *ovl_i_dentry_upper(struct inode *inode)
 357 {
 358         return ovl_upperdentry_dereference(OVL_I(inode));
 359 }
 360
 361 struct inode *ovl_i_path_real(struct inode *inode, struct path *path)
 362 {
 363         struct ovl_path *lowerpath = ovl_lowerpath(OVL_I_E(inode));
 364
 365         path->dentry = ovl_i_dentry_upper(inode);
 366         if (!path->dentry) {
 367                 path->dentry = lowerpath->dentry;
 368                 path->mnt = lowerpath->layer->mnt;
 369         } else {
 370                 path->mnt = ovl_upper_mnt(OVL_FS(inode->i_sb));
 371         }
 372
 373         return path->dentry ? d_inode_rcu(path->dentry) : NULL;
 374 }
 375
 376 struct inode *ovl_inode_upper(struct inode *inode)
 377 {
 378         struct dentry *upperdentry = ovl_i_dentry_upper(inode);
 379
 380         return upperdentry ? d_inode(upperdentry) : NULL;
 381 }
 382
 383 struct inode *ovl_inode_lower(struct inode *inode)
 384 {
 385         struct ovl_path *lowerpath = ovl_lowerpath(OVL_I_E(inode));
 386
 387         return lowerpath ? d_inode(lowerpath->dentry) : NULL;
 388 }
 389
 390 struct inode *ovl_inode_real(struct inode *inode)
 391 {
 392         return ovl_inode_upper(inode) ?: ovl_inode_lower(inode);
 393 }
 394
 395 /* Return inode which contains lower data. Do not return metacopy */
 396 struct inode *ovl_inode_lowerdata(struct inode *inode)
 397 {
 398         struct dentry *lowerdata = ovl_lowerdata_dentry(OVL_I_E(inode));
 399
 400         if (WARN_ON(!S_ISREG(inode->i_mode)))
 401                 return NULL;
 402
 403         return lowerdata ? d_inode(lowerdata) : NULL;
 404 }
 405
 406 /* Return real inode which contains data. Does not return metacopy inode */
 407 struct inode *ovl_inode_realdata(struct inode *inode)
 408 {
 409         struct inode *upperinode;
 410
 411         upperinode = ovl_inode_upper(inode);
 412         if (upperinode && ovl_has_upperdata(inode))
 413                 return upperinode;
 414
 415         return ovl_inode_lowerdata(inode);
 416 }
 417
 418 const char *ovl_lowerdata_redirect(struct inode *inode)
 419 {
 420         return inode && S_ISREG(inode->i_mode) ?
 421                 OVL_I(inode)->lowerdata_redirect : NULL;
 422 }
 423
 424 struct ovl_dir_cache *ovl_dir_cache(struct inode *inode)
 425 {
 426         return inode && S_ISDIR(inode->i_mode) ? OVL_I(inode)->cache : NULL;
 427 }
 428
 429 void ovl_set_dir_cache(struct inode *inode, struct ovl_dir_cache *cache)
 430 {
 431         OVL_I(inode)->cache = cache;
 432 }
 433
 434 void ovl_dentry_set_flag(unsigned long flag, struct dentry *dentry)
 435 {
 436         set_bit(flag, OVL_E_FLAGS(dentry));
 437 }
 438
 439 void ovl_dentry_clear_flag(unsigned long flag, struct dentry *dentry)
 440 {
 441         clear_bit(flag, OVL_E_FLAGS(dentry));
 442 }
 443
 444 bool ovl_dentry_test_flag(unsigned long flag, struct dentry *dentry)
 445 {
 446         return test_bit(flag, OVL_E_FLAGS(dentry));
 447 }
 448
 449 bool ovl_dentry_is_opaque(struct dentry *dentry)
 450 {
 451         return ovl_dentry_test_flag(OVL_E_OPAQUE, dentry);
 452 }
 453
 454 bool ovl_dentry_is_whiteout(struct dentry *dentry)
 455 {
 456         return !dentry->d_inode && ovl_dentry_is_opaque(dentry);
 457 }
 458
 459 void ovl_dentry_set_opaque(struct dentry *dentry)
 460 {
 461         ovl_dentry_set_flag(OVL_E_OPAQUE, dentry);
 462 }
 463
 464 /*
 465  * For hard links and decoded file handles, it's possible for ovl_dentry_upper()
 466  * to return positive, while there's no actual upper alias for the inode.
 467  * Copy up code needs to know about the existence of the upper alias, so it
 468  * can't use ovl_dentry_upper().
 469  */
 470 bool ovl_dentry_has_upper_alias(struct dentry *dentry)
 471 {
 472         return ovl_dentry_test_flag(OVL_E_UPPER_ALIAS, dentry);
 473 }
 474
 475 void ovl_dentry_set_upper_alias(struct dentry *dentry)
 476 {
 477         ovl_dentry_set_flag(OVL_E_UPPER_ALIAS, dentry);
 478 }
 479
 480 static bool ovl_should_check_upperdata(struct inode *inode)
 481 {
 482         if (!S_ISREG(inode->i_mode))
 483                 return false;
 484
 485         if (!ovl_inode_lower(inode))
 486                 return false;
 487
 488         return true;
 489 }
 490
 491 bool ovl_has_upperdata(struct inode *inode)
 492 {
 493         if (!ovl_should_check_upperdata(inode))
 494                 return true;
 495
 496         if (!ovl_test_flag(OVL_UPPERDATA, inode))
 497                 return false;
 498         /*
 499          * Pairs with smp_wmb() in ovl_set_upperdata(). Main user of
 500          * ovl_has_upperdata() is ovl_copy_up_meta_inode_data(). Make sure
 501          * if setting of OVL_UPPERDATA is visible, then effects of writes
 502          * before that are visible too.
 503          */
 504         smp_rmb();
 505         return true;
 506 }
 507
 508 void ovl_set_upperdata(struct inode *inode)
 509 {
 510         /*
 511          * Pairs with smp_rmb() in ovl_has_upperdata(). Make sure
 512          * if OVL_UPPERDATA flag is visible, then effects of write operations
 513          * before it are visible as well.
 514          */
 515         smp_wmb();
 516         ovl_set_flag(OVL_UPPERDATA, inode);
 517 }
 518
 519 /* Caller should hold ovl_inode->lock */
 520 bool ovl_dentry_needs_data_copy_up_locked(struct dentry *dentry, int flags)
 521 {
 522         if (!ovl_open_flags_need_copy_up(flags))
 523                 return false;
 524
 525         return !ovl_test_flag(OVL_UPPERDATA, d_inode(dentry));
 526 }
 527
 528 bool ovl_dentry_needs_data_copy_up(struct dentry *dentry, int flags)
 529 {
 530         if (!ovl_open_flags_need_copy_up(flags))
 531                 return false;
 532
 533         return !ovl_has_upperdata(d_inode(dentry));
 534 }
 535
 536 const char *ovl_dentry_get_redirect(struct dentry *dentry)
 537 {
 538         return OVL_I(d_inode(dentry))->redirect;
 539 }
 540
 541 void ovl_dentry_set_redirect(struct dentry *dentry, const char *redirect)
 542 {
 543         struct ovl_inode *oi = OVL_I(d_inode(dentry));
 544
 545         kfree(oi->redirect);
 546         oi->redirect = redirect;
 547 }
 548
 549 void ovl_inode_update(struct inode *inode, struct dentry *upperdentry)
 550 {
 551         struct inode *upperinode = d_inode(upperdentry);
 552
 553         WARN_ON(OVL_I(inode)->__upperdentry);
 554
 555         /*
 556          * Make sure upperdentry is consistent before making it visible
 557          */
 558         smp_wmb();
 559         OVL_I(inode)->__upperdentry = upperdentry;
 560         if (inode_unhashed(inode)) {
 561                 inode->i_private = upperinode;
 562                 __insert_inode_hash(inode, (unsigned long) upperinode);
 563         }
 564 }
 565
 566 static void ovl_dir_version_inc(struct dentry *dentry, bool impurity)
 567 {
 568         struct inode *inode = d_inode(dentry);
 569
 570         WARN_ON(!inode_is_locked(inode));
 571         WARN_ON(!d_is_dir(dentry));
 572         /*
 573          * Version is used by readdir code to keep cache consistent.
 574          * For merge dirs (or dirs with origin) all changes need to be noted.
 575          * For non-merge dirs, cache contains only impure entries (i.e. ones
 576          * which have been copied up and have origins), so only need to note
 577          * changes to impure entries.
 578          */
 579         if (!ovl_dir_is_real(inode) || impurity)
 580                 OVL_I(inode)->version++;
 581 }
 582
 583 void ovl_dir_modified(struct dentry *dentry, bool impurity)
 584 {
 585         /* Copy mtime/ctime */
 586         ovl_copyattr(d_inode(dentry));
 587
 588         ovl_dir_version_inc(dentry, impurity);
 589 }
 590
 591 u64 ovl_inode_version_get(struct inode *inode)
 592 {
 593         WARN_ON(!inode_is_locked(inode));
 594         return OVL_I(inode)->version;
 595 }
 596
 597 bool ovl_is_whiteout(struct dentry *dentry)
 598 {
 599         struct inode *inode = dentry->d_inode;
 600
 601         return inode && IS_WHITEOUT(inode);
 602 }
 603
 604 /*
 605  * Use this over ovl_is_whiteout for upper and lower files, as it also
 606  * handles overlay.whiteout xattr whiteout files.
 607  */
 608 bool ovl_path_is_whiteout(struct ovl_fs *ofs, const struct path *path)
 609 {
 610         return ovl_is_whiteout(path->dentry) ||
 611                 ovl_path_check_xwhiteout_xattr(ofs, path);
 612 }
 613
 614 struct file *ovl_path_open(const struct path *path, int flags)
 615 {
 616         struct inode *inode = d_inode(path->dentry);
 617         struct mnt_idmap *real_idmap = mnt_idmap(path->mnt);
 618         int err, acc_mode;
 619
 620         if (flags & ~(O_ACCMODE | O_LARGEFILE))
 621                 BUG();
 622
 623         switch (flags & O_ACCMODE) {
 624         case O_RDONLY:
 625                 acc_mode = MAY_READ;
 626                 break;
 627         case O_WRONLY:
 628                 acc_mode = MAY_WRITE;
 629                 break;
 630         default:
 631                 BUG();
 632         }
 633
 634         err = inode_permission(real_idmap, inode, acc_mode | MAY_OPEN);
 635         if (err)
 636                 return ERR_PTR(err);
 637
 638         /* O_NOATIME is an optimization, don't fail if not permitted */
 639         if (inode_owner_or_capable(real_idmap, inode))
 640                 flags |= O_NOATIME;
 641
 642         return dentry_open(path, flags, current_cred());
 643 }
 644
 645 /* Caller should hold ovl_inode->lock */
 646 static bool ovl_already_copied_up_locked(struct dentry *dentry, int flags)
 647 {
 648         bool disconnected = dentry->d_flags & DCACHE_DISCONNECTED;
 649
 650         if (ovl_dentry_upper(dentry) &&
 651             (ovl_dentry_has_upper_alias(dentry) || disconnected) &&
 652             !ovl_dentry_needs_data_copy_up_locked(dentry, flags))
 653                 return true;
 654
 655         return false;
 656 }
 657
 658 bool ovl_already_copied_up(struct dentry *dentry, int flags)
 659 {
 660         bool disconnected = dentry->d_flags & DCACHE_DISCONNECTED;
 661
 662         /*
 663          * Check if copy-up has happened as well as for upper alias (in
 664          * case of hard links) is there.
 665          *
 666          * Both checks are lockless:
 667          *  - false negatives: will recheck under oi->lock
 668          *  - false positives:
 669          *    + ovl_dentry_upper() uses memory barriers to ensure the
 670          *      upper dentry is up-to-date
 671          *    + ovl_dentry_has_upper_alias() relies on locking of
 672          *      upper parent i_rwsem to prevent reordering copy-up
 673          *      with rename.
 674          */
 675         if (ovl_dentry_upper(dentry) &&
 676             (ovl_dentry_has_upper_alias(dentry) || disconnected) &&
 677             !ovl_dentry_needs_data_copy_up(dentry, flags))
 678                 return true;
 679
 680         return false;
 681 }
 682
 683 /*
 684  * The copy up "transaction" keeps an elevated mnt write count on upper mnt,
 685  * but leaves taking freeze protection on upper sb to lower level helpers.
 686  */
 687 int ovl_copy_up_start(struct dentry *dentry, int flags)
 688 {
 689         struct inode *inode = d_inode(dentry);
 690         int err;
 691
 692         err = ovl_inode_lock_interruptible(inode);
 693         if (err)
 694                 return err;
 695
 696         if (ovl_already_copied_up_locked(dentry, flags))
 697                 err = 1; /* Already copied up */
 698         else
 699                 err = ovl_get_write_access(dentry);
 700         if (err)
 701                 goto out_unlock;
 702
 703         return 0;
 704
 705 out_unlock:
 706         ovl_inode_unlock(inode);
 707         return err;
 708 }
 709
 710 void ovl_copy_up_end(struct dentry *dentry)
 711 {
 712         ovl_put_write_access(dentry);
 713         ovl_inode_unlock(d_inode(dentry));
 714 }
 715
 716 bool ovl_path_check_origin_xattr(struct ovl_fs *ofs, const struct path *path)
 717 {
 718         int res;
 719
 720         res = ovl_path_getxattr(ofs, path, OVL_XATTR_ORIGIN, NULL, 0);
 721
 722         /* Zero size value means "copied up but origin unknown" */
 723         if (res >= 0)
 724                 return true;
 725
 726         return false;
 727 }
 728
 729 bool ovl_path_check_xwhiteout_xattr(struct ovl_fs *ofs, const struct path *path)
 730 {
 731         struct dentry *dentry = path->dentry;
 732         int res;
 733
 734         /* xattr.whiteout must be a zero size regular file */
 735         if (!d_is_reg(dentry) || i_size_read(d_inode(dentry)) != 0)
 736                 return false;
 737
 738         res = ovl_path_getxattr(ofs, path, OVL_XATTR_XWHITEOUT, NULL, 0);
 739         return res >= 0;
 740 }
 741
 742 bool ovl_path_check_xwhiteouts_xattr(struct ovl_fs *ofs, const struct path *path)
 743 {
 744         struct dentry *dentry = path->dentry;
 745         int res;
 746
 747         /* xattr.whiteouts must be a directory */
 748         if (!d_is_dir(dentry))
 749                 return false;
 750
 751         res = ovl_path_getxattr(ofs, path, OVL_XATTR_XWHITEOUTS, NULL, 0);
 752         return res >= 0;
 753 }
 754
 755 /*
 756  * Load persistent uuid from xattr into s_uuid if found, or store a new
 757  * random generated value in s_uuid and in xattr.
 758  */
 759 bool ovl_init_uuid_xattr(struct super_block *sb, struct ovl_fs *ofs,
 760                          const struct path *upperpath)
 761 {
 762         bool set = false;
 763         int res;
 764
 765         /* Try to load existing persistent uuid */
 766         res = ovl_path_getxattr(ofs, upperpath, OVL_XATTR_UUID, sb->s_uuid.b,
 767                                 UUID_SIZE);
 768         if (res == UUID_SIZE)
 769                 return true;
 770
 771         if (res != -ENODATA)
 772                 goto fail;
 773
 774         /*
 775          * With uuid=auto, if uuid xattr is found, it will be used.
 776          * If uuid xattrs is not found, generate a persistent uuid only on mount
 777          * of new overlays where upper root dir is not yet marked as impure.
 778          * An upper dir is marked as impure on copy up or lookup of its subdirs.
 779          */
 780         if (ofs->config.uuid == OVL_UUID_AUTO) {
 781                 res = ovl_path_getxattr(ofs, upperpath, OVL_XATTR_IMPURE, NULL,
 782                                         0);
 783                 if (res > 0) {
 784                         /* Any mount of old overlay - downgrade to uuid=null */
 785                         ofs->config.uuid = OVL_UUID_NULL;
 786                         return true;
 787                 } else if (res == -ENODATA) {
 788                         /* First mount of new overlay - upgrade to uuid=on */
 789                         ofs->config.uuid = OVL_UUID_ON;
 790                 } else if (res < 0) {
 791                         goto fail;
 792                 }
 793
 794         }
 795
 796         /* Generate overlay instance uuid */
 797         uuid_gen(&sb->s_uuid);
 798
 799         /* Try to store persistent uuid */
 800         set = true;
 801         res = ovl_setxattr(ofs, upperpath->dentry, OVL_XATTR_UUID, sb->s_uuid.b,
 802                            UUID_SIZE);
 803         if (res == 0)
 804                 return true;
 805
 806 fail:
 807         memset(sb->s_uuid.b, 0, UUID_SIZE);
 808         ofs->config.uuid = OVL_UUID_NULL;
 809         pr_warn("failed to %s uuid (%pd2, err=%i); falling back to uuid=null.\n",
 810                 set ? "set" : "get", upperpath->dentry, res);
 811         return false;
 812 }
 813
 814 bool ovl_path_check_dir_xattr(struct ovl_fs *ofs, const struct path *path,
 815                                enum ovl_xattr ox)
 816 {
 817         int res;
 818         char val;
 819
 820         if (!d_is_dir(path->dentry))
 821                 return false;
 822
 823         res = ovl_path_getxattr(ofs, path, ox, &val, 1);
 824         if (res == 1 && val == 'y')
 825                 return true;
 826
 827         return false;
 828 }
 829
 830 #define OVL_XATTR_OPAQUE_POSTFIX        "opaque"
 831 #define OVL_XATTR_REDIRECT_POSTFIX      "redirect"
 832 #define OVL_XATTR_ORIGIN_POSTFIX        "origin"
 833 #define OVL_XATTR_IMPURE_POSTFIX        "impure"
 834 #define OVL_XATTR_NLINK_POSTFIX         "nlink"
 835 #define OVL_XATTR_UPPER_POSTFIX         "upper"
 836 #define OVL_XATTR_UUID_POSTFIX          "uuid"
 837 #define OVL_XATTR_METACOPY_POSTFIX      "metacopy"
 838 #define OVL_XATTR_PROTATTR_POSTFIX      "protattr"
 839 #define OVL_XATTR_XWHITEOUT_POSTFIX     "whiteout"
 840 #define OVL_XATTR_XWHITEOUTS_POSTFIX    "whiteouts"
 841
 842 #define OVL_XATTR_TAB_ENTRY(x) \
 843         [x] = { [false] = OVL_XATTR_TRUSTED_PREFIX x ## _POSTFIX, \
 844                 [true] = OVL_XATTR_USER_PREFIX x ## _POSTFIX }
 845
 846 const char *const ovl_xattr_table[][2] = {
 847         OVL_XATTR_TAB_ENTRY(OVL_XATTR_OPAQUE),
 848         OVL_XATTR_TAB_ENTRY(OVL_XATTR_REDIRECT),
 849         OVL_XATTR_TAB_ENTRY(OVL_XATTR_ORIGIN),
 850         OVL_XATTR_TAB_ENTRY(OVL_XATTR_IMPURE),
 851         OVL_XATTR_TAB_ENTRY(OVL_XATTR_NLINK),
 852         OVL_XATTR_TAB_ENTRY(OVL_XATTR_UPPER),
 853         OVL_XATTR_TAB_ENTRY(OVL_XATTR_UUID),
 854         OVL_XATTR_TAB_ENTRY(OVL_XATTR_METACOPY),
 855         OVL_XATTR_TAB_ENTRY(OVL_XATTR_PROTATTR),
 856         OVL_XATTR_TAB_ENTRY(OVL_XATTR_XWHITEOUT),
 857         OVL_XATTR_TAB_ENTRY(OVL_XATTR_XWHITEOUTS),
 858 };
 859
 860 int ovl_check_setxattr(struct ovl_fs *ofs, struct dentry *upperdentry,
 861                        enum ovl_xattr ox, const void *value, size_t size,
 862                        int xerr)
 863 {
 864         int err;
 865
 866         if (ofs->noxattr)
 867                 return xerr;
 868
 869         err = ovl_setxattr(ofs, upperdentry, ox, value, size);
 870
 871         if (err == -EOPNOTSUPP) {
 872                 pr_warn("cannot set %s xattr on upper\n", ovl_xattr(ofs, ox));
 873                 ofs->noxattr = true;
 874                 return xerr;
 875         }
 876
 877         return err;
 878 }
 879
 880 int ovl_set_impure(struct dentry *dentry, struct dentry *upperdentry)
 881 {
 882         struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
 883         int err;
 884
 885         if (ovl_test_flag(OVL_IMPURE, d_inode(dentry)))
 886                 return 0;
 887
 888         /*
 889          * Do not fail when upper doesn't support xattrs.
 890          * Upper inodes won't have origin nor redirect xattr anyway.
 891          */
 892         err = ovl_check_setxattr(ofs, upperdentry, OVL_XATTR_IMPURE, "y", 1, 0);
 893         if (!err)
 894                 ovl_set_flag(OVL_IMPURE, d_inode(dentry));
 895
 896         return err;
 897 }
 898
 899
 900 #define OVL_PROTATTR_MAX 32 /* Reserved for future flags */
 901
 902 void ovl_check_protattr(struct inode *inode, struct dentry *upper)
 903 {
 904         struct ovl_fs *ofs = OVL_FS(inode->i_sb);
 905         u32 iflags = inode->i_flags & OVL_PROT_I_FLAGS_MASK;
 906         char buf[OVL_PROTATTR_MAX+1];
 907         int res, n;
 908
 909         res = ovl_getxattr_upper(ofs, upper, OVL_XATTR_PROTATTR, buf,
 910                                  OVL_PROTATTR_MAX);
 911         if (res < 0)
 912                 return;
 913
 914         /*
 915          * Initialize inode flags from overlay.protattr xattr and upper inode
 916          * flags.  If upper inode has those fileattr flags set (i.e. from old
 917          * kernel), we do not clear them on ovl_get_inode(), but we will clear
 918          * them on next fileattr_set().
 919          */
 920         for (n = 0; n < res; n++) {
 921                 if (buf[n] == 'a')
 922                         iflags |= S_APPEND;
 923                 else if (buf[n] == 'i')
 924                         iflags |= S_IMMUTABLE;
 925                 else
 926                         break;
 927         }
 928
 929         if (!res || n < res) {
 930                 pr_warn_ratelimited("incompatible overlay.protattr format (%pd2, len=%d)\n",
 931                                     upper, res);
 932         } else {
 933                 inode_set_flags(inode, iflags, OVL_PROT_I_FLAGS_MASK);
 934         }
 935 }
 936
 937 int ovl_set_protattr(struct inode *inode, struct dentry *upper,
 938                       struct fileattr *fa)
 939 {
 940         struct ovl_fs *ofs = OVL_FS(inode->i_sb);
 941         char buf[OVL_PROTATTR_MAX];
 942         int len = 0, err = 0;
 943         u32 iflags = 0;
 944
 945         BUILD_BUG_ON(HWEIGHT32(OVL_PROT_FS_FLAGS_MASK) > OVL_PROTATTR_MAX);
 946
 947         if (fa->flags & FS_APPEND_FL) {
 948                 buf[len++] = 'a';
 949                 iflags |= S_APPEND;
 950         }
 951         if (fa->flags & FS_IMMUTABLE_FL) {
 952                 buf[len++] = 'i';
 953                 iflags |= S_IMMUTABLE;
 954         }
 955
 956         /*
 957          * Do not allow to set protection flags when upper doesn't support
 958          * xattrs, because we do not set those fileattr flags on upper inode.
 959          * Remove xattr if it exist and all protection flags are cleared.
 960          */
 961         if (len) {
 962                 err = ovl_check_setxattr(ofs, upper, OVL_XATTR_PROTATTR,
 963                                          buf, len, -EPERM);
 964         } else if (inode->i_flags & OVL_PROT_I_FLAGS_MASK) {
 965                 err = ovl_removexattr(ofs, upper, OVL_XATTR_PROTATTR);
 966                 if (err == -EOPNOTSUPP || err == -ENODATA)
 967                         err = 0;
 968         }
 969         if (err)
 970                 return err;
 971
 972         inode_set_flags(inode, iflags, OVL_PROT_I_FLAGS_MASK);
 973
 974         /* Mask out the fileattr flags that should not be set in upper inode */
 975         fa->flags &= ~OVL_PROT_FS_FLAGS_MASK;
 976         fa->fsx_xflags &= ~OVL_PROT_FSX_FLAGS_MASK;
 977
 978         return 0;
 979 }
 980
 981 /*
 982  * Caller must hold a reference to inode to prevent it from being freed while
 983  * it is marked inuse.
 984  */
 985 bool ovl_inuse_trylock(struct dentry *dentry)
 986 {
 987         struct inode *inode = d_inode(dentry);
 988         bool locked = false;
 989
 990         spin_lock(&inode->i_lock);
 991         if (!(inode->i_state & I_OVL_INUSE)) {
 992                 inode->i_state |= I_OVL_INUSE;
 993                 locked = true;
 994         }
 995         spin_unlock(&inode->i_lock);
 996
 997         return locked;
 998 }
 999
1000 void ovl_inuse_unlock(struct dentry *dentry)
1001 {
1002         if (dentry) {
1003                 struct inode *inode = d_inode(dentry);
1004
1005                 spin_lock(&inode->i_lock);
1006                 WARN_ON(!(inode->i_state & I_OVL_INUSE));
1007                 inode->i_state &= ~I_OVL_INUSE;
1008                 spin_unlock(&inode->i_lock);
1009         }
1010 }
1011
1012 bool ovl_is_inuse(struct dentry *dentry)
1013 {
1014         struct inode *inode = d_inode(dentry);
1015         bool inuse;
1016
1017         spin_lock(&inode->i_lock);
1018         inuse = (inode->i_state & I_OVL_INUSE);
1019         spin_unlock(&inode->i_lock);
1020
1021         return inuse;
1022 }
1023
1024 /*
1025  * Does this overlay dentry need to be indexed on copy up?
1026  */
1027 bool ovl_need_index(struct dentry *dentry)
1028 {
1029         struct dentry *lower = ovl_dentry_lower(dentry);
1030
1031         if (!lower || !ovl_indexdir(dentry->d_sb))
1032                 return false;
1033
1034         /* Index all files for NFS export and consistency verification */
1035         if (ovl_index_all(dentry->d_sb))
1036                 return true;
1037
1038         /* Index only lower hardlinks on copy up */
1039         if (!d_is_dir(lower) && d_inode(lower)->i_nlink > 1)
1040                 return true;
1041
1042         return false;
1043 }
1044
1045 /* Caller must hold OVL_I(inode)->lock */
1046 static void ovl_cleanup_index(struct dentry *dentry)
1047 {
1048         struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
1049         struct dentry *indexdir = ovl_indexdir(dentry->d_sb);
1050         struct inode *dir = indexdir->d_inode;
1051         struct dentry *lowerdentry = ovl_dentry_lower(dentry);
1052         struct dentry *upperdentry = ovl_dentry_upper(dentry);
1053         struct dentry *index = NULL;
1054         struct inode *inode;
1055         struct qstr name = { };
1056         bool got_write = false;
1057         int err;
1058
1059         err = ovl_get_index_name(ofs, lowerdentry, &name);
1060         if (err)
1061                 goto fail;
1062
1063         err = ovl_want_write(dentry);
1064         if (err)
1065                 goto fail;
1066
1067         got_write = true;
1068         inode = d_inode(upperdentry);
1069         if (!S_ISDIR(inode->i_mode) && inode->i_nlink != 1) {
1070                 pr_warn_ratelimited("cleanup linked index (%pd2, ino=%lu, nlink=%u)\n",
1071                                     upperdentry, inode->i_ino, inode->i_nlink);
1072                 /*
1073                  * We either have a bug with persistent union nlink or a lower
1074                  * hardlink was added while overlay is mounted. Adding a lower
1075                  * hardlink and then unlinking all overlay hardlinks would drop
1076                  * overlay nlink to zero before all upper inodes are unlinked.
1077                  * As a safety measure, when that situation is detected, set
1078                  * the overlay nlink to the index inode nlink minus one for the
1079                  * index entry itself.
1080                  */
1081                 set_nlink(d_inode(dentry), inode->i_nlink - 1);
1082                 ovl_set_nlink_upper(dentry);
1083                 goto out;
1084         }
1085
1086         inode_lock_nested(dir, I_MUTEX_PARENT);
1087         index = ovl_lookup_upper(ofs, name.name, indexdir, name.len);
1088         err = PTR_ERR(index);
1089         if (IS_ERR(index)) {
1090                 index = NULL;
1091         } else if (ovl_index_all(dentry->d_sb)) {
1092                 /* Whiteout orphan index to block future open by handle */
1093                 err = ovl_cleanup_and_whiteout(OVL_FS(dentry->d_sb),
1094                                                dir, index);
1095         } else {
1096                 /* Cleanup orphan index entries */
1097                 err = ovl_cleanup(ofs, dir, index);
1098         }
1099
1100         inode_unlock(dir);
1101         if (err)
1102                 goto fail;
1103
1104 out:
1105         if (got_write)
1106                 ovl_drop_write(dentry);
1107         kfree(name.name);
1108         dput(index);
1109         return;
1110
1111 fail:
1112         pr_err("cleanup index of '%pd2' failed (%i)\n", dentry, err);
1113         goto out;
1114 }
1115
1116 /*
1117  * Operations that change overlay inode and upper inode nlink need to be
1118  * synchronized with copy up for persistent nlink accounting.
1119  */
1120 int ovl_nlink_start(struct dentry *dentry)
1121 {
1122         struct inode *inode = d_inode(dentry);
1123         const struct cred *old_cred;
1124         int err;
1125
1126         if (WARN_ON(!inode))
1127                 return -ENOENT;
1128
1129         /*
1130          * With inodes index is enabled, we store the union overlay nlink
1131          * in an xattr on the index inode. When whiting out an indexed lower,
1132          * we need to decrement the overlay persistent nlink, but before the
1133          * first copy up, we have no upper index inode to store the xattr.
1134          *
1135          * As a workaround, before whiteout/rename over an indexed lower,
1136          * copy up to create the upper index. Creating the upper index will
1137          * initialize the overlay nlink, so it could be dropped if unlink
1138          * or rename succeeds.
1139          *
1140          * TODO: implement metadata only index copy up when called with
1141          *       ovl_copy_up_flags(dentry, O_PATH).
1142          */
1143         if (ovl_need_index(dentry) && !ovl_dentry_has_upper_alias(dentry)) {
1144                 err = ovl_copy_up(dentry);
1145                 if (err)
1146                         return err;
1147         }
1148
1149         err = ovl_inode_lock_interruptible(inode);
1150         if (err)
1151                 return err;
1152
1153         err = ovl_want_write(dentry);
1154         if (err)
1155                 goto out_unlock;
1156
1157         if (d_is_dir(dentry) || !ovl_test_flag(OVL_INDEX, inode))
1158                 return 0;
1159
1160         old_cred = ovl_override_creds(dentry->d_sb);
1161         /*
1162          * The overlay inode nlink should be incremented/decremented IFF the
1163          * upper operation succeeds, along with nlink change of upper inode.
1164          * Therefore, before link/unlink/rename, we store the union nlink
1165          * value relative to the upper inode nlink in an upper inode xattr.
1166          */
1167         err = ovl_set_nlink_upper(dentry);
1168         revert_creds(old_cred);
1169         if (err)
1170                 goto out_drop_write;
1171
1172         return 0;
1173
1174 out_drop_write:
1175         ovl_drop_write(dentry);
1176 out_unlock:
1177         ovl_inode_unlock(inode);
1178
1179         return err;
1180 }
1181
1182 void ovl_nlink_end(struct dentry *dentry)
1183 {
1184         struct inode *inode = d_inode(dentry);
1185
1186         ovl_drop_write(dentry);
1187
1188         if (ovl_test_flag(OVL_INDEX, inode) && inode->i_nlink == 0) {
1189                 const struct cred *old_cred;
1190
1191                 old_cred = ovl_override_creds(dentry->d_sb);
1192                 ovl_cleanup_index(dentry);
1193                 revert_creds(old_cred);
1194         }
1195
1196         ovl_inode_unlock(inode);
1197 }
1198
1199 int ovl_lock_rename_workdir(struct dentry *workdir, struct dentry *upperdir)
1200 {
1201         struct dentry *trap;
1202
1203         /* Workdir should not be the same as upperdir */
1204         if (workdir == upperdir)
1205                 goto err;
1206
1207         /* Workdir should not be subdir of upperdir and vice versa */
1208         trap = lock_rename(workdir, upperdir);
1209         if (IS_ERR(trap))
1210                 goto err;
1211         if (trap)
1212                 goto err_unlock;
1213
1214         return 0;
1215
1216 err_unlock:
1217         unlock_rename(workdir, upperdir);
1218 err:
1219         pr_err("failed to lock workdir+upperdir\n");
1220         return -EIO;
1221 }
1222
1223 /*
1224  * err < 0, 0 if no metacopy xattr, metacopy data size if xattr found.
1225  * an empty xattr returns OVL_METACOPY_MIN_SIZE to distinguish from no xattr value.
1226  */
1227 int ovl_check_metacopy_xattr(struct ovl_fs *ofs, const struct path *path,
1228                              struct ovl_metacopy *data)
1229 {
1230         int res;
1231
1232         /* Only regular files can have metacopy xattr */
1233         if (!S_ISREG(d_inode(path->dentry)->i_mode))
1234                 return 0;
1235
1236         res = ovl_path_getxattr(ofs, path, OVL_XATTR_METACOPY,
1237                                 data, data ? OVL_METACOPY_MAX_SIZE : 0);
1238         if (res < 0) {
1239                 if (res == -ENODATA || res == -EOPNOTSUPP)
1240                         return 0;
1241                 /*
1242                  * getxattr on user.* may fail with EACCES in case there's no
1243                  * read permission on the inode.  Not much we can do, other than
1244                  * tell the caller that this is not a metacopy inode.
1245                  */
1246                 if (ofs->config.userxattr && res == -EACCES)
1247                         return 0;
1248                 goto out;
1249         }
1250
1251         if (res == 0) {
1252                 /* Emulate empty data for zero size metacopy xattr */
1253                 res = OVL_METACOPY_MIN_SIZE;
1254                 if (data) {
1255                         memset(data, 0, res);
1256                         data->len = res;
1257                 }
1258         } else if (res < OVL_METACOPY_MIN_SIZE) {
1259                 pr_warn_ratelimited("metacopy file '%pd' has too small xattr\n",
1260                                     path->dentry);
1261                 return -EIO;
1262         } else if (data) {
1263                 if (data->version != 0) {
1264                         pr_warn_ratelimited("metacopy file '%pd' has unsupported version\n",
1265                                             path->dentry);
1266                         return -EIO;
1267                 }
1268                 if (res != data->len) {
1269                         pr_warn_ratelimited("metacopy file '%pd' has invalid xattr size\n",
1270                                             path->dentry);
1271                         return -EIO;
1272                 }
1273         }
1274
1275         return res;
1276 out:
1277         pr_warn_ratelimited("failed to get metacopy (%i)\n", res);
1278         return res;
1279 }
1280
1281 int ovl_set_metacopy_xattr(struct ovl_fs *ofs, struct dentry *d, struct ovl_metacopy *metacopy)
1282 {
1283         size_t len = metacopy->len;
1284
1285         /* If no flags or digest fall back to empty metacopy file */
1286         if (metacopy->version == 0 && metacopy->flags == 0 && metacopy->digest_algo == 0)
1287                 len = 0;
1288
1289         return ovl_check_setxattr(ofs, d, OVL_XATTR_METACOPY,
1290                                   metacopy, len, -EOPNOTSUPP);
1291 }
1292
1293 bool ovl_is_metacopy_dentry(struct dentry *dentry)
1294 {
1295         struct ovl_entry *oe = OVL_E(dentry);
1296
1297         if (!d_is_reg(dentry))
1298                 return false;
1299
1300         if (ovl_dentry_upper(dentry)) {
1301                 if (!ovl_has_upperdata(d_inode(dentry)))
1302                         return true;
1303                 return false;
1304         }
1305
1306         return (ovl_numlower(oe) > 1);
1307 }
1308
1309 char *ovl_get_redirect_xattr(struct ovl_fs *ofs, const struct path *path, int padding)
1310 {
1311         int res;
1312         char *s, *next, *buf = NULL;
1313
1314         res = ovl_path_getxattr(ofs, path, OVL_XATTR_REDIRECT, NULL, 0);
1315         if (res == -ENODATA || res == -EOPNOTSUPP)
1316                 return NULL;
1317         if (res < 0)
1318                 goto fail;
1319         if (res == 0)
1320                 goto invalid;
1321
1322         buf = kzalloc(res + padding + 1, GFP_KERNEL);
1323         if (!buf)
1324                 return ERR_PTR(-ENOMEM);
1325
1326         res = ovl_path_getxattr(ofs, path, OVL_XATTR_REDIRECT, buf, res);
1327         if (res < 0)
1328                 goto fail;
1329         if (res == 0)
1330                 goto invalid;
1331
1332         if (buf[0] == '/') {
1333                 for (s = buf; *s++ == '/'; s = next) {
1334                         next = strchrnul(s, '/');
1335                         if (s == next)
1336                                 goto invalid;
1337                 }
1338         } else {
1339                 if (strchr(buf, '/') != NULL)
1340                         goto invalid;
1341         }
1342
1343         return buf;
1344 invalid:
1345         pr_warn_ratelimited("invalid redirect (%s)\n", buf);
1346         res = -EINVAL;
1347         goto err_free;
1348 fail:
1349         pr_warn_ratelimited("failed to get redirect (%i)\n", res);
1350 err_free:
1351         kfree(buf);
1352         return ERR_PTR(res);
1353 }
1354
1355 /* Call with mounter creds as it may open the file */
1356 int ovl_ensure_verity_loaded(struct path *datapath)
1357 {
1358         struct inode *inode = d_inode(datapath->dentry);
1359         struct file *filp;
1360
1361         if (!fsverity_active(inode) && IS_VERITY(inode)) {
1362                 /*
1363                  * If this inode was not yet opened, the verity info hasn't been
1364                  * loaded yet, so we need to do that here to force it into memory.
1365                  */
1366                 filp = kernel_file_open(datapath, O_RDONLY, inode, current_cred());
1367                 if (IS_ERR(filp))
1368                         return PTR_ERR(filp);
1369                 fput(filp);
1370         }
1371
1372         return 0;
1373 }
1374
1375 int ovl_validate_verity(struct ovl_fs *ofs,
1376                         struct path *metapath,
1377                         struct path *datapath)
1378 {
1379         struct ovl_metacopy metacopy_data;
1380         u8 actual_digest[FS_VERITY_MAX_DIGEST_SIZE];
1381         int xattr_digest_size, digest_size;
1382         int xattr_size, err;
1383         u8 verity_algo;
1384
1385         if (!ofs->config.verity_mode ||
1386             /* Verity only works on regular files */
1387             !S_ISREG(d_inode(metapath->dentry)->i_mode))
1388                 return 0;
1389
1390         xattr_size = ovl_check_metacopy_xattr(ofs, metapath, &metacopy_data);
1391         if (xattr_size < 0)
1392                 return xattr_size;
1393
1394         if (!xattr_size || !metacopy_data.digest_algo) {
1395                 if (ofs->config.verity_mode == OVL_VERITY_REQUIRE) {
1396                         pr_warn_ratelimited("metacopy file '%pd' has no digest specified\n",
1397                                             metapath->dentry);
1398                         return -EIO;
1399                 }
1400                 return 0;
1401         }
1402
1403         xattr_digest_size = ovl_metadata_digest_size(&metacopy_data);
1404
1405         err = ovl_ensure_verity_loaded(datapath);
1406         if (err < 0) {
1407                 pr_warn_ratelimited("lower file '%pd' failed to load fs-verity info\n",
1408                                     datapath->dentry);
1409                 return -EIO;
1410         }
1411
1412         digest_size = fsverity_get_digest(d_inode(datapath->dentry), actual_digest,
1413                                           &verity_algo, NULL);
1414         if (digest_size == 0) {
1415                 pr_warn_ratelimited("lower file '%pd' has no fs-verity digest\n", datapath->dentry);
1416                 return -EIO;
1417         }
1418
1419         if (xattr_digest_size != digest_size ||
1420             metacopy_data.digest_algo != verity_algo ||
1421             memcmp(metacopy_data.digest, actual_digest, xattr_digest_size) != 0) {
1422                 pr_warn_ratelimited("lower file '%pd' has the wrong fs-verity digest\n",
1423                                     datapath->dentry);
1424                 return -EIO;
1425         }
1426
1427         return 0;
1428 }
1429
1430 int ovl_get_verity_digest(struct ovl_fs *ofs, struct path *src,
1431                           struct ovl_metacopy *metacopy)
1432 {
1433         int err, digest_size;
1434
1435         if (!ofs->config.verity_mode || !S_ISREG(d_inode(src->dentry)->i_mode))
1436                 return 0;
1437
1438         err = ovl_ensure_verity_loaded(src);
1439         if (err < 0) {
1440                 pr_warn_ratelimited("lower file '%pd' failed to load fs-verity info\n",
1441                                     src->dentry);
1442                 return -EIO;
1443         }
1444
1445         digest_size = fsverity_get_digest(d_inode(src->dentry),
1446                                           metacopy->digest, &metacopy->digest_algo, NULL);
1447         if (digest_size == 0 ||
1448             WARN_ON_ONCE(digest_size > FS_VERITY_MAX_DIGEST_SIZE)) {
1449                 if (ofs->config.verity_mode == OVL_VERITY_REQUIRE) {
1450                         pr_warn_ratelimited("lower file '%pd' has no fs-verity digest\n",
1451                                             src->dentry);
1452                         return -EIO;
1453                 }
1454                 return 0;
1455         }
1456
1457         metacopy->len += digest_size;
1458         return 0;
1459 }
1460
1461 /*
1462  * ovl_sync_status() - Check fs sync status for volatile mounts
1463  *
1464  * Returns 1 if this is not a volatile mount and a real sync is required.
1465  *
1466  * Returns 0 if syncing can be skipped because mount is volatile, and no errors
1467  * have occurred on the upperdir since the mount.
1468  *
1469  * Returns -errno if it is a volatile mount, and the error that occurred since
1470  * the last mount. If the error code changes, it'll return the latest error
1471  * code.
1472  */
1473
1474 int ovl_sync_status(struct ovl_fs *ofs)
1475 {
1476         struct vfsmount *mnt;
1477
1478         if (ovl_should_sync(ofs))
1479                 return 1;
1480
1481         mnt = ovl_upper_mnt(ofs);
1482         if (!mnt)
1483                 return 0;
1484
1485         return errseq_check(&mnt->mnt_sb->s_wb_err, ofs->errseq);
1486 }
1487
1488 /*
1489  * ovl_copyattr() - copy inode attributes from layer to ovl inode
1490  *
1491  * When overlay copies inode information from an upper or lower layer to the
1492  * relevant overlay inode it will apply the idmapping of the upper or lower
1493  * layer when doing so ensuring that the ovl inode ownership will correctly
1494  * reflect the ownership of the idmapped upper or lower layer. For example, an
1495  * idmapped upper or lower layer mapping id 1001 to id 1000 will take care to
1496  * map any lower or upper inode owned by id 1001 to id 1000. These mapping
1497  * helpers are nops when the relevant layer isn't idmapped.
1498  */
1499 void ovl_copyattr(struct inode *inode)
1500 {
1501         struct path realpath;
1502         struct inode *realinode;
1503         struct mnt_idmap *real_idmap;
1504         vfsuid_t vfsuid;
1505         vfsgid_t vfsgid;
1506
1507         realinode = ovl_i_path_real(inode, &realpath);
1508         real_idmap = mnt_idmap(realpath.mnt);
1509
1510         spin_lock(&inode->i_lock);
1511         vfsuid = i_uid_into_vfsuid(real_idmap, realinode);
1512         vfsgid = i_gid_into_vfsgid(real_idmap, realinode);
1513
1514         inode->i_uid = vfsuid_into_kuid(vfsuid);
1515         inode->i_gid = vfsgid_into_kgid(vfsgid);
1516         inode->i_mode = realinode->i_mode;
1517         inode_set_atime_to_ts(inode, inode_get_atime(realinode));
1518         inode_set_mtime_to_ts(inode, inode_get_mtime(realinode));
1519         inode_set_ctime_to_ts(inode, inode_get_ctime(realinode));
1520         i_size_write(inode, i_size_read(realinode));
1521         spin_unlock(&inode->i_lock);
1522 }