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 "overlayfs.h" 16 #include "ovl_entry.h" 17 18 int ovl_want_write(struct dentry *dentry) 19 { 20 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 21 return mnt_want_write(ofs->upper_mnt); 22 } 23 24 void ovl_drop_write(struct dentry *dentry) 25 { 26 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 27 mnt_drop_write(ofs->upper_mnt); 28 } 29 30 struct dentry *ovl_workdir(struct dentry *dentry) 31 { 32 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 33 return ofs->workdir; 34 } 35 36 const struct cred *ovl_override_creds(struct super_block *sb) 37 { 38 struct ovl_fs *ofs = sb->s_fs_info; 39 40 return override_creds(ofs->creator_cred); 41 } 42 43 struct super_block *ovl_same_sb(struct super_block *sb) 44 { 45 struct ovl_fs *ofs = sb->s_fs_info; 46 47 return ofs->same_sb; 48 } 49 50 struct ovl_entry *ovl_alloc_entry(unsigned int numlower) 51 { 52 size_t size = offsetof(struct ovl_entry, lowerstack[numlower]); 53 struct ovl_entry *oe = kzalloc(size, GFP_KERNEL); 54 55 if (oe) 56 oe->numlower = numlower; 57 58 return oe; 59 } 60 61 bool ovl_dentry_remote(struct dentry *dentry) 62 { 63 return dentry->d_flags & 64 (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE | 65 DCACHE_OP_REAL); 66 } 67 68 bool ovl_dentry_weird(struct dentry *dentry) 69 { 70 return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT | 71 DCACHE_MANAGE_TRANSIT | 72 DCACHE_OP_HASH | 73 DCACHE_OP_COMPARE); 74 } 75 76 enum ovl_path_type ovl_path_type(struct dentry *dentry) 77 { 78 struct ovl_entry *oe = dentry->d_fsdata; 79 enum ovl_path_type type = 0; 80 81 if (oe->__upperdentry) { 82 type = __OVL_PATH_UPPER; 83 84 /* 85 * Non-dir dentry can hold lower dentry of its copy up origin. 86 */ 87 if (oe->numlower) { 88 type |= __OVL_PATH_ORIGIN; 89 if (d_is_dir(dentry)) 90 type |= __OVL_PATH_MERGE; 91 } 92 } else { 93 if (oe->numlower > 1) 94 type |= __OVL_PATH_MERGE; 95 } 96 return type; 97 } 98 99 void ovl_path_upper(struct dentry *dentry, struct path *path) 100 { 101 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 102 struct ovl_entry *oe = dentry->d_fsdata; 103 104 path->mnt = ofs->upper_mnt; 105 path->dentry = ovl_upperdentry_dereference(oe); 106 } 107 108 void ovl_path_lower(struct dentry *dentry, struct path *path) 109 { 110 struct ovl_entry *oe = dentry->d_fsdata; 111 112 *path = oe->numlower ? oe->lowerstack[0] : (struct path) { }; 113 } 114 115 enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path) 116 { 117 enum ovl_path_type type = ovl_path_type(dentry); 118 119 if (!OVL_TYPE_UPPER(type)) 120 ovl_path_lower(dentry, path); 121 else 122 ovl_path_upper(dentry, path); 123 124 return type; 125 } 126 127 struct dentry *ovl_dentry_upper(struct dentry *dentry) 128 { 129 struct ovl_entry *oe = dentry->d_fsdata; 130 131 return ovl_upperdentry_dereference(oe); 132 } 133 134 static struct dentry *__ovl_dentry_lower(struct ovl_entry *oe) 135 { 136 return oe->numlower ? oe->lowerstack[0].dentry : NULL; 137 } 138 139 struct dentry *ovl_dentry_lower(struct dentry *dentry) 140 { 141 struct ovl_entry *oe = dentry->d_fsdata; 142 143 return __ovl_dentry_lower(oe); 144 } 145 146 struct dentry *ovl_dentry_real(struct dentry *dentry) 147 { 148 struct ovl_entry *oe = dentry->d_fsdata; 149 struct dentry *realdentry; 150 151 realdentry = ovl_upperdentry_dereference(oe); 152 if (!realdentry) 153 realdentry = __ovl_dentry_lower(oe); 154 155 return realdentry; 156 } 157 158 struct ovl_dir_cache *ovl_dir_cache(struct dentry *dentry) 159 { 160 struct ovl_entry *oe = dentry->d_fsdata; 161 162 return oe->cache; 163 } 164 165 void ovl_set_dir_cache(struct dentry *dentry, struct ovl_dir_cache *cache) 166 { 167 struct ovl_entry *oe = dentry->d_fsdata; 168 169 oe->cache = cache; 170 } 171 172 bool ovl_dentry_is_opaque(struct dentry *dentry) 173 { 174 struct ovl_entry *oe = dentry->d_fsdata; 175 return oe->opaque; 176 } 177 178 bool ovl_dentry_is_impure(struct dentry *dentry) 179 { 180 struct ovl_entry *oe = dentry->d_fsdata; 181 182 return oe->impure; 183 } 184 185 bool ovl_dentry_is_whiteout(struct dentry *dentry) 186 { 187 return !dentry->d_inode && ovl_dentry_is_opaque(dentry); 188 } 189 190 void ovl_dentry_set_opaque(struct dentry *dentry) 191 { 192 struct ovl_entry *oe = dentry->d_fsdata; 193 194 oe->opaque = true; 195 } 196 197 bool ovl_redirect_dir(struct super_block *sb) 198 { 199 struct ovl_fs *ofs = sb->s_fs_info; 200 201 return ofs->config.redirect_dir && !ofs->noxattr; 202 } 203 204 const char *ovl_dentry_get_redirect(struct dentry *dentry) 205 { 206 struct ovl_entry *oe = dentry->d_fsdata; 207 208 return oe->redirect; 209 } 210 211 void ovl_dentry_set_redirect(struct dentry *dentry, const char *redirect) 212 { 213 struct ovl_entry *oe = dentry->d_fsdata; 214 215 kfree(oe->redirect); 216 oe->redirect = redirect; 217 } 218 219 void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry) 220 { 221 struct ovl_entry *oe = dentry->d_fsdata; 222 223 WARN_ON(!inode_is_locked(upperdentry->d_parent->d_inode)); 224 WARN_ON(oe->__upperdentry); 225 /* 226 * Make sure upperdentry is consistent before making it visible to 227 * ovl_upperdentry_dereference(). 228 */ 229 smp_wmb(); 230 oe->__upperdentry = upperdentry; 231 } 232 233 void ovl_inode_init(struct inode *inode, struct dentry *dentry) 234 { 235 struct inode *realinode = d_inode(ovl_dentry_real(dentry)); 236 bool is_upper = ovl_dentry_upper(dentry); 237 238 WRITE_ONCE(inode->i_private, (unsigned long) realinode | 239 (is_upper ? OVL_ISUPPER_MASK : 0)); 240 241 ovl_copyattr(realinode, inode); 242 } 243 244 void ovl_inode_update(struct inode *inode, struct inode *upperinode) 245 { 246 WARN_ON(!upperinode); 247 WARN_ON(!inode_unhashed(inode)); 248 WRITE_ONCE(inode->i_private, 249 (unsigned long) upperinode | OVL_ISUPPER_MASK); 250 if (!S_ISDIR(upperinode->i_mode)) 251 __insert_inode_hash(inode, (unsigned long) upperinode); 252 } 253 254 void ovl_dentry_version_inc(struct dentry *dentry) 255 { 256 struct ovl_entry *oe = dentry->d_fsdata; 257 258 WARN_ON(!inode_is_locked(dentry->d_inode)); 259 oe->version++; 260 } 261 262 u64 ovl_dentry_version_get(struct dentry *dentry) 263 { 264 struct ovl_entry *oe = dentry->d_fsdata; 265 266 WARN_ON(!inode_is_locked(dentry->d_inode)); 267 return oe->version; 268 } 269 270 bool ovl_is_whiteout(struct dentry *dentry) 271 { 272 struct inode *inode = dentry->d_inode; 273 274 return inode && IS_WHITEOUT(inode); 275 } 276 277 struct file *ovl_path_open(struct path *path, int flags) 278 { 279 return dentry_open(path, flags | O_NOATIME, current_cred()); 280 } 281 282 int ovl_copy_up_start(struct dentry *dentry) 283 { 284 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 285 struct ovl_entry *oe = dentry->d_fsdata; 286 int err; 287 288 spin_lock(&ofs->copyup_wq.lock); 289 err = wait_event_interruptible_locked(ofs->copyup_wq, !oe->copying); 290 if (!err) { 291 if (oe->__upperdentry) 292 err = 1; /* Already copied up */ 293 else 294 oe->copying = true; 295 } 296 spin_unlock(&ofs->copyup_wq.lock); 297 298 return err; 299 } 300 301 void ovl_copy_up_end(struct dentry *dentry) 302 { 303 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 304 struct ovl_entry *oe = dentry->d_fsdata; 305 306 spin_lock(&ofs->copyup_wq.lock); 307 oe->copying = false; 308 wake_up_locked(&ofs->copyup_wq); 309 spin_unlock(&ofs->copyup_wq.lock); 310 } 311 312 bool ovl_check_dir_xattr(struct dentry *dentry, const char *name) 313 { 314 int res; 315 char val; 316 317 if (!d_is_dir(dentry)) 318 return false; 319 320 res = vfs_getxattr(dentry, name, &val, 1); 321 if (res == 1 && val == 'y') 322 return true; 323 324 return false; 325 } 326 327 int ovl_check_setxattr(struct dentry *dentry, struct dentry *upperdentry, 328 const char *name, const void *value, size_t size, 329 int xerr) 330 { 331 int err; 332 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 333 334 if (ofs->noxattr) 335 return xerr; 336 337 err = ovl_do_setxattr(upperdentry, name, value, size, 0); 338 339 if (err == -EOPNOTSUPP) { 340 pr_warn("overlayfs: cannot set %s xattr on upper\n", name); 341 ofs->noxattr = true; 342 return xerr; 343 } 344 345 return err; 346 } 347 348 int ovl_set_impure(struct dentry *dentry, struct dentry *upperdentry) 349 { 350 int err; 351 struct ovl_entry *oe = dentry->d_fsdata; 352 353 if (oe->impure) 354 return 0; 355 356 /* 357 * Do not fail when upper doesn't support xattrs. 358 * Upper inodes won't have origin nor redirect xattr anyway. 359 */ 360 err = ovl_check_setxattr(dentry, upperdentry, OVL_XATTR_IMPURE, 361 "y", 1, 0); 362 if (!err) 363 oe->impure = true; 364 365 return err; 366 } 367