~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/overlayfs/util.c

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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/exportfs.h>
 16 #include <linux/uuid.h>
 17 #include <linux/namei.h>
 18 #include <linux/ratelimit.h>
 19 #include "overlayfs.h"
 20 #include "ovl_entry.h"
 21 
 22 int ovl_want_write(struct dentry *dentry)
 23 {
 24         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 25         return mnt_want_write(ofs->upper_mnt);
 26 }
 27 
 28 void ovl_drop_write(struct dentry *dentry)
 29 {
 30         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 31         mnt_drop_write(ofs->upper_mnt);
 32 }
 33 
 34 struct dentry *ovl_workdir(struct dentry *dentry)
 35 {
 36         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 37         return ofs->workdir;
 38 }
 39 
 40 const struct cred *ovl_override_creds(struct super_block *sb)
 41 {
 42         struct ovl_fs *ofs = sb->s_fs_info;
 43 
 44         return override_creds(ofs->creator_cred);
 45 }
 46 
 47 struct super_block *ovl_same_sb(struct super_block *sb)
 48 {
 49         struct ovl_fs *ofs = sb->s_fs_info;
 50 
 51         return ofs->same_sb;
 52 }
 53 
 54 bool ovl_can_decode_fh(struct super_block *sb)
 55 {
 56         return (sb->s_export_op && sb->s_export_op->fh_to_dentry &&
 57                 !uuid_is_null(&sb->s_uuid));
 58 }
 59 
 60 struct dentry *ovl_indexdir(struct super_block *sb)
 61 {
 62         struct ovl_fs *ofs = sb->s_fs_info;
 63 
 64         return ofs->indexdir;
 65 }
 66 
 67 struct ovl_entry *ovl_alloc_entry(unsigned int numlower)
 68 {
 69         size_t size = offsetof(struct ovl_entry, lowerstack[numlower]);
 70         struct ovl_entry *oe = kzalloc(size, GFP_KERNEL);
 71 
 72         if (oe)
 73                 oe->numlower = numlower;
 74 
 75         return oe;
 76 }
 77 
 78 bool ovl_dentry_remote(struct dentry *dentry)
 79 {
 80         return dentry->d_flags &
 81                 (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE |
 82                  DCACHE_OP_REAL);
 83 }
 84 
 85 bool ovl_dentry_weird(struct dentry *dentry)
 86 {
 87         return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT |
 88                                   DCACHE_MANAGE_TRANSIT |
 89                                   DCACHE_OP_HASH |
 90                                   DCACHE_OP_COMPARE);
 91 }
 92 
 93 enum ovl_path_type ovl_path_type(struct dentry *dentry)
 94 {
 95         struct ovl_entry *oe = dentry->d_fsdata;
 96         enum ovl_path_type type = 0;
 97 
 98         if (ovl_dentry_upper(dentry)) {
 99                 type = __OVL_PATH_UPPER;
100 
101                 /*
102                  * Non-dir dentry can hold lower dentry of its copy up origin.
103                  */
104                 if (oe->numlower) {
105                         type |= __OVL_PATH_ORIGIN;
106                         if (d_is_dir(dentry))
107                                 type |= __OVL_PATH_MERGE;
108                 }
109         } else {
110                 if (oe->numlower > 1)
111                         type |= __OVL_PATH_MERGE;
112         }
113         return type;
114 }
115 
116 void ovl_path_upper(struct dentry *dentry, struct path *path)
117 {
118         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
119 
120         path->mnt = ofs->upper_mnt;
121         path->dentry = ovl_dentry_upper(dentry);
122 }
123 
124 void ovl_path_lower(struct dentry *dentry, struct path *path)
125 {
126         struct ovl_entry *oe = dentry->d_fsdata;
127 
128         *path = oe->numlower ? oe->lowerstack[0] : (struct path) { };
129 }
130 
131 enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path)
132 {
133         enum ovl_path_type type = ovl_path_type(dentry);
134 
135         if (!OVL_TYPE_UPPER(type))
136                 ovl_path_lower(dentry, path);
137         else
138                 ovl_path_upper(dentry, path);
139 
140         return type;
141 }
142 
143 struct dentry *ovl_dentry_upper(struct dentry *dentry)
144 {
145         return ovl_upperdentry_dereference(OVL_I(d_inode(dentry)));
146 }
147 
148 struct dentry *ovl_dentry_lower(struct dentry *dentry)
149 {
150         struct ovl_entry *oe = dentry->d_fsdata;
151 
152         return oe->numlower ? oe->lowerstack[0].dentry : NULL;
153 }
154 
155 struct dentry *ovl_dentry_real(struct dentry *dentry)
156 {
157         return ovl_dentry_upper(dentry) ?: ovl_dentry_lower(dentry);
158 }
159 
160 struct dentry *ovl_i_dentry_upper(struct inode *inode)
161 {
162         return ovl_upperdentry_dereference(OVL_I(inode));
163 }
164 
165 struct inode *ovl_inode_upper(struct inode *inode)
166 {
167         struct dentry *upperdentry = ovl_i_dentry_upper(inode);
168 
169         return upperdentry ? d_inode(upperdentry) : NULL;
170 }
171 
172 struct inode *ovl_inode_lower(struct inode *inode)
173 {
174         return OVL_I(inode)->lower;
175 }
176 
177 struct inode *ovl_inode_real(struct inode *inode)
178 {
179         return ovl_inode_upper(inode) ?: ovl_inode_lower(inode);
180 }
181 
182 
183 struct ovl_dir_cache *ovl_dir_cache(struct dentry *dentry)
184 {
185         return OVL_I(d_inode(dentry))->cache;
186 }
187 
188 void ovl_set_dir_cache(struct dentry *dentry, struct ovl_dir_cache *cache)
189 {
190         OVL_I(d_inode(dentry))->cache = cache;
191 }
192 
193 bool ovl_dentry_is_opaque(struct dentry *dentry)
194 {
195         struct ovl_entry *oe = dentry->d_fsdata;
196         return oe->opaque;
197 }
198 
199 bool ovl_dentry_is_whiteout(struct dentry *dentry)
200 {
201         return !dentry->d_inode && ovl_dentry_is_opaque(dentry);
202 }
203 
204 void ovl_dentry_set_opaque(struct dentry *dentry)
205 {
206         struct ovl_entry *oe = dentry->d_fsdata;
207 
208         oe->opaque = true;
209 }
210 
211 /*
212  * For hard links it's possible for ovl_dentry_upper() to return positive, while
213  * there's no actual upper alias for the inode.  Copy up code needs to know
214  * about the existence of the upper alias, so it can't use ovl_dentry_upper().
215  */
216 bool ovl_dentry_has_upper_alias(struct dentry *dentry)
217 {
218         struct ovl_entry *oe = dentry->d_fsdata;
219 
220         return oe->has_upper;
221 }
222 
223 void ovl_dentry_set_upper_alias(struct dentry *dentry)
224 {
225         struct ovl_entry *oe = dentry->d_fsdata;
226 
227         oe->has_upper = true;
228 }
229 
230 bool ovl_redirect_dir(struct super_block *sb)
231 {
232         struct ovl_fs *ofs = sb->s_fs_info;
233 
234         return ofs->config.redirect_dir && !ofs->noxattr;
235 }
236 
237 const char *ovl_dentry_get_redirect(struct dentry *dentry)
238 {
239         return OVL_I(d_inode(dentry))->redirect;
240 }
241 
242 void ovl_dentry_set_redirect(struct dentry *dentry, const char *redirect)
243 {
244         struct ovl_inode *oi = OVL_I(d_inode(dentry));
245 
246         kfree(oi->redirect);
247         oi->redirect = redirect;
248 }
249 
250 void ovl_inode_init(struct inode *inode, struct dentry *upperdentry,
251                     struct dentry *lowerdentry)
252 {
253         if (upperdentry)
254                 OVL_I(inode)->__upperdentry = upperdentry;
255         if (lowerdentry)
256                 OVL_I(inode)->lower = d_inode(lowerdentry);
257 
258         ovl_copyattr(d_inode(upperdentry ?: lowerdentry), inode);
259 }
260 
261 void ovl_inode_update(struct inode *inode, struct dentry *upperdentry)
262 {
263         struct inode *upperinode = d_inode(upperdentry);
264 
265         WARN_ON(OVL_I(inode)->__upperdentry);
266 
267         /*
268          * Make sure upperdentry is consistent before making it visible
269          */
270         smp_wmb();
271         OVL_I(inode)->__upperdentry = upperdentry;
272         if (!S_ISDIR(upperinode->i_mode) && inode_unhashed(inode)) {
273                 inode->i_private = upperinode;
274                 __insert_inode_hash(inode, (unsigned long) upperinode);
275         }
276 }
277 
278 void ovl_dentry_version_inc(struct dentry *dentry)
279 {
280         struct inode *inode = d_inode(dentry);
281 
282         WARN_ON(!inode_is_locked(inode));
283         OVL_I(inode)->version++;
284 }
285 
286 u64 ovl_dentry_version_get(struct dentry *dentry)
287 {
288         struct inode *inode = d_inode(dentry);
289 
290         WARN_ON(!inode_is_locked(inode));
291         return OVL_I(inode)->version;
292 }
293 
294 bool ovl_is_whiteout(struct dentry *dentry)
295 {
296         struct inode *inode = dentry->d_inode;
297 
298         return inode && IS_WHITEOUT(inode);
299 }
300 
301 struct file *ovl_path_open(struct path *path, int flags)
302 {
303         return dentry_open(path, flags | O_NOATIME, current_cred());
304 }
305 
306 int ovl_copy_up_start(struct dentry *dentry)
307 {
308         struct ovl_inode *oi = OVL_I(d_inode(dentry));
309         int err;
310 
311         err = mutex_lock_interruptible(&oi->lock);
312         if (!err && ovl_dentry_has_upper_alias(dentry)) {
313                 err = 1; /* Already copied up */
314                 mutex_unlock(&oi->lock);
315         }
316 
317         return err;
318 }
319 
320 void ovl_copy_up_end(struct dentry *dentry)
321 {
322         mutex_unlock(&OVL_I(d_inode(dentry))->lock);
323 }
324 
325 bool ovl_check_dir_xattr(struct dentry *dentry, const char *name)
326 {
327         int res;
328         char val;
329 
330         if (!d_is_dir(dentry))
331                 return false;
332 
333         res = vfs_getxattr(dentry, name, &val, 1);
334         if (res == 1 && val == 'y')
335                 return true;
336 
337         return false;
338 }
339 
340 int ovl_check_setxattr(struct dentry *dentry, struct dentry *upperdentry,
341                        const char *name, const void *value, size_t size,
342                        int xerr)
343 {
344         int err;
345         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
346 
347         if (ofs->noxattr)
348                 return xerr;
349 
350         err = ovl_do_setxattr(upperdentry, name, value, size, 0);
351 
352         if (err == -EOPNOTSUPP) {
353                 pr_warn("overlayfs: cannot set %s xattr on upper\n", name);
354                 ofs->noxattr = true;
355                 return xerr;
356         }
357 
358         return err;
359 }
360 
361 int ovl_set_impure(struct dentry *dentry, struct dentry *upperdentry)
362 {
363         int err;
364 
365         if (ovl_test_flag(OVL_IMPURE, d_inode(dentry)))
366                 return 0;
367 
368         /*
369          * Do not fail when upper doesn't support xattrs.
370          * Upper inodes won't have origin nor redirect xattr anyway.
371          */
372         err = ovl_check_setxattr(dentry, upperdentry, OVL_XATTR_IMPURE,
373                                  "y", 1, 0);
374         if (!err)
375                 ovl_set_flag(OVL_IMPURE, d_inode(dentry));
376 
377         return err;
378 }
379 
380 void ovl_set_flag(unsigned long flag, struct inode *inode)
381 {
382         set_bit(flag, &OVL_I(inode)->flags);
383 }
384 
385 bool ovl_test_flag(unsigned long flag, struct inode *inode)
386 {
387         return test_bit(flag, &OVL_I(inode)->flags);
388 }
389 
390 /**
391  * Caller must hold a reference to inode to prevent it from being freed while
392  * it is marked inuse.
393  */
394 bool ovl_inuse_trylock(struct dentry *dentry)
395 {
396         struct inode *inode = d_inode(dentry);
397         bool locked = false;
398 
399         spin_lock(&inode->i_lock);
400         if (!(inode->i_state & I_OVL_INUSE)) {
401                 inode->i_state |= I_OVL_INUSE;
402                 locked = true;
403         }
404         spin_unlock(&inode->i_lock);
405 
406         return locked;
407 }
408 
409 void ovl_inuse_unlock(struct dentry *dentry)
410 {
411         if (dentry) {
412                 struct inode *inode = d_inode(dentry);
413 
414                 spin_lock(&inode->i_lock);
415                 WARN_ON(!(inode->i_state & I_OVL_INUSE));
416                 inode->i_state &= ~I_OVL_INUSE;
417                 spin_unlock(&inode->i_lock);
418         }
419 }
420 
421 /* Caller must hold OVL_I(inode)->lock */
422 static void ovl_cleanup_index(struct dentry *dentry)
423 {
424         struct inode *dir = ovl_indexdir(dentry->d_sb)->d_inode;
425         struct dentry *lowerdentry = ovl_dentry_lower(dentry);
426         struct dentry *upperdentry = ovl_dentry_upper(dentry);
427         struct dentry *index = NULL;
428         struct inode *inode;
429         struct qstr name;
430         int err;
431 
432         err = ovl_get_index_name(lowerdentry, &name);
433         if (err)
434                 goto fail;
435 
436         inode = d_inode(upperdentry);
437         if (inode->i_nlink != 1) {
438                 pr_warn_ratelimited("overlayfs: cleanup linked index (%pd2, ino=%lu, nlink=%u)\n",
439                                     upperdentry, inode->i_ino, inode->i_nlink);
440                 /*
441                  * We either have a bug with persistent union nlink or a lower
442                  * hardlink was added while overlay is mounted. Adding a lower
443                  * hardlink and then unlinking all overlay hardlinks would drop
444                  * overlay nlink to zero before all upper inodes are unlinked.
445                  * As a safety measure, when that situation is detected, set
446                  * the overlay nlink to the index inode nlink minus one for the
447                  * index entry itself.
448                  */
449                 set_nlink(d_inode(dentry), inode->i_nlink - 1);
450                 ovl_set_nlink_upper(dentry);
451                 goto out;
452         }
453 
454         inode_lock_nested(dir, I_MUTEX_PARENT);
455         /* TODO: whiteout instead of cleanup to block future open by handle */
456         index = lookup_one_len(name.name, ovl_indexdir(dentry->d_sb), name.len);
457         err = PTR_ERR(index);
458         if (!IS_ERR(index))
459                 err = ovl_cleanup(dir, index);
460         else
461                 index = NULL;
462 
463         inode_unlock(dir);
464         if (err)
465                 goto fail;
466 
467 out:
468         dput(index);
469         return;
470 
471 fail:
472         pr_err("overlayfs: cleanup index of '%pd2' failed (%i)\n", dentry, err);
473         goto out;
474 }
475 
476 /*
477  * Operations that change overlay inode and upper inode nlink need to be
478  * synchronized with copy up for persistent nlink accounting.
479  */
480 int ovl_nlink_start(struct dentry *dentry, bool *locked)
481 {
482         struct ovl_inode *oi = OVL_I(d_inode(dentry));
483         const struct cred *old_cred;
484         int err;
485 
486         if (!d_inode(dentry) || d_is_dir(dentry))
487                 return 0;
488 
489         /*
490          * With inodes index is enabled, we store the union overlay nlink
491          * in an xattr on the index inode. When whiting out lower hardlinks
492          * we need to decrement the overlay persistent nlink, but before the
493          * first copy up, we have no upper index inode to store the xattr.
494          *
495          * As a workaround, before whiteout/rename over of a lower hardlink,
496          * copy up to create the upper index. Creating the upper index will
497          * initialize the overlay nlink, so it could be dropped if unlink
498          * or rename succeeds.
499          *
500          * TODO: implement metadata only index copy up when called with
501          *       ovl_copy_up_flags(dentry, O_PATH).
502          */
503         if (ovl_indexdir(dentry->d_sb) && !ovl_dentry_has_upper_alias(dentry) &&
504             d_inode(ovl_dentry_lower(dentry))->i_nlink > 1) {
505                 err = ovl_copy_up(dentry);
506                 if (err)
507                         return err;
508         }
509 
510         err = mutex_lock_interruptible(&oi->lock);
511         if (err)
512                 return err;
513 
514         if (!ovl_test_flag(OVL_INDEX, d_inode(dentry)))
515                 goto out;
516 
517         old_cred = ovl_override_creds(dentry->d_sb);
518         /*
519          * The overlay inode nlink should be incremented/decremented IFF the
520          * upper operation succeeds, along with nlink change of upper inode.
521          * Therefore, before link/unlink/rename, we store the union nlink
522          * value relative to the upper inode nlink in an upper inode xattr.
523          */
524         err = ovl_set_nlink_upper(dentry);
525         revert_creds(old_cred);
526 
527 out:
528         if (err)
529                 mutex_unlock(&oi->lock);
530         else
531                 *locked = true;
532 
533         return err;
534 }
535 
536 void ovl_nlink_end(struct dentry *dentry, bool locked)
537 {
538         if (locked) {
539                 if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) &&
540                     d_inode(dentry)->i_nlink == 0) {
541                         const struct cred *old_cred;
542 
543                         old_cred = ovl_override_creds(dentry->d_sb);
544                         ovl_cleanup_index(dentry);
545                         revert_creds(old_cred);
546                 }
547 
548                 mutex_unlock(&OVL_I(d_inode(dentry))->lock);
549         }
550 }
551 
552 int ovl_lock_rename_workdir(struct dentry *workdir, struct dentry *upperdir)
553 {
554         /* Workdir should not be the same as upperdir */
555         if (workdir == upperdir)
556                 goto err;
557 
558         /* Workdir should not be subdir of upperdir and vice versa */
559         if (lock_rename(workdir, upperdir) != NULL)
560                 goto err_unlock;
561 
562         return 0;
563 
564 err_unlock:
565         unlock_rename(workdir, upperdir);
566 err:
567         pr_err("overlayfs: failed to lock workdir+upperdir\n");
568         return -EIO;
569 }
570 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp