1
2
3
4
5
6
7
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
22int 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
28void 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
34struct dentry *ovl_workdir(struct dentry *dentry)
35{
36 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
37 return ofs->workdir;
38}
39
40const 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
47struct 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
54bool 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
60struct dentry *ovl_indexdir(struct super_block *sb)
61{
62 struct ovl_fs *ofs = sb->s_fs_info;
63
64 return ofs->indexdir;
65}
66
67struct 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
78bool 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
85bool 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
93enum 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
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
116void 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
124void 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
131enum 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
143struct dentry *ovl_dentry_upper(struct dentry *dentry)
144{
145 return ovl_upperdentry_dereference(OVL_I(d_inode(dentry)));
146}
147
148struct 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
155struct dentry *ovl_dentry_real(struct dentry *dentry)
156{
157 return ovl_dentry_upper(dentry) ?: ovl_dentry_lower(dentry);
158}
159
160struct dentry *ovl_i_dentry_upper(struct inode *inode)
161{
162 return ovl_upperdentry_dereference(OVL_I(inode));
163}
164
165struct 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
172struct inode *ovl_inode_lower(struct inode *inode)
173{
174 return OVL_I(inode)->lower;
175}
176
177struct inode *ovl_inode_real(struct inode *inode)
178{
179 return ovl_inode_upper(inode) ?: ovl_inode_lower(inode);
180}
181
182
183struct ovl_dir_cache *ovl_dir_cache(struct dentry *dentry)
184{
185 return OVL_I(d_inode(dentry))->cache;
186}
187
188void ovl_set_dir_cache(struct dentry *dentry, struct ovl_dir_cache *cache)
189{
190 OVL_I(d_inode(dentry))->cache = cache;
191}
192
193bool ovl_dentry_is_opaque(struct dentry *dentry)
194{
195 struct ovl_entry *oe = dentry->d_fsdata;
196 return oe->opaque;
197}
198
199bool ovl_dentry_is_whiteout(struct dentry *dentry)
200{
201 return !dentry->d_inode && ovl_dentry_is_opaque(dentry);
202}
203
204void 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
213
214
215
216bool 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
223void 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
230bool 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
237const char *ovl_dentry_get_redirect(struct dentry *dentry)
238{
239 return OVL_I(d_inode(dentry))->redirect;
240}
241
242void 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
250void 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
261void 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
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
278void 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
286u64 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
294bool ovl_is_whiteout(struct dentry *dentry)
295{
296 struct inode *inode = dentry->d_inode;
297
298 return inode && IS_WHITEOUT(inode);
299}
300
301struct file *ovl_path_open(struct path *path, int flags)
302{
303 return dentry_open(path, flags | O_NOATIME, current_cred());
304}
305
306int 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;
314 mutex_unlock(&oi->lock);
315 }
316
317 return err;
318}
319
320void ovl_copy_up_end(struct dentry *dentry)
321{
322 mutex_unlock(&OVL_I(d_inode(dentry))->lock);
323}
324
325bool 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
340int 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
361int 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
370
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
380void ovl_set_flag(unsigned long flag, struct inode *inode)
381{
382 set_bit(flag, &OVL_I(inode)->flags);
383}
384
385bool ovl_test_flag(unsigned long flag, struct inode *inode)
386{
387 return test_bit(flag, &OVL_I(inode)->flags);
388}
389
390
391
392
393
394bool 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
409void 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
422static 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
442
443
444
445
446
447
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
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 inode_unlock(dir);
461 if (err)
462 goto fail;
463
464out:
465 dput(index);
466 return;
467
468fail:
469 pr_err("overlayfs: cleanup index of '%pd2' failed (%i)\n", dentry, err);
470 goto out;
471}
472
473
474
475
476
477int ovl_nlink_start(struct dentry *dentry, bool *locked)
478{
479 struct ovl_inode *oi = OVL_I(d_inode(dentry));
480 const struct cred *old_cred;
481 int err;
482
483 if (!d_inode(dentry) || d_is_dir(dentry))
484 return 0;
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500 if (ovl_indexdir(dentry->d_sb) && !ovl_dentry_has_upper_alias(dentry) &&
501 d_inode(ovl_dentry_lower(dentry))->i_nlink > 1) {
502 err = ovl_copy_up(dentry);
503 if (err)
504 return err;
505 }
506
507 err = mutex_lock_interruptible(&oi->lock);
508 if (err)
509 return err;
510
511 if (!ovl_test_flag(OVL_INDEX, d_inode(dentry)))
512 goto out;
513
514 old_cred = ovl_override_creds(dentry->d_sb);
515
516
517
518
519
520
521 err = ovl_set_nlink_upper(dentry);
522 revert_creds(old_cred);
523
524out:
525 if (err)
526 mutex_unlock(&oi->lock);
527 else
528 *locked = true;
529
530 return err;
531}
532
533void ovl_nlink_end(struct dentry *dentry, bool locked)
534{
535 if (locked) {
536 if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) &&
537 d_inode(dentry)->i_nlink == 0) {
538 const struct cred *old_cred;
539
540 old_cred = ovl_override_creds(dentry->d_sb);
541 ovl_cleanup_index(dentry);
542 revert_creds(old_cred);
543 }
544
545 mutex_unlock(&OVL_I(d_inode(dentry))->lock);
546 }
547}
548