fs/overlayfs/util.c

   1 /*
   2  * Copyright (C) 2011 Novell Inc.
   3  * Copyright (C) 2016 Red Hat, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  */
   9
  10 #include <linux/fs.h>
  11 #include <linux/mount.h>
  12 #include <linux/slab.h>
  13 #include <linux/cred.h>
  14 #include <linux/xattr.h>
  15 #include <linux/sched/signal.h>
  16 #include "overlayfs.h"
  17 #include "ovl_entry.h"
  18
  19 int ovl_want_write(struct dentry *dentry)
  20 {
  21         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
  22         return mnt_want_write(ofs->upper_mnt);
  23 }
  24
  25 void ovl_drop_write(struct dentry *dentry)
  26 {
  27         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
  28         mnt_drop_write(ofs->upper_mnt);
  29 }
  30
  31 struct dentry *ovl_workdir(struct dentry *dentry)
  32 {
  33         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
  34         return ofs->workdir;
  35 }
  36
  37 const struct cred *ovl_override_creds(struct super_block *sb)
  38 {
  39         struct ovl_fs *ofs = sb->s_fs_info;
  40
  41         return override_creds(ofs->creator_cred);
  42 }
  43
  44 struct ovl_entry *ovl_alloc_entry(unsigned int numlower)
  45 {
  46         size_t size = offsetof(struct ovl_entry, lowerstack[numlower]);
  47         struct ovl_entry *oe = kzalloc(size, GFP_KERNEL);
  48
  49         if (oe)
  50                 oe->numlower = numlower;
  51
  52         return oe;
  53 }
  54
  55 bool ovl_dentry_remote(struct dentry *dentry)
  56 {
  57         return dentry->d_flags &
  58                 (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE |
  59                  DCACHE_OP_REAL);
  60 }
  61
  62 bool ovl_dentry_weird(struct dentry *dentry)
  63 {
  64         return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT |
  65                                   DCACHE_MANAGE_TRANSIT |
  66                                   DCACHE_OP_HASH |
  67                                   DCACHE_OP_COMPARE);
  68 }
  69
  70 enum ovl_path_type ovl_path_type(struct dentry *dentry)
  71 {
  72         struct ovl_entry *oe = dentry->d_fsdata;
  73         enum ovl_path_type type = 0;
  74
  75         if (oe->__upperdentry) {
  76                 type = __OVL_PATH_UPPER;
  77
  78                 /*
  79                  * Non-dir dentry can hold lower dentry from previous
  80                  * location.
  81                  */
  82                 if (oe->numlower && d_is_dir(dentry))
  83                         type |= __OVL_PATH_MERGE;
  84         } else {
  85                 if (oe->numlower > 1)
  86                         type |= __OVL_PATH_MERGE;
  87         }
  88         return type;
  89 }
  90
  91 void ovl_path_upper(struct dentry *dentry, struct path *path)
  92 {
  93         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
  94         struct ovl_entry *oe = dentry->d_fsdata;
  95
  96         path->mnt = ofs->upper_mnt;
  97         path->dentry = ovl_upperdentry_dereference(oe);
  98 }
  99
 100 void ovl_path_lower(struct dentry *dentry, struct path *path)
 101 {
 102         struct ovl_entry *oe = dentry->d_fsdata;
 103
 104         *path = oe->numlower ? oe->lowerstack[0] : (struct path) { NULL, NULL };
 105 }
 106
 107 enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path)
 108 {
 109         enum ovl_path_type type = ovl_path_type(dentry);
 110
 111         if (!OVL_TYPE_UPPER(type))
 112                 ovl_path_lower(dentry, path);
 113         else
 114                 ovl_path_upper(dentry, path);
 115
 116         return type;
 117 }
 118
 119 struct dentry *ovl_dentry_upper(struct dentry *dentry)
 120 {
 121         struct ovl_entry *oe = dentry->d_fsdata;
 122
 123         return ovl_upperdentry_dereference(oe);
 124 }
 125
 126 static struct dentry *__ovl_dentry_lower(struct ovl_entry *oe)
 127 {
 128         return oe->numlower ? oe->lowerstack[0].dentry : NULL;
 129 }
 130
 131 struct dentry *ovl_dentry_lower(struct dentry *dentry)
 132 {
 133         struct ovl_entry *oe = dentry->d_fsdata;
 134
 135         return __ovl_dentry_lower(oe);
 136 }
 137
 138 struct dentry *ovl_dentry_real(struct dentry *dentry)
 139 {
 140         struct ovl_entry *oe = dentry->d_fsdata;
 141         struct dentry *realdentry;
 142
 143         realdentry = ovl_upperdentry_dereference(oe);
 144         if (!realdentry)
 145                 realdentry = __ovl_dentry_lower(oe);
 146
 147         return realdentry;
 148 }
 149
 150 struct ovl_dir_cache *ovl_dir_cache(struct dentry *dentry)
 151 {
 152         struct ovl_entry *oe = dentry->d_fsdata;
 153
 154         return oe->cache;
 155 }
 156
 157 void ovl_set_dir_cache(struct dentry *dentry, struct ovl_dir_cache *cache)
 158 {
 159         struct ovl_entry *oe = dentry->d_fsdata;
 160
 161         oe->cache = cache;
 162 }
 163
 164 bool ovl_dentry_is_opaque(struct dentry *dentry)
 165 {
 166         struct ovl_entry *oe = dentry->d_fsdata;
 167         return oe->opaque;
 168 }
 169
 170 bool ovl_dentry_is_whiteout(struct dentry *dentry)
 171 {
 172         return !dentry->d_inode && ovl_dentry_is_opaque(dentry);
 173 }
 174
 175 void ovl_dentry_set_opaque(struct dentry *dentry)
 176 {
 177         struct ovl_entry *oe = dentry->d_fsdata;
 178
 179         oe->opaque = true;
 180 }
 181
 182 bool ovl_redirect_dir(struct super_block *sb)
 183 {
 184         struct ovl_fs *ofs = sb->s_fs_info;
 185
 186         return ofs->config.redirect_dir;
 187 }
 188
 189 void ovl_clear_redirect_dir(struct super_block *sb)
 190 {
 191         struct ovl_fs *ofs = sb->s_fs_info;
 192
 193         ofs->config.redirect_dir = false;
 194 }
 195
 196 const char *ovl_dentry_get_redirect(struct dentry *dentry)
 197 {
 198         struct ovl_entry *oe = dentry->d_fsdata;
 199
 200         return oe->redirect;
 201 }
 202
 203 void ovl_dentry_set_redirect(struct dentry *dentry, const char *redirect)
 204 {
 205         struct ovl_entry *oe = dentry->d_fsdata;
 206
 207         kfree(oe->redirect);
 208         oe->redirect = redirect;
 209 }
 210
 211 void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry)
 212 {
 213         struct ovl_entry *oe = dentry->d_fsdata;
 214
 215         WARN_ON(!inode_is_locked(upperdentry->d_parent->d_inode));
 216         WARN_ON(oe->__upperdentry);
 217         /*
 218          * Make sure upperdentry is consistent before making it visible to
 219          * ovl_upperdentry_dereference().
 220          */
 221         smp_wmb();
 222         oe->__upperdentry = upperdentry;
 223 }
 224
 225 void ovl_inode_init(struct inode *inode, struct inode *realinode, bool is_upper)
 226 {
 227         WRITE_ONCE(inode->i_private, (unsigned long) realinode |
 228                    (is_upper ? OVL_ISUPPER_MASK : 0));
 229 }
 230
 231 void ovl_inode_update(struct inode *inode, struct inode *upperinode)
 232 {
 233         WARN_ON(!upperinode);
 234         WARN_ON(!inode_unhashed(inode));
 235         WRITE_ONCE(inode->i_private,
 236                    (unsigned long) upperinode | OVL_ISUPPER_MASK);
 237         if (!S_ISDIR(upperinode->i_mode))
 238                 __insert_inode_hash(inode, (unsigned long) upperinode);
 239 }
 240
 241 void ovl_dentry_version_inc(struct dentry *dentry)
 242 {
 243         struct ovl_entry *oe = dentry->d_fsdata;
 244
 245         WARN_ON(!inode_is_locked(dentry->d_inode));
 246         oe->version++;
 247 }
 248
 249 u64 ovl_dentry_version_get(struct dentry *dentry)
 250 {
 251         struct ovl_entry *oe = dentry->d_fsdata;
 252
 253         WARN_ON(!inode_is_locked(dentry->d_inode));
 254         return oe->version;
 255 }
 256
 257 bool ovl_is_whiteout(struct dentry *dentry)
 258 {
 259         struct inode *inode = dentry->d_inode;
 260
 261         return inode && IS_WHITEOUT(inode);
 262 }
 263
 264 struct file *ovl_path_open(struct path *path, int flags)
 265 {
 266         return dentry_open(path, flags | O_NOATIME, current_cred());
 267 }
 268
 269 int ovl_copy_up_start(struct dentry *dentry)
 270 {
 271         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 272         struct ovl_entry *oe = dentry->d_fsdata;
 273         int err;
 274
 275         spin_lock(&ofs->copyup_wq.lock);
 276         err = wait_event_interruptible_locked(ofs->copyup_wq, !oe->copying);
 277         if (!err) {
 278                 if (oe->__upperdentry)
 279                         err = 1; /* Already copied up */
 280                 else
 281                         oe->copying = true;
 282         }
 283         spin_unlock(&ofs->copyup_wq.lock);
 284
 285         return err;
 286 }
 287
 288 void ovl_copy_up_end(struct dentry *dentry)
 289 {
 290         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 291         struct ovl_entry *oe = dentry->d_fsdata;
 292
 293         spin_lock(&ofs->copyup_wq.lock);
 294         oe->copying = false;
 295         wake_up_locked(&ofs->copyup_wq);
 296         spin_unlock(&ofs->copyup_wq.lock);
 297 }