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

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

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ 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 
 21 int ovl_want_write(struct dentry *dentry)
 22 {
 23         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 24         return mnt_want_write(ofs->upper_mnt);
 25 }
 26 
 27 void ovl_drop_write(struct dentry *dentry)
 28 {
 29         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 30         mnt_drop_write(ofs->upper_mnt);
 31 }
 32 
 33 struct dentry *ovl_workdir(struct dentry *dentry)
 34 {
 35         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 36         return ofs->workdir;
 37 }
 38 
 39 const struct cred *ovl_override_creds(struct super_block *sb)
 40 {
 41         struct ovl_fs *ofs = sb->s_fs_info;
 42 
 43         return override_creds(ofs->creator_cred);
 44 }
 45 
 46 struct super_block *ovl_same_sb(struct super_block *sb)
 47 {
 48         struct ovl_fs *ofs = sb->s_fs_info;
 49 
 50         if (!ofs->numlowerfs)
 51                 return ofs->upper_mnt->mnt_sb;
 52         else if (ofs->numlowerfs == 1 && !ofs->upper_mnt)
 53                 return ofs->lower_fs[0].sb;
 54         else
 55                 return NULL;
 56 }
 57 
 58 /*
 59  * Check if underlying fs supports file handles and try to determine encoding
 60  * type, in order to deduce maximum inode number used by fs.
 61  *
 62  * Return 0 if file handles are not supported.
 63  * Return 1 (FILEID_INO32_GEN) if fs uses the default 32bit inode encoding.
 64  * Return -1 if fs uses a non default encoding with unknown inode size.
 65  */
 66 int ovl_can_decode_fh(struct super_block *sb)
 67 {
 68         if (!sb->s_export_op || !sb->s_export_op->fh_to_dentry)
 69                 return 0;
 70 
 71         return sb->s_export_op->encode_fh ? -1 : FILEID_INO32_GEN;
 72 }
 73 
 74 struct dentry *ovl_indexdir(struct super_block *sb)
 75 {
 76         struct ovl_fs *ofs = sb->s_fs_info;
 77 
 78         return ofs->indexdir;
 79 }
 80 
 81 /* Index all files on copy up. For now only enabled for NFS export */
 82 bool ovl_index_all(struct super_block *sb)
 83 {
 84         struct ovl_fs *ofs = sb->s_fs_info;
 85 
 86         return ofs->config.nfs_export && ofs->config.index;
 87 }
 88 
 89 /* Verify lower origin on lookup. For now only enabled for NFS export */
 90 bool ovl_verify_lower(struct super_block *sb)
 91 {
 92         struct ovl_fs *ofs = sb->s_fs_info;
 93 
 94         return ofs->config.nfs_export && ofs->config.index;
 95 }
 96 
 97 struct ovl_entry *ovl_alloc_entry(unsigned int numlower)
 98 {
 99         size_t size = offsetof(struct ovl_entry, lowerstack[numlower]);
100         struct ovl_entry *oe = kzalloc(size, GFP_KERNEL);
101 
102         if (oe)
103                 oe->numlower = numlower;
104 
105         return oe;
106 }
107 
108 bool ovl_dentry_remote(struct dentry *dentry)
109 {
110         return dentry->d_flags &
111                 (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE |
112                  DCACHE_OP_REAL);
113 }
114 
115 bool ovl_dentry_weird(struct dentry *dentry)
116 {
117         return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT |
118                                   DCACHE_MANAGE_TRANSIT |
119                                   DCACHE_OP_HASH |
120                                   DCACHE_OP_COMPARE);
121 }
122 
123 enum ovl_path_type ovl_path_type(struct dentry *dentry)
124 {
125         struct ovl_entry *oe = dentry->d_fsdata;
126         enum ovl_path_type type = 0;
127 
128         if (ovl_dentry_upper(dentry)) {
129                 type = __OVL_PATH_UPPER;
130 
131                 /*
132                  * Non-dir dentry can hold lower dentry of its copy up origin.
133                  */
134                 if (oe->numlower) {
135                         if (ovl_test_flag(OVL_CONST_INO, d_inode(dentry)))
136                                 type |= __OVL_PATH_ORIGIN;
137                         if (d_is_dir(dentry) ||
138                             !ovl_has_upperdata(d_inode(dentry)))
139                                 type |= __OVL_PATH_MERGE;
140                 }
141         } else {
142                 if (oe->numlower > 1)
143                         type |= __OVL_PATH_MERGE;
144         }
145         return type;
146 }
147 
148 void ovl_path_upper(struct dentry *dentry, struct path *path)
149 {
150         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
151 
152         path->mnt = ofs->upper_mnt;
153         path->dentry = ovl_dentry_upper(dentry);
154 }
155 
156 void ovl_path_lower(struct dentry *dentry, struct path *path)
157 {
158         struct ovl_entry *oe = dentry->d_fsdata;
159 
160         if (oe->numlower) {
161                 path->mnt = oe->lowerstack[0].layer->mnt;
162                 path->dentry = oe->lowerstack[0].dentry;
163         } else {
164                 *path = (struct path) { };
165         }
166 }
167 
168 void ovl_path_lowerdata(struct dentry *dentry, struct path *path)
169 {
170         struct ovl_entry *oe = dentry->d_fsdata;
171 
172         if (oe->numlower) {
173                 path->mnt = oe->lowerstack[oe->numlower - 1].layer->mnt;
174                 path->dentry = oe->lowerstack[oe->numlower - 1].dentry;
175         } else {
176                 *path = (struct path) { };
177         }
178 }
179 
180 enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path)
181 {
182         enum ovl_path_type type = ovl_path_type(dentry);
183 
184         if (!OVL_TYPE_UPPER(type))
185                 ovl_path_lower(dentry, path);
186         else
187                 ovl_path_upper(dentry, path);
188 
189         return type;
190 }
191 
192 struct dentry *ovl_dentry_upper(struct dentry *dentry)
193 {
194         return ovl_upperdentry_dereference(OVL_I(d_inode(dentry)));
195 }
196 
197 struct dentry *ovl_dentry_lower(struct dentry *dentry)
198 {
199         struct ovl_entry *oe = dentry->d_fsdata;
200 
201         return oe->numlower ? oe->lowerstack[0].dentry : NULL;
202 }
203 
204 struct ovl_layer *ovl_layer_lower(struct dentry *dentry)
205 {
206         struct ovl_entry *oe = dentry->d_fsdata;
207 
208         return oe->numlower ? oe->lowerstack[0].layer : NULL;
209 }
210 
211 /*
212  * ovl_dentry_lower() could return either a data dentry or metacopy dentry
213  * dependig on what is stored in lowerstack[0]. At times we need to find
214  * lower dentry which has data (and not metacopy dentry). This helper
215  * returns the lower data dentry.
216  */
217 struct dentry *ovl_dentry_lowerdata(struct dentry *dentry)
218 {
219         struct ovl_entry *oe = dentry->d_fsdata;
220 
221         return oe->numlower ? oe->lowerstack[oe->numlower - 1].dentry : NULL;
222 }
223 
224 struct dentry *ovl_dentry_real(struct dentry *dentry)
225 {
226         return ovl_dentry_upper(dentry) ?: ovl_dentry_lower(dentry);
227 }
228 
229 struct dentry *ovl_i_dentry_upper(struct inode *inode)
230 {
231         return ovl_upperdentry_dereference(OVL_I(inode));
232 }
233 
234 struct inode *ovl_inode_upper(struct inode *inode)
235 {
236         struct dentry *upperdentry = ovl_i_dentry_upper(inode);
237 
238         return upperdentry ? d_inode(upperdentry) : NULL;
239 }
240 
241 struct inode *ovl_inode_lower(struct inode *inode)
242 {
243         return OVL_I(inode)->lower;
244 }
245 
246 struct inode *ovl_inode_real(struct inode *inode)
247 {
248         return ovl_inode_upper(inode) ?: ovl_inode_lower(inode);
249 }
250 
251 /* Return inode which contains lower data. Do not return metacopy */
252 struct inode *ovl_inode_lowerdata(struct inode *inode)
253 {
254         if (WARN_ON(!S_ISREG(inode->i_mode)))
255                 return NULL;
256 
257         return OVL_I(inode)->lowerdata ?: ovl_inode_lower(inode);
258 }
259 
260 /* Return real inode which contains data. Does not return metacopy inode */
261 struct inode *ovl_inode_realdata(struct inode *inode)
262 {
263         struct inode *upperinode;
264 
265         upperinode = ovl_inode_upper(inode);
266         if (upperinode && ovl_has_upperdata(inode))
267                 return upperinode;
268 
269         return ovl_inode_lowerdata(inode);
270 }
271 
272 struct ovl_dir_cache *ovl_dir_cache(struct inode *inode)
273 {
274         return OVL_I(inode)->cache;
275 }
276 
277 void ovl_set_dir_cache(struct inode *inode, struct ovl_dir_cache *cache)
278 {
279         OVL_I(inode)->cache = cache;
280 }
281 
282 void ovl_dentry_set_flag(unsigned long flag, struct dentry *dentry)
283 {
284         set_bit(flag, &OVL_E(dentry)->flags);
285 }
286 
287 void ovl_dentry_clear_flag(unsigned long flag, struct dentry *dentry)
288 {
289         clear_bit(flag, &OVL_E(dentry)->flags);
290 }
291 
292 bool ovl_dentry_test_flag(unsigned long flag, struct dentry *dentry)
293 {
294         return test_bit(flag, &OVL_E(dentry)->flags);
295 }
296 
297 bool ovl_dentry_is_opaque(struct dentry *dentry)
298 {
299         return ovl_dentry_test_flag(OVL_E_OPAQUE, dentry);
300 }
301 
302 bool ovl_dentry_is_whiteout(struct dentry *dentry)
303 {
304         return !dentry->d_inode && ovl_dentry_is_opaque(dentry);
305 }
306 
307 void ovl_dentry_set_opaque(struct dentry *dentry)
308 {
309         ovl_dentry_set_flag(OVL_E_OPAQUE, dentry);
310 }
311 
312 /*
313  * For hard links and decoded file handles, it's possible for ovl_dentry_upper()
314  * to return positive, while there's no actual upper alias for the inode.
315  * Copy up code needs to know about the existence of the upper alias, so it
316  * can't use ovl_dentry_upper().
317  */
318 bool ovl_dentry_has_upper_alias(struct dentry *dentry)
319 {
320         return ovl_dentry_test_flag(OVL_E_UPPER_ALIAS, dentry);
321 }
322 
323 void ovl_dentry_set_upper_alias(struct dentry *dentry)
324 {
325         ovl_dentry_set_flag(OVL_E_UPPER_ALIAS, dentry);
326 }
327 
328 static bool ovl_should_check_upperdata(struct inode *inode)
329 {
330         if (!S_ISREG(inode->i_mode))
331                 return false;
332 
333         if (!ovl_inode_lower(inode))
334                 return false;
335 
336         return true;
337 }
338 
339 bool ovl_has_upperdata(struct inode *inode)
340 {
341         if (!ovl_should_check_upperdata(inode))
342                 return true;
343 
344         if (!ovl_test_flag(OVL_UPPERDATA, inode))
345                 return false;
346         /*
347          * Pairs with smp_wmb() in ovl_set_upperdata(). Main user of
348          * ovl_has_upperdata() is ovl_copy_up_meta_inode_data(). Make sure
349          * if setting of OVL_UPPERDATA is visible, then effects of writes
350          * before that are visible too.
351          */
352         smp_rmb();
353         return true;
354 }
355 
356 void ovl_set_upperdata(struct inode *inode)
357 {
358         /*
359          * Pairs with smp_rmb() in ovl_has_upperdata(). Make sure
360          * if OVL_UPPERDATA flag is visible, then effects of write operations
361          * before it are visible as well.
362          */
363         smp_wmb();
364         ovl_set_flag(OVL_UPPERDATA, inode);
365 }
366 
367 /* Caller should hold ovl_inode->lock */
368 bool ovl_dentry_needs_data_copy_up_locked(struct dentry *dentry, int flags)
369 {
370         if (!ovl_open_flags_need_copy_up(flags))
371                 return false;
372 
373         return !ovl_test_flag(OVL_UPPERDATA, d_inode(dentry));
374 }
375 
376 bool ovl_dentry_needs_data_copy_up(struct dentry *dentry, int flags)
377 {
378         if (!ovl_open_flags_need_copy_up(flags))
379                 return false;
380 
381         return !ovl_has_upperdata(d_inode(dentry));
382 }
383 
384 bool ovl_redirect_dir(struct super_block *sb)
385 {
386         struct ovl_fs *ofs = sb->s_fs_info;
387 
388         return ofs->config.redirect_dir && !ofs->noxattr;
389 }
390 
391 const char *ovl_dentry_get_redirect(struct dentry *dentry)
392 {
393         return OVL_I(d_inode(dentry))->redirect;
394 }
395 
396 void ovl_dentry_set_redirect(struct dentry *dentry, const char *redirect)
397 {
398         struct ovl_inode *oi = OVL_I(d_inode(dentry));
399 
400         kfree(oi->redirect);
401         oi->redirect = redirect;
402 }
403 
404 void ovl_inode_init(struct inode *inode, struct dentry *upperdentry,
405                     struct dentry *lowerdentry, struct dentry *lowerdata)
406 {
407         struct inode *realinode = d_inode(upperdentry ?: lowerdentry);
408 
409         if (upperdentry)
410                 OVL_I(inode)->__upperdentry = upperdentry;
411         if (lowerdentry)
412                 OVL_I(inode)->lower = igrab(d_inode(lowerdentry));
413         if (lowerdata)
414                 OVL_I(inode)->lowerdata = igrab(d_inode(lowerdata));
415 
416         ovl_copyattr(realinode, inode);
417         ovl_copyflags(realinode, inode);
418         if (!inode->i_ino)
419                 inode->i_ino = realinode->i_ino;
420 }
421 
422 void ovl_inode_update(struct inode *inode, struct dentry *upperdentry)
423 {
424         struct inode *upperinode = d_inode(upperdentry);
425 
426         WARN_ON(OVL_I(inode)->__upperdentry);
427 
428         /*
429          * Make sure upperdentry is consistent before making it visible
430          */
431         smp_wmb();
432         OVL_I(inode)->__upperdentry = upperdentry;
433         if (inode_unhashed(inode)) {
434                 if (!inode->i_ino)
435                         inode->i_ino = upperinode->i_ino;
436                 inode->i_private = upperinode;
437                 __insert_inode_hash(inode, (unsigned long) upperinode);
438         }
439 }
440 
441 static void ovl_dentry_version_inc(struct dentry *dentry, bool impurity)
442 {
443         struct inode *inode = d_inode(dentry);
444 
445         WARN_ON(!inode_is_locked(inode));
446         /*
447          * Version is used by readdir code to keep cache consistent.  For merge
448          * dirs all changes need to be noted.  For non-merge dirs, cache only
449          * contains impure (ones which have been copied up and have origins)
450          * entries, so only need to note changes to impure entries.
451          */
452         if (OVL_TYPE_MERGE(ovl_path_type(dentry)) || impurity)
453                 OVL_I(inode)->version++;
454 }
455 
456 void ovl_dir_modified(struct dentry *dentry, bool impurity)
457 {
458         /* Copy mtime/ctime */
459         ovl_copyattr(d_inode(ovl_dentry_upper(dentry)), d_inode(dentry));
460 
461         ovl_dentry_version_inc(dentry, impurity);
462 }
463 
464 u64 ovl_dentry_version_get(struct dentry *dentry)
465 {
466         struct inode *inode = d_inode(dentry);
467 
468         WARN_ON(!inode_is_locked(inode));
469         return OVL_I(inode)->version;
470 }
471 
472 bool ovl_is_whiteout(struct dentry *dentry)
473 {
474         struct inode *inode = dentry->d_inode;
475 
476         return inode && IS_WHITEOUT(inode);
477 }
478 
479 struct file *ovl_path_open(struct path *path, int flags)
480 {
481         return dentry_open(path, flags | O_NOATIME, current_cred());
482 }
483 
484 /* Caller should hold ovl_inode->lock */
485 static bool ovl_already_copied_up_locked(struct dentry *dentry, int flags)
486 {
487         bool disconnected = dentry->d_flags & DCACHE_DISCONNECTED;
488 
489         if (ovl_dentry_upper(dentry) &&
490             (ovl_dentry_has_upper_alias(dentry) || disconnected) &&
491             !ovl_dentry_needs_data_copy_up_locked(dentry, flags))
492                 return true;
493 
494         return false;
495 }
496 
497 bool ovl_already_copied_up(struct dentry *dentry, int flags)
498 {
499         bool disconnected = dentry->d_flags & DCACHE_DISCONNECTED;
500 
501         /*
502          * Check if copy-up has happened as well as for upper alias (in
503          * case of hard links) is there.
504          *
505          * Both checks are lockless:
506          *  - false negatives: will recheck under oi->lock
507          *  - false positives:
508          *    + ovl_dentry_upper() uses memory barriers to ensure the
509          *      upper dentry is up-to-date
510          *    + ovl_dentry_has_upper_alias() relies on locking of
511          *      upper parent i_rwsem to prevent reordering copy-up
512          *      with rename.
513          */
514         if (ovl_dentry_upper(dentry) &&
515             (ovl_dentry_has_upper_alias(dentry) || disconnected) &&
516             !ovl_dentry_needs_data_copy_up(dentry, flags))
517                 return true;
518 
519         return false;
520 }
521 
522 int ovl_copy_up_start(struct dentry *dentry, int flags)
523 {
524         struct inode *inode = d_inode(dentry);
525         int err;
526 
527         err = ovl_inode_lock(inode);
528         if (!err && ovl_already_copied_up_locked(dentry, flags)) {
529                 err = 1; /* Already copied up */
530                 ovl_inode_unlock(inode);
531         }
532 
533         return err;
534 }
535 
536 void ovl_copy_up_end(struct dentry *dentry)
537 {
538         ovl_inode_unlock(d_inode(dentry));
539 }
540 
541 bool ovl_check_origin_xattr(struct dentry *dentry)
542 {
543         int res;
544 
545         res = vfs_getxattr(dentry, OVL_XATTR_ORIGIN, NULL, 0);
546 
547         /* Zero size value means "copied up but origin unknown" */
548         if (res >= 0)
549                 return true;
550 
551         return false;
552 }
553 
554 bool ovl_check_dir_xattr(struct dentry *dentry, const char *name)
555 {
556         int res;
557         char val;
558 
559         if (!d_is_dir(dentry))
560                 return false;
561 
562         res = vfs_getxattr(dentry, name, &val, 1);
563         if (res == 1 && val == 'y')
564                 return true;
565 
566         return false;
567 }
568 
569 int ovl_check_setxattr(struct dentry *dentry, struct dentry *upperdentry,
570                        const char *name, const void *value, size_t size,
571                        int xerr)
572 {
573         int err;
574         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
575 
576         if (ofs->noxattr)
577                 return xerr;
578 
579         err = ovl_do_setxattr(upperdentry, name, value, size, 0);
580 
581         if (err == -EOPNOTSUPP) {
582                 pr_warn("overlayfs: cannot set %s xattr on upper\n", name);
583                 ofs->noxattr = true;
584                 return xerr;
585         }
586 
587         return err;
588 }
589 
590 int ovl_set_impure(struct dentry *dentry, struct dentry *upperdentry)
591 {
592         int err;
593 
594         if (ovl_test_flag(OVL_IMPURE, d_inode(dentry)))
595                 return 0;
596 
597         /*
598          * Do not fail when upper doesn't support xattrs.
599          * Upper inodes won't have origin nor redirect xattr anyway.
600          */
601         err = ovl_check_setxattr(dentry, upperdentry, OVL_XATTR_IMPURE,
602                                  "y", 1, 0);
603         if (!err)
604                 ovl_set_flag(OVL_IMPURE, d_inode(dentry));
605 
606         return err;
607 }
608 
609 void ovl_set_flag(unsigned long flag, struct inode *inode)
610 {
611         set_bit(flag, &OVL_I(inode)->flags);
612 }
613 
614 void ovl_clear_flag(unsigned long flag, struct inode *inode)
615 {
616         clear_bit(flag, &OVL_I(inode)->flags);
617 }
618 
619 bool ovl_test_flag(unsigned long flag, struct inode *inode)
620 {
621         return test_bit(flag, &OVL_I(inode)->flags);
622 }
623 
624 /**
625  * Caller must hold a reference to inode to prevent it from being freed while
626  * it is marked inuse.
627  */
628 bool ovl_inuse_trylock(struct dentry *dentry)
629 {
630         struct inode *inode = d_inode(dentry);
631         bool locked = false;
632 
633         spin_lock(&inode->i_lock);
634         if (!(inode->i_state & I_OVL_INUSE)) {
635                 inode->i_state |= I_OVL_INUSE;
636                 locked = true;
637         }
638         spin_unlock(&inode->i_lock);
639 
640         return locked;
641 }
642 
643 void ovl_inuse_unlock(struct dentry *dentry)
644 {
645         if (dentry) {
646                 struct inode *inode = d_inode(dentry);
647 
648                 spin_lock(&inode->i_lock);
649                 WARN_ON(!(inode->i_state & I_OVL_INUSE));
650                 inode->i_state &= ~I_OVL_INUSE;
651                 spin_unlock(&inode->i_lock);
652         }
653 }
654 
655 bool ovl_is_inuse(struct dentry *dentry)
656 {
657         struct inode *inode = d_inode(dentry);
658         bool inuse;
659 
660         spin_lock(&inode->i_lock);
661         inuse = (inode->i_state & I_OVL_INUSE);
662         spin_unlock(&inode->i_lock);
663 
664         return inuse;
665 }
666 
667 /*
668  * Does this overlay dentry need to be indexed on copy up?
669  */
670 bool ovl_need_index(struct dentry *dentry)
671 {
672         struct dentry *lower = ovl_dentry_lower(dentry);
673 
674         if (!lower || !ovl_indexdir(dentry->d_sb))
675                 return false;
676 
677         /* Index all files for NFS export and consistency verification */
678         if (ovl_index_all(dentry->d_sb))
679                 return true;
680 
681         /* Index only lower hardlinks on copy up */
682         if (!d_is_dir(lower) && d_inode(lower)->i_nlink > 1)
683                 return true;
684 
685         return false;
686 }
687 
688 /* Caller must hold OVL_I(inode)->lock */
689 static void ovl_cleanup_index(struct dentry *dentry)
690 {
691         struct dentry *indexdir = ovl_indexdir(dentry->d_sb);
692         struct inode *dir = indexdir->d_inode;
693         struct dentry *lowerdentry = ovl_dentry_lower(dentry);
694         struct dentry *upperdentry = ovl_dentry_upper(dentry);
695         struct dentry *index = NULL;
696         struct inode *inode;
697         struct qstr name = { };
698         int err;
699 
700         err = ovl_get_index_name(lowerdentry, &name);
701         if (err)
702                 goto fail;
703 
704         inode = d_inode(upperdentry);
705         if (!S_ISDIR(inode->i_mode) && inode->i_nlink != 1) {
706                 pr_warn_ratelimited("overlayfs: cleanup linked index (%pd2, ino=%lu, nlink=%u)\n",
707                                     upperdentry, inode->i_ino, inode->i_nlink);
708                 /*
709                  * We either have a bug with persistent union nlink or a lower
710                  * hardlink was added while overlay is mounted. Adding a lower
711                  * hardlink and then unlinking all overlay hardlinks would drop
712                  * overlay nlink to zero before all upper inodes are unlinked.
713                  * As a safety measure, when that situation is detected, set
714                  * the overlay nlink to the index inode nlink minus one for the
715                  * index entry itself.
716                  */
717                 set_nlink(d_inode(dentry), inode->i_nlink - 1);
718                 ovl_set_nlink_upper(dentry);
719                 goto out;
720         }
721 
722         inode_lock_nested(dir, I_MUTEX_PARENT);
723         index = lookup_one_len(name.name, indexdir, name.len);
724         err = PTR_ERR(index);
725         if (IS_ERR(index)) {
726                 index = NULL;
727         } else if (ovl_index_all(dentry->d_sb)) {
728                 /* Whiteout orphan index to block future open by handle */
729                 err = ovl_cleanup_and_whiteout(indexdir, dir, index);
730         } else {
731                 /* Cleanup orphan index entries */
732                 err = ovl_cleanup(dir, index);
733         }
734 
735         inode_unlock(dir);
736         if (err)
737                 goto fail;
738 
739 out:
740         kfree(name.name);
741         dput(index);
742         return;
743 
744 fail:
745         pr_err("overlayfs: cleanup index of '%pd2' failed (%i)\n", dentry, err);
746         goto out;
747 }
748 
749 /*
750  * Operations that change overlay inode and upper inode nlink need to be
751  * synchronized with copy up for persistent nlink accounting.
752  */
753 int ovl_nlink_start(struct dentry *dentry)
754 {
755         struct inode *inode = d_inode(dentry);
756         const struct cred *old_cred;
757         int err;
758 
759         if (WARN_ON(!inode))
760                 return -ENOENT;
761 
762         /*
763          * With inodes index is enabled, we store the union overlay nlink
764          * in an xattr on the index inode. When whiting out an indexed lower,
765          * we need to decrement the overlay persistent nlink, but before the
766          * first copy up, we have no upper index inode to store the xattr.
767          *
768          * As a workaround, before whiteout/rename over an indexed lower,
769          * copy up to create the upper index. Creating the upper index will
770          * initialize the overlay nlink, so it could be dropped if unlink
771          * or rename succeeds.
772          *
773          * TODO: implement metadata only index copy up when called with
774          *       ovl_copy_up_flags(dentry, O_PATH).
775          */
776         if (ovl_need_index(dentry) && !ovl_dentry_has_upper_alias(dentry)) {
777                 err = ovl_copy_up(dentry);
778                 if (err)
779                         return err;
780         }
781 
782         err = ovl_inode_lock(inode);
783         if (err)
784                 return err;
785 
786         if (d_is_dir(dentry) || !ovl_test_flag(OVL_INDEX, inode))
787                 goto out;
788 
789         old_cred = ovl_override_creds(dentry->d_sb);
790         /*
791          * The overlay inode nlink should be incremented/decremented IFF the
792          * upper operation succeeds, along with nlink change of upper inode.
793          * Therefore, before link/unlink/rename, we store the union nlink
794          * value relative to the upper inode nlink in an upper inode xattr.
795          */
796         err = ovl_set_nlink_upper(dentry);
797         revert_creds(old_cred);
798 
799 out:
800         if (err)
801                 ovl_inode_unlock(inode);
802 
803         return err;
804 }
805 
806 void ovl_nlink_end(struct dentry *dentry)
807 {
808         struct inode *inode = d_inode(dentry);
809 
810         if (ovl_test_flag(OVL_INDEX, inode) && inode->i_nlink == 0) {
811                 const struct cred *old_cred;
812 
813                 old_cred = ovl_override_creds(dentry->d_sb);
814                 ovl_cleanup_index(dentry);
815                 revert_creds(old_cred);
816         }
817 
818         ovl_inode_unlock(inode);
819 }
820 
821 int ovl_lock_rename_workdir(struct dentry *workdir, struct dentry *upperdir)
822 {
823         /* Workdir should not be the same as upperdir */
824         if (workdir == upperdir)
825                 goto err;
826 
827         /* Workdir should not be subdir of upperdir and vice versa */
828         if (lock_rename(workdir, upperdir) != NULL)
829                 goto err_unlock;
830 
831         return 0;
832 
833 err_unlock:
834         unlock_rename(workdir, upperdir);
835 err:
836         pr_err("overlayfs: failed to lock workdir+upperdir\n");
837         return -EIO;
838 }
839 
840 /* err < 0, 0 if no metacopy xattr, 1 if metacopy xattr found */
841 int ovl_check_metacopy_xattr(struct dentry *dentry)
842 {
843         int res;
844 
845         /* Only regular files can have metacopy xattr */
846         if (!S_ISREG(d_inode(dentry)->i_mode))
847                 return 0;
848 
849         res = vfs_getxattr(dentry, OVL_XATTR_METACOPY, NULL, 0);
850         if (res < 0) {
851                 if (res == -ENODATA || res == -EOPNOTSUPP)
852                         return 0;
853                 goto out;
854         }
855 
856         return 1;
857 out:
858         pr_warn_ratelimited("overlayfs: failed to get metacopy (%i)\n", res);
859         return res;
860 }
861 
862 bool ovl_is_metacopy_dentry(struct dentry *dentry)
863 {
864         struct ovl_entry *oe = dentry->d_fsdata;
865 
866         if (!d_is_reg(dentry))
867                 return false;
868 
869         if (ovl_dentry_upper(dentry)) {
870                 if (!ovl_has_upperdata(d_inode(dentry)))
871                         return true;
872                 return false;
873         }
874 
875         return (oe->numlower > 1);
876 }
877 
878 ssize_t ovl_getxattr(struct dentry *dentry, char *name, char **value,
879                      size_t padding)
880 {
881         ssize_t res;
882         char *buf = NULL;
883 
884         res = vfs_getxattr(dentry, name, NULL, 0);
885         if (res < 0) {
886                 if (res == -ENODATA || res == -EOPNOTSUPP)
887                         return -ENODATA;
888                 goto fail;
889         }
890 
891         if (res != 0) {
892                 buf = kzalloc(res + padding, GFP_KERNEL);
893                 if (!buf)
894                         return -ENOMEM;
895 
896                 res = vfs_getxattr(dentry, name, buf, res);
897                 if (res < 0)
898                         goto fail;
899         }
900         *value = buf;
901 
902         return res;
903 
904 fail:
905         pr_warn_ratelimited("overlayfs: failed to get xattr %s: err=%zi)\n",
906                             name, res);
907         kfree(buf);
908         return res;
909 }
910 
911 char *ovl_get_redirect_xattr(struct dentry *dentry, int padding)
912 {
913         int res;
914         char *s, *next, *buf = NULL;
915 
916         res = ovl_getxattr(dentry, OVL_XATTR_REDIRECT, &buf, padding + 1);
917         if (res == -ENODATA)
918                 return NULL;
919         if (res < 0)
920                 return ERR_PTR(res);
921         if (res == 0)
922                 goto invalid;
923 
924         if (buf[0] == '/') {
925                 for (s = buf; *s++ == '/'; s = next) {
926                         next = strchrnul(s, '/');
927                         if (s == next)
928                                 goto invalid;
929                 }
930         } else {
931                 if (strchr(buf, '/') != NULL)
932                         goto invalid;
933         }
934 
935         return buf;
936 invalid:
937         pr_warn_ratelimited("overlayfs: invalid redirect (%s)\n", buf);
938         res = -EINVAL;
939         kfree(buf);
940         return ERR_PTR(res);
941 }
942 

~ [ 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