]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - fs/aufs/i_op.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
UBUNTU: SAUCE: Import aufs driver
[mirror_ubuntu-bionic-kernel.git] / fs / aufs / i_op.c
1 /*
2 * Copyright (C) 2005-2017 Junjiro R. Okajima
3 *
4 * This program, aufs is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18 /*
19 * inode operations (except add/del/rename)
20 */
21
22 #include <linux/device_cgroup.h>
23 #include <linux/fs_stack.h>
24 #include <linux/namei.h>
25 #include <linux/security.h>
26 #include "aufs.h"
27
28 static int h_permission(struct inode *h_inode, int mask,
29 struct path *h_path, int brperm)
30 {
31 int err;
32 const unsigned char write_mask = !!(mask & (MAY_WRITE | MAY_APPEND));
33
34 err = -EPERM;
35 if (write_mask && IS_IMMUTABLE(h_inode))
36 goto out;
37
38 err = -EACCES;
39 if (((mask & MAY_EXEC)
40 && S_ISREG(h_inode->i_mode)
41 && (path_noexec(h_path)
42 || !(h_inode->i_mode & S_IXUGO))))
43 goto out;
44
45 /*
46 * - skip the lower fs test in the case of write to ro branch.
47 * - nfs dir permission write check is optimized, but a policy for
48 * link/rename requires a real check.
49 * - nfs always sets SB_POSIXACL regardless its mount option 'noacl.'
50 * in this case, generic_permission() returns -EOPNOTSUPP.
51 */
52 if ((write_mask && !au_br_writable(brperm))
53 || (au_test_nfs(h_inode->i_sb) && S_ISDIR(h_inode->i_mode)
54 && write_mask && !(mask & MAY_READ))
55 || !h_inode->i_op->permission) {
56 /* AuLabel(generic_permission); */
57 /* AuDbg("get_acl %pf\n", h_inode->i_op->get_acl); */
58 err = generic_permission(h_inode, mask);
59 if (err == -EOPNOTSUPP && au_test_nfs_noacl(h_inode))
60 err = h_inode->i_op->permission(h_inode, mask);
61 AuTraceErr(err);
62 } else {
63 /* AuLabel(h_inode->permission); */
64 err = h_inode->i_op->permission(h_inode, mask);
65 AuTraceErr(err);
66 }
67
68 if (!err)
69 err = devcgroup_inode_permission(h_inode, mask);
70 if (!err)
71 err = security_inode_permission(h_inode, mask);
72
73 #if 0
74 if (!err) {
75 /* todo: do we need to call ima_path_check()? */
76 struct path h_path = {
77 .dentry =
78 .mnt = h_mnt
79 };
80 err = ima_path_check(&h_path,
81 mask & (MAY_READ | MAY_WRITE | MAY_EXEC),
82 IMA_COUNT_LEAVE);
83 }
84 #endif
85
86 out:
87 return err;
88 }
89
90 static int aufs_permission(struct inode *inode, int mask)
91 {
92 int err;
93 aufs_bindex_t bindex, bbot;
94 const unsigned char isdir = !!S_ISDIR(inode->i_mode),
95 write_mask = !!(mask & (MAY_WRITE | MAY_APPEND));
96 struct inode *h_inode;
97 struct super_block *sb;
98 struct au_branch *br;
99
100 /* todo: support rcu-walk? */
101 if (mask & MAY_NOT_BLOCK)
102 return -ECHILD;
103
104 sb = inode->i_sb;
105 si_read_lock(sb, AuLock_FLUSH);
106 ii_read_lock_child(inode);
107 #if 0
108 err = au_iigen_test(inode, au_sigen(sb));
109 if (unlikely(err))
110 goto out;
111 #endif
112
113 if (!isdir
114 || write_mask
115 || au_opt_test(au_mntflags(sb), DIRPERM1)) {
116 err = au_busy_or_stale();
117 h_inode = au_h_iptr(inode, au_ibtop(inode));
118 if (unlikely(!h_inode
119 || (h_inode->i_mode & S_IFMT)
120 != (inode->i_mode & S_IFMT)))
121 goto out;
122
123 err = 0;
124 bindex = au_ibtop(inode);
125 br = au_sbr(sb, bindex);
126 err = h_permission(h_inode, mask, &br->br_path, br->br_perm);
127 if (write_mask
128 && !err
129 && !special_file(h_inode->i_mode)) {
130 /* test whether the upper writable branch exists */
131 err = -EROFS;
132 for (; bindex >= 0; bindex--)
133 if (!au_br_rdonly(au_sbr(sb, bindex))) {
134 err = 0;
135 break;
136 }
137 }
138 goto out;
139 }
140
141 /* non-write to dir */
142 err = 0;
143 bbot = au_ibbot(inode);
144 for (bindex = au_ibtop(inode); !err && bindex <= bbot; bindex++) {
145 h_inode = au_h_iptr(inode, bindex);
146 if (h_inode) {
147 err = au_busy_or_stale();
148 if (unlikely(!S_ISDIR(h_inode->i_mode)))
149 break;
150
151 br = au_sbr(sb, bindex);
152 err = h_permission(h_inode, mask, &br->br_path,
153 br->br_perm);
154 }
155 }
156
157 out:
158 ii_read_unlock(inode);
159 si_read_unlock(sb);
160 return err;
161 }
162
163 /* ---------------------------------------------------------------------- */
164
165 static struct dentry *aufs_lookup(struct inode *dir, struct dentry *dentry,
166 unsigned int flags)
167 {
168 struct dentry *ret, *parent;
169 struct inode *inode;
170 struct super_block *sb;
171 int err, npositive;
172
173 IMustLock(dir);
174
175 /* todo: support rcu-walk? */
176 ret = ERR_PTR(-ECHILD);
177 if (flags & LOOKUP_RCU)
178 goto out;
179
180 ret = ERR_PTR(-ENAMETOOLONG);
181 if (unlikely(dentry->d_name.len > AUFS_MAX_NAMELEN))
182 goto out;
183
184 sb = dir->i_sb;
185 err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM);
186 ret = ERR_PTR(err);
187 if (unlikely(err))
188 goto out;
189
190 err = au_di_init(dentry);
191 ret = ERR_PTR(err);
192 if (unlikely(err))
193 goto out_si;
194
195 inode = NULL;
196 npositive = 0; /* suppress a warning */
197 parent = dentry->d_parent; /* dir inode is locked */
198 di_read_lock_parent(parent, AuLock_IR);
199 err = au_alive_dir(parent);
200 if (!err)
201 err = au_digen_test(parent, au_sigen(sb));
202 if (!err) {
203 /* regardless LOOKUP_CREATE, always ALLOW_NEG */
204 npositive = au_lkup_dentry(dentry, au_dbtop(parent),
205 AuLkup_ALLOW_NEG);
206 err = npositive;
207 }
208 di_read_unlock(parent, AuLock_IR);
209 ret = ERR_PTR(err);
210 if (unlikely(err < 0))
211 goto out_unlock;
212
213 if (npositive) {
214 inode = au_new_inode(dentry, /*must_new*/0);
215 if (IS_ERR(inode)) {
216 ret = (void *)inode;
217 inode = NULL;
218 goto out_unlock;
219 }
220 }
221
222 if (inode)
223 atomic_inc(&inode->i_count);
224 ret = d_splice_alias(inode, dentry);
225 #if 0
226 if (unlikely(d_need_lookup(dentry))) {
227 spin_lock(&dentry->d_lock);
228 dentry->d_flags &= ~DCACHE_NEED_LOOKUP;
229 spin_unlock(&dentry->d_lock);
230 } else
231 #endif
232 if (inode) {
233 if (!IS_ERR(ret)) {
234 iput(inode);
235 if (ret && ret != dentry)
236 ii_write_unlock(inode);
237 } else {
238 ii_write_unlock(inode);
239 iput(inode);
240 inode = NULL;
241 }
242 }
243
244 out_unlock:
245 di_write_unlock(dentry);
246 out_si:
247 si_read_unlock(sb);
248 out:
249 return ret;
250 }
251
252 /* ---------------------------------------------------------------------- */
253
254 struct aopen_node {
255 struct hlist_bl_node hblist;
256 struct file *file, *h_file;
257 };
258
259 static int au_do_aopen(struct inode *inode, struct file *file)
260 {
261 struct hlist_bl_head *aopen;
262 struct hlist_bl_node *pos;
263 struct aopen_node *node;
264 struct au_do_open_args args = {
265 .aopen = 1,
266 .open = au_do_open_nondir
267 };
268
269 aopen = &au_sbi(inode->i_sb)->si_aopen;
270 hlist_bl_lock(aopen);
271 hlist_bl_for_each_entry(node, pos, aopen, hblist)
272 if (node->file == file) {
273 args.h_file = node->h_file;
274 break;
275 }
276 hlist_bl_unlock(aopen);
277 /* AuDebugOn(!args.h_file); */
278
279 return au_do_open(file, &args);
280 }
281
282 static int aufs_atomic_open(struct inode *dir, struct dentry *dentry,
283 struct file *file, unsigned int open_flag,
284 umode_t create_mode, int *opened)
285 {
286 int err, unlocked, h_opened = *opened;
287 unsigned int lkup_flags;
288 struct dentry *parent, *d;
289 struct hlist_bl_head *aopen;
290 struct vfsub_aopen_args args = {
291 .open_flag = open_flag,
292 .create_mode = create_mode,
293 .opened = &h_opened
294 };
295 struct aopen_node aopen_node = {
296 .file = file
297 };
298
299 IMustLock(dir);
300 AuDbg("open_flag 0%o\n", open_flag);
301 AuDbgDentry(dentry);
302
303 err = 0;
304 if (!au_di(dentry)) {
305 lkup_flags = LOOKUP_OPEN;
306 if (open_flag & O_CREAT)
307 lkup_flags |= LOOKUP_CREATE;
308 d = aufs_lookup(dir, dentry, lkup_flags);
309 if (IS_ERR(d)) {
310 err = PTR_ERR(d);
311 AuTraceErr(err);
312 goto out;
313 } else if (d) {
314 /*
315 * obsoleted dentry found.
316 * another error will be returned later.
317 */
318 d_drop(d);
319 AuDbgDentry(d);
320 dput(d);
321 }
322 AuDbgDentry(dentry);
323 }
324
325 if (d_is_positive(dentry)
326 || d_unhashed(dentry)
327 || d_unlinked(dentry)
328 || !(open_flag & O_CREAT))
329 goto out_no_open;
330
331 unlocked = 0;
332 err = aufs_read_lock(dentry, AuLock_DW | AuLock_FLUSH | AuLock_GEN);
333 if (unlikely(err))
334 goto out;
335
336 parent = dentry->d_parent; /* dir is locked */
337 di_write_lock_parent(parent);
338 err = au_lkup_dentry(dentry, /*btop*/0, AuLkup_ALLOW_NEG);
339 if (unlikely(err))
340 goto out_unlock;
341
342 AuDbgDentry(dentry);
343 if (d_is_positive(dentry))
344 goto out_unlock;
345
346 args.file = get_empty_filp();
347 err = PTR_ERR(args.file);
348 if (IS_ERR(args.file))
349 goto out_unlock;
350
351 args.file->f_flags = file->f_flags;
352 err = au_aopen_or_create(dir, dentry, &args);
353 AuTraceErr(err);
354 AuDbgFile(args.file);
355 if (unlikely(err < 0)) {
356 if (h_opened & FILE_OPENED)
357 fput(args.file);
358 else
359 put_filp(args.file);
360 goto out_unlock;
361 }
362 di_write_unlock(parent);
363 di_write_unlock(dentry);
364 unlocked = 1;
365
366 /* some filesystems don't set FILE_CREATED while succeeded? */
367 *opened |= FILE_CREATED;
368 if (h_opened & FILE_OPENED)
369 aopen_node.h_file = args.file;
370 else {
371 put_filp(args.file);
372 args.file = NULL;
373 }
374 aopen = &au_sbi(dir->i_sb)->si_aopen;
375 au_hbl_add(&aopen_node.hblist, aopen);
376 err = finish_open(file, dentry, au_do_aopen, opened);
377 au_hbl_del(&aopen_node.hblist, aopen);
378 AuTraceErr(err);
379 AuDbgFile(file);
380 if (aopen_node.h_file)
381 fput(aopen_node.h_file);
382
383 out_unlock:
384 if (unlocked)
385 si_read_unlock(dentry->d_sb);
386 else {
387 di_write_unlock(parent);
388 aufs_read_unlock(dentry, AuLock_DW);
389 }
390 AuDbgDentry(dentry);
391 if (unlikely(err < 0))
392 goto out;
393 out_no_open:
394 if (err >= 0 && !(*opened & FILE_CREATED)) {
395 AuLabel(out_no_open);
396 dget(dentry);
397 err = finish_no_open(file, dentry);
398 }
399 out:
400 AuDbg("%pd%s%s\n", dentry,
401 (*opened & FILE_CREATED) ? " created" : "",
402 (*opened & FILE_OPENED) ? " opened" : "");
403 AuTraceErr(err);
404 return err;
405 }
406
407
408 /* ---------------------------------------------------------------------- */
409
410 static int au_wr_dir_cpup(struct dentry *dentry, struct dentry *parent,
411 const unsigned char add_entry, aufs_bindex_t bcpup,
412 aufs_bindex_t btop)
413 {
414 int err;
415 struct dentry *h_parent;
416 struct inode *h_dir;
417
418 if (add_entry)
419 IMustLock(d_inode(parent));
420 else
421 di_write_lock_parent(parent);
422
423 err = 0;
424 if (!au_h_dptr(parent, bcpup)) {
425 if (btop > bcpup)
426 err = au_cpup_dirs(dentry, bcpup);
427 else if (btop < bcpup)
428 err = au_cpdown_dirs(dentry, bcpup);
429 else
430 BUG();
431 }
432 if (!err && add_entry && !au_ftest_wrdir(add_entry, TMPFILE)) {
433 h_parent = au_h_dptr(parent, bcpup);
434 h_dir = d_inode(h_parent);
435 vfsub_inode_lock_shared_nested(h_dir, AuLsc_I_PARENT);
436 err = au_lkup_neg(dentry, bcpup, /*wh*/0);
437 /* todo: no unlock here */
438 inode_unlock_shared(h_dir);
439
440 AuDbg("bcpup %d\n", bcpup);
441 if (!err) {
442 if (d_really_is_negative(dentry))
443 au_set_h_dptr(dentry, btop, NULL);
444 au_update_dbrange(dentry, /*do_put_zero*/0);
445 }
446 }
447
448 if (!add_entry)
449 di_write_unlock(parent);
450 if (!err)
451 err = bcpup; /* success */
452
453 AuTraceErr(err);
454 return err;
455 }
456
457 /*
458 * decide the branch and the parent dir where we will create a new entry.
459 * returns new bindex or an error.
460 * copyup the parent dir if needed.
461 */
462 int au_wr_dir(struct dentry *dentry, struct dentry *src_dentry,
463 struct au_wr_dir_args *args)
464 {
465 int err;
466 unsigned int flags;
467 aufs_bindex_t bcpup, btop, src_btop;
468 const unsigned char add_entry
469 = au_ftest_wrdir(args->flags, ADD_ENTRY)
470 | au_ftest_wrdir(args->flags, TMPFILE);
471 struct super_block *sb;
472 struct dentry *parent;
473 struct au_sbinfo *sbinfo;
474
475 sb = dentry->d_sb;
476 sbinfo = au_sbi(sb);
477 parent = dget_parent(dentry);
478 btop = au_dbtop(dentry);
479 bcpup = btop;
480 if (args->force_btgt < 0) {
481 if (src_dentry) {
482 src_btop = au_dbtop(src_dentry);
483 if (src_btop < btop)
484 bcpup = src_btop;
485 } else if (add_entry) {
486 flags = 0;
487 if (au_ftest_wrdir(args->flags, ISDIR))
488 au_fset_wbr(flags, DIR);
489 err = AuWbrCreate(sbinfo, dentry, flags);
490 bcpup = err;
491 }
492
493 if (bcpup < 0 || au_test_ro(sb, bcpup, d_inode(dentry))) {
494 if (add_entry)
495 err = AuWbrCopyup(sbinfo, dentry);
496 else {
497 if (!IS_ROOT(dentry)) {
498 di_read_lock_parent(parent, !AuLock_IR);
499 err = AuWbrCopyup(sbinfo, dentry);
500 di_read_unlock(parent, !AuLock_IR);
501 } else
502 err = AuWbrCopyup(sbinfo, dentry);
503 }
504 bcpup = err;
505 if (unlikely(err < 0))
506 goto out;
507 }
508 } else {
509 bcpup = args->force_btgt;
510 AuDebugOn(au_test_ro(sb, bcpup, d_inode(dentry)));
511 }
512
513 AuDbg("btop %d, bcpup %d\n", btop, bcpup);
514 err = bcpup;
515 if (bcpup == btop)
516 goto out; /* success */
517
518 /* copyup the new parent into the branch we process */
519 err = au_wr_dir_cpup(dentry, parent, add_entry, bcpup, btop);
520 if (err >= 0) {
521 if (d_really_is_negative(dentry)) {
522 au_set_h_dptr(dentry, btop, NULL);
523 au_set_dbtop(dentry, bcpup);
524 au_set_dbbot(dentry, bcpup);
525 }
526 AuDebugOn(add_entry
527 && !au_ftest_wrdir(args->flags, TMPFILE)
528 && !au_h_dptr(dentry, bcpup));
529 }
530
531 out:
532 dput(parent);
533 return err;
534 }
535
536 /* ---------------------------------------------------------------------- */
537
538 void au_pin_hdir_unlock(struct au_pin *p)
539 {
540 if (p->hdir)
541 au_hn_inode_unlock(p->hdir);
542 }
543
544 int au_pin_hdir_lock(struct au_pin *p)
545 {
546 int err;
547
548 err = 0;
549 if (!p->hdir)
550 goto out;
551
552 /* even if an error happens later, keep this lock */
553 au_hn_inode_lock_nested(p->hdir, p->lsc_hi);
554
555 err = -EBUSY;
556 if (unlikely(p->hdir->hi_inode != d_inode(p->h_parent)))
557 goto out;
558
559 err = 0;
560 if (p->h_dentry)
561 err = au_h_verify(p->h_dentry, p->udba, p->hdir->hi_inode,
562 p->h_parent, p->br);
563
564 out:
565 return err;
566 }
567
568 int au_pin_hdir_relock(struct au_pin *p)
569 {
570 int err, i;
571 struct inode *h_i;
572 struct dentry *h_d[] = {
573 p->h_dentry,
574 p->h_parent
575 };
576
577 err = au_pin_hdir_lock(p);
578 if (unlikely(err))
579 goto out;
580
581 for (i = 0; !err && i < sizeof(h_d)/sizeof(*h_d); i++) {
582 if (!h_d[i])
583 continue;
584 if (d_is_positive(h_d[i])) {
585 h_i = d_inode(h_d[i]);
586 err = !h_i->i_nlink;
587 }
588 }
589
590 out:
591 return err;
592 }
593
594 static void au_pin_hdir_set_owner(struct au_pin *p, struct task_struct *task)
595 {
596 #if !defined(CONFIG_RWSEM_GENERIC_SPINLOCK) && defined(CONFIG_RWSEM_SPIN_ON_OWNER)
597 p->hdir->hi_inode->i_rwsem.owner = task;
598 #endif
599 }
600
601 void au_pin_hdir_acquire_nest(struct au_pin *p)
602 {
603 if (p->hdir) {
604 rwsem_acquire_nest(&p->hdir->hi_inode->i_rwsem.dep_map,
605 p->lsc_hi, 0, NULL, _RET_IP_);
606 au_pin_hdir_set_owner(p, current);
607 }
608 }
609
610 void au_pin_hdir_release(struct au_pin *p)
611 {
612 if (p->hdir) {
613 au_pin_hdir_set_owner(p, p->task);
614 rwsem_release(&p->hdir->hi_inode->i_rwsem.dep_map, 1, _RET_IP_);
615 }
616 }
617
618 struct dentry *au_pinned_h_parent(struct au_pin *pin)
619 {
620 if (pin && pin->parent)
621 return au_h_dptr(pin->parent, pin->bindex);
622 return NULL;
623 }
624
625 void au_unpin(struct au_pin *p)
626 {
627 if (p->hdir)
628 au_pin_hdir_unlock(p);
629 if (p->h_mnt && au_ftest_pin(p->flags, MNT_WRITE))
630 vfsub_mnt_drop_write(p->h_mnt);
631 if (!p->hdir)
632 return;
633
634 if (!au_ftest_pin(p->flags, DI_LOCKED))
635 di_read_unlock(p->parent, AuLock_IR);
636 iput(p->hdir->hi_inode);
637 dput(p->parent);
638 p->parent = NULL;
639 p->hdir = NULL;
640 p->h_mnt = NULL;
641 /* do not clear p->task */
642 }
643
644 int au_do_pin(struct au_pin *p)
645 {
646 int err;
647 struct super_block *sb;
648 struct inode *h_dir;
649
650 err = 0;
651 sb = p->dentry->d_sb;
652 p->br = au_sbr(sb, p->bindex);
653 if (IS_ROOT(p->dentry)) {
654 if (au_ftest_pin(p->flags, MNT_WRITE)) {
655 p->h_mnt = au_br_mnt(p->br);
656 err = vfsub_mnt_want_write(p->h_mnt);
657 if (unlikely(err)) {
658 au_fclr_pin(p->flags, MNT_WRITE);
659 goto out_err;
660 }
661 }
662 goto out;
663 }
664
665 p->h_dentry = NULL;
666 if (p->bindex <= au_dbbot(p->dentry))
667 p->h_dentry = au_h_dptr(p->dentry, p->bindex);
668
669 p->parent = dget_parent(p->dentry);
670 if (!au_ftest_pin(p->flags, DI_LOCKED))
671 di_read_lock(p->parent, AuLock_IR, p->lsc_di);
672
673 h_dir = NULL;
674 p->h_parent = au_h_dptr(p->parent, p->bindex);
675 p->hdir = au_hi(d_inode(p->parent), p->bindex);
676 if (p->hdir)
677 h_dir = p->hdir->hi_inode;
678
679 /*
680 * udba case, or
681 * if DI_LOCKED is not set, then p->parent may be different
682 * and h_parent can be NULL.
683 */
684 if (unlikely(!p->hdir || !h_dir || !p->h_parent)) {
685 err = -EBUSY;
686 if (!au_ftest_pin(p->flags, DI_LOCKED))
687 di_read_unlock(p->parent, AuLock_IR);
688 dput(p->parent);
689 p->parent = NULL;
690 goto out_err;
691 }
692
693 if (au_ftest_pin(p->flags, MNT_WRITE)) {
694 p->h_mnt = au_br_mnt(p->br);
695 err = vfsub_mnt_want_write(p->h_mnt);
696 if (unlikely(err)) {
697 au_fclr_pin(p->flags, MNT_WRITE);
698 if (!au_ftest_pin(p->flags, DI_LOCKED))
699 di_read_unlock(p->parent, AuLock_IR);
700 dput(p->parent);
701 p->parent = NULL;
702 goto out_err;
703 }
704 }
705
706 au_igrab(h_dir);
707 err = au_pin_hdir_lock(p);
708 if (!err)
709 goto out; /* success */
710
711 au_unpin(p);
712
713 out_err:
714 pr_err("err %d\n", err);
715 err = au_busy_or_stale();
716 out:
717 return err;
718 }
719
720 void au_pin_init(struct au_pin *p, struct dentry *dentry,
721 aufs_bindex_t bindex, int lsc_di, int lsc_hi,
722 unsigned int udba, unsigned char flags)
723 {
724 p->dentry = dentry;
725 p->udba = udba;
726 p->lsc_di = lsc_di;
727 p->lsc_hi = lsc_hi;
728 p->flags = flags;
729 p->bindex = bindex;
730
731 p->parent = NULL;
732 p->hdir = NULL;
733 p->h_mnt = NULL;
734
735 p->h_dentry = NULL;
736 p->h_parent = NULL;
737 p->br = NULL;
738 p->task = current;
739 }
740
741 int au_pin(struct au_pin *pin, struct dentry *dentry, aufs_bindex_t bindex,
742 unsigned int udba, unsigned char flags)
743 {
744 au_pin_init(pin, dentry, bindex, AuLsc_DI_PARENT, AuLsc_I_PARENT2,
745 udba, flags);
746 return au_do_pin(pin);
747 }
748
749 /* ---------------------------------------------------------------------- */
750
751 /*
752 * ->setattr() and ->getattr() are called in various cases.
753 * chmod, stat: dentry is revalidated.
754 * fchmod, fstat: file and dentry are not revalidated, additionally they may be
755 * unhashed.
756 * for ->setattr(), ia->ia_file is passed from ftruncate only.
757 */
758 /* todo: consolidate with do_refresh() and simple_reval_dpath() */
759 int au_reval_for_attr(struct dentry *dentry, unsigned int sigen)
760 {
761 int err;
762 struct dentry *parent;
763
764 err = 0;
765 if (au_digen_test(dentry, sigen)) {
766 parent = dget_parent(dentry);
767 di_read_lock_parent(parent, AuLock_IR);
768 err = au_refresh_dentry(dentry, parent);
769 di_read_unlock(parent, AuLock_IR);
770 dput(parent);
771 }
772
773 AuTraceErr(err);
774 return err;
775 }
776
777 int au_pin_and_icpup(struct dentry *dentry, struct iattr *ia,
778 struct au_icpup_args *a)
779 {
780 int err;
781 loff_t sz;
782 aufs_bindex_t btop, ibtop;
783 struct dentry *hi_wh, *parent;
784 struct inode *inode;
785 struct au_wr_dir_args wr_dir_args = {
786 .force_btgt = -1,
787 .flags = 0
788 };
789
790 if (d_is_dir(dentry))
791 au_fset_wrdir(wr_dir_args.flags, ISDIR);
792 /* plink or hi_wh() case */
793 btop = au_dbtop(dentry);
794 inode = d_inode(dentry);
795 ibtop = au_ibtop(inode);
796 if (btop != ibtop && !au_test_ro(inode->i_sb, ibtop, inode))
797 wr_dir_args.force_btgt = ibtop;
798 err = au_wr_dir(dentry, /*src_dentry*/NULL, &wr_dir_args);
799 if (unlikely(err < 0))
800 goto out;
801 a->btgt = err;
802 if (err != btop)
803 au_fset_icpup(a->flags, DID_CPUP);
804
805 err = 0;
806 a->pin_flags = AuPin_MNT_WRITE;
807 parent = NULL;
808 if (!IS_ROOT(dentry)) {
809 au_fset_pin(a->pin_flags, DI_LOCKED);
810 parent = dget_parent(dentry);
811 di_write_lock_parent(parent);
812 }
813
814 err = au_pin(&a->pin, dentry, a->btgt, a->udba, a->pin_flags);
815 if (unlikely(err))
816 goto out_parent;
817
818 sz = -1;
819 a->h_path.dentry = au_h_dptr(dentry, btop);
820 a->h_inode = d_inode(a->h_path.dentry);
821 if (ia && (ia->ia_valid & ATTR_SIZE)) {
822 vfsub_inode_lock_shared_nested(a->h_inode, AuLsc_I_CHILD);
823 if (ia->ia_size < i_size_read(a->h_inode))
824 sz = ia->ia_size;
825 inode_unlock_shared(a->h_inode);
826 }
827
828 hi_wh = NULL;
829 if (au_ftest_icpup(a->flags, DID_CPUP) && d_unlinked(dentry)) {
830 hi_wh = au_hi_wh(inode, a->btgt);
831 if (!hi_wh) {
832 struct au_cp_generic cpg = {
833 .dentry = dentry,
834 .bdst = a->btgt,
835 .bsrc = -1,
836 .len = sz,
837 .pin = &a->pin
838 };
839 err = au_sio_cpup_wh(&cpg, /*file*/NULL);
840 if (unlikely(err))
841 goto out_unlock;
842 hi_wh = au_hi_wh(inode, a->btgt);
843 /* todo: revalidate hi_wh? */
844 }
845 }
846
847 if (parent) {
848 au_pin_set_parent_lflag(&a->pin, /*lflag*/0);
849 di_downgrade_lock(parent, AuLock_IR);
850 dput(parent);
851 parent = NULL;
852 }
853 if (!au_ftest_icpup(a->flags, DID_CPUP))
854 goto out; /* success */
855
856 if (!d_unhashed(dentry)) {
857 struct au_cp_generic cpg = {
858 .dentry = dentry,
859 .bdst = a->btgt,
860 .bsrc = btop,
861 .len = sz,
862 .pin = &a->pin,
863 .flags = AuCpup_DTIME | AuCpup_HOPEN
864 };
865 err = au_sio_cpup_simple(&cpg);
866 if (!err)
867 a->h_path.dentry = au_h_dptr(dentry, a->btgt);
868 } else if (!hi_wh)
869 a->h_path.dentry = au_h_dptr(dentry, a->btgt);
870 else
871 a->h_path.dentry = hi_wh; /* do not dget here */
872
873 out_unlock:
874 a->h_inode = d_inode(a->h_path.dentry);
875 if (!err)
876 goto out; /* success */
877 au_unpin(&a->pin);
878 out_parent:
879 if (parent) {
880 di_write_unlock(parent);
881 dput(parent);
882 }
883 out:
884 if (!err)
885 inode_lock_nested(a->h_inode, AuLsc_I_CHILD);
886 return err;
887 }
888
889 static int aufs_setattr(struct dentry *dentry, struct iattr *ia)
890 {
891 int err;
892 struct inode *inode, *delegated;
893 struct super_block *sb;
894 struct file *file;
895 struct au_icpup_args *a;
896
897 inode = d_inode(dentry);
898 IMustLock(inode);
899
900 err = setattr_prepare(dentry, ia);
901 if (unlikely(err))
902 goto out;
903
904 err = -ENOMEM;
905 a = kzalloc(sizeof(*a), GFP_NOFS);
906 if (unlikely(!a))
907 goto out;
908
909 if (ia->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
910 ia->ia_valid &= ~ATTR_MODE;
911
912 file = NULL;
913 sb = dentry->d_sb;
914 err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM);
915 if (unlikely(err))
916 goto out_kfree;
917
918 if (ia->ia_valid & ATTR_FILE) {
919 /* currently ftruncate(2) only */
920 AuDebugOn(!d_is_reg(dentry));
921 file = ia->ia_file;
922 err = au_reval_and_lock_fdi(file, au_reopen_nondir, /*wlock*/1,
923 /*fi_lsc*/0);
924 if (unlikely(err))
925 goto out_si;
926 ia->ia_file = au_hf_top(file);
927 a->udba = AuOpt_UDBA_NONE;
928 } else {
929 /* fchmod() doesn't pass ia_file */
930 a->udba = au_opt_udba(sb);
931 di_write_lock_child(dentry);
932 /* no d_unlinked(), to set UDBA_NONE for root */
933 if (d_unhashed(dentry))
934 a->udba = AuOpt_UDBA_NONE;
935 if (a->udba != AuOpt_UDBA_NONE) {
936 AuDebugOn(IS_ROOT(dentry));
937 err = au_reval_for_attr(dentry, au_sigen(sb));
938 if (unlikely(err))
939 goto out_dentry;
940 }
941 }
942
943 err = au_pin_and_icpup(dentry, ia, a);
944 if (unlikely(err < 0))
945 goto out_dentry;
946 if (au_ftest_icpup(a->flags, DID_CPUP)) {
947 ia->ia_file = NULL;
948 ia->ia_valid &= ~ATTR_FILE;
949 }
950
951 a->h_path.mnt = au_sbr_mnt(sb, a->btgt);
952 if ((ia->ia_valid & (ATTR_MODE | ATTR_CTIME))
953 == (ATTR_MODE | ATTR_CTIME)) {
954 err = security_path_chmod(&a->h_path, ia->ia_mode);
955 if (unlikely(err))
956 goto out_unlock;
957 } else if ((ia->ia_valid & (ATTR_UID | ATTR_GID))
958 && (ia->ia_valid & ATTR_CTIME)) {
959 err = security_path_chown(&a->h_path, ia->ia_uid, ia->ia_gid);
960 if (unlikely(err))
961 goto out_unlock;
962 }
963
964 if (ia->ia_valid & ATTR_SIZE) {
965 struct file *f;
966
967 if (ia->ia_size < i_size_read(inode))
968 /* unmap only */
969 truncate_setsize(inode, ia->ia_size);
970
971 f = NULL;
972 if (ia->ia_valid & ATTR_FILE)
973 f = ia->ia_file;
974 inode_unlock(a->h_inode);
975 err = vfsub_trunc(&a->h_path, ia->ia_size, ia->ia_valid, f);
976 inode_lock_nested(a->h_inode, AuLsc_I_CHILD);
977 } else {
978 delegated = NULL;
979 while (1) {
980 err = vfsub_notify_change(&a->h_path, ia, &delegated);
981 if (delegated) {
982 err = break_deleg_wait(&delegated);
983 if (!err)
984 continue;
985 }
986 break;
987 }
988 }
989 /*
990 * regardless aufs 'acl' option setting.
991 * why don't all acl-aware fs call this func from their ->setattr()?
992 */
993 if (!err && (ia->ia_valid & ATTR_MODE))
994 err = vfsub_acl_chmod(a->h_inode, ia->ia_mode);
995 if (!err)
996 au_cpup_attr_changeable(inode);
997
998 out_unlock:
999 inode_unlock(a->h_inode);
1000 au_unpin(&a->pin);
1001 if (unlikely(err))
1002 au_update_dbtop(dentry);
1003 out_dentry:
1004 di_write_unlock(dentry);
1005 if (file) {
1006 fi_write_unlock(file);
1007 ia->ia_file = file;
1008 ia->ia_valid |= ATTR_FILE;
1009 }
1010 out_si:
1011 si_read_unlock(sb);
1012 out_kfree:
1013 kfree(a);
1014 out:
1015 AuTraceErr(err);
1016 return err;
1017 }
1018
1019 #if IS_ENABLED(CONFIG_AUFS_XATTR) || IS_ENABLED(CONFIG_FS_POSIX_ACL)
1020 static int au_h_path_to_set_attr(struct dentry *dentry,
1021 struct au_icpup_args *a, struct path *h_path)
1022 {
1023 int err;
1024 struct super_block *sb;
1025
1026 sb = dentry->d_sb;
1027 a->udba = au_opt_udba(sb);
1028 /* no d_unlinked(), to set UDBA_NONE for root */
1029 if (d_unhashed(dentry))
1030 a->udba = AuOpt_UDBA_NONE;
1031 if (a->udba != AuOpt_UDBA_NONE) {
1032 AuDebugOn(IS_ROOT(dentry));
1033 err = au_reval_for_attr(dentry, au_sigen(sb));
1034 if (unlikely(err))
1035 goto out;
1036 }
1037 err = au_pin_and_icpup(dentry, /*ia*/NULL, a);
1038 if (unlikely(err < 0))
1039 goto out;
1040
1041 h_path->dentry = a->h_path.dentry;
1042 h_path->mnt = au_sbr_mnt(sb, a->btgt);
1043
1044 out:
1045 return err;
1046 }
1047
1048 ssize_t au_sxattr(struct dentry *dentry, struct inode *inode,
1049 struct au_sxattr *arg)
1050 {
1051 int err;
1052 struct path h_path;
1053 struct super_block *sb;
1054 struct au_icpup_args *a;
1055 struct inode *h_inode;
1056
1057 IMustLock(inode);
1058
1059 err = -ENOMEM;
1060 a = kzalloc(sizeof(*a), GFP_NOFS);
1061 if (unlikely(!a))
1062 goto out;
1063
1064 sb = dentry->d_sb;
1065 err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM);
1066 if (unlikely(err))
1067 goto out_kfree;
1068
1069 h_path.dentry = NULL; /* silence gcc */
1070 di_write_lock_child(dentry);
1071 err = au_h_path_to_set_attr(dentry, a, &h_path);
1072 if (unlikely(err))
1073 goto out_di;
1074
1075 inode_unlock(a->h_inode);
1076 switch (arg->type) {
1077 case AU_XATTR_SET:
1078 AuDebugOn(d_is_negative(h_path.dentry));
1079 err = vfsub_setxattr(h_path.dentry,
1080 arg->u.set.name, arg->u.set.value,
1081 arg->u.set.size, arg->u.set.flags);
1082 break;
1083 case AU_ACL_SET:
1084 err = -EOPNOTSUPP;
1085 h_inode = d_inode(h_path.dentry);
1086 if (h_inode->i_op->set_acl)
1087 /* this will call posix_acl_update_mode */
1088 err = h_inode->i_op->set_acl(h_inode,
1089 arg->u.acl_set.acl,
1090 arg->u.acl_set.type);
1091 break;
1092 }
1093 if (!err)
1094 au_cpup_attr_timesizes(inode);
1095
1096 au_unpin(&a->pin);
1097 if (unlikely(err))
1098 au_update_dbtop(dentry);
1099
1100 out_di:
1101 di_write_unlock(dentry);
1102 si_read_unlock(sb);
1103 out_kfree:
1104 kfree(a);
1105 out:
1106 AuTraceErr(err);
1107 return err;
1108 }
1109 #endif
1110
1111 static void au_refresh_iattr(struct inode *inode, struct kstat *st,
1112 unsigned int nlink)
1113 {
1114 unsigned int n;
1115
1116 inode->i_mode = st->mode;
1117 /* don't i_[ug]id_write() here */
1118 inode->i_uid = st->uid;
1119 inode->i_gid = st->gid;
1120 inode->i_atime = st->atime;
1121 inode->i_mtime = st->mtime;
1122 inode->i_ctime = st->ctime;
1123
1124 au_cpup_attr_nlink(inode, /*force*/0);
1125 if (S_ISDIR(inode->i_mode)) {
1126 n = inode->i_nlink;
1127 n -= nlink;
1128 n += st->nlink;
1129 smp_mb(); /* for i_nlink */
1130 /* 0 can happen */
1131 set_nlink(inode, n);
1132 }
1133
1134 spin_lock(&inode->i_lock);
1135 inode->i_blocks = st->blocks;
1136 i_size_write(inode, st->size);
1137 spin_unlock(&inode->i_lock);
1138 }
1139
1140 /*
1141 * common routine for aufs_getattr() and au_getxattr().
1142 * returns zero or negative (an error).
1143 * @dentry will be read-locked in success.
1144 */
1145 int au_h_path_getattr(struct dentry *dentry, int force, struct path *h_path,
1146 int locked)
1147 {
1148 int err;
1149 unsigned int mnt_flags, sigen;
1150 unsigned char udba_none;
1151 aufs_bindex_t bindex;
1152 struct super_block *sb, *h_sb;
1153 struct inode *inode;
1154
1155 h_path->mnt = NULL;
1156 h_path->dentry = NULL;
1157
1158 err = 0;
1159 sb = dentry->d_sb;
1160 mnt_flags = au_mntflags(sb);
1161 udba_none = !!au_opt_test(mnt_flags, UDBA_NONE);
1162
1163 if (unlikely(locked))
1164 goto body; /* skip locking dinfo */
1165
1166 /* support fstat(2) */
1167 if (!d_unlinked(dentry) && !udba_none) {
1168 sigen = au_sigen(sb);
1169 err = au_digen_test(dentry, sigen);
1170 if (!err) {
1171 di_read_lock_child(dentry, AuLock_IR);
1172 err = au_dbrange_test(dentry);
1173 if (unlikely(err)) {
1174 di_read_unlock(dentry, AuLock_IR);
1175 goto out;
1176 }
1177 } else {
1178 AuDebugOn(IS_ROOT(dentry));
1179 di_write_lock_child(dentry);
1180 err = au_dbrange_test(dentry);
1181 if (!err)
1182 err = au_reval_for_attr(dentry, sigen);
1183 if (!err)
1184 di_downgrade_lock(dentry, AuLock_IR);
1185 else {
1186 di_write_unlock(dentry);
1187 goto out;
1188 }
1189 }
1190 } else
1191 di_read_lock_child(dentry, AuLock_IR);
1192
1193 body:
1194 inode = d_inode(dentry);
1195 bindex = au_ibtop(inode);
1196 h_path->mnt = au_sbr_mnt(sb, bindex);
1197 h_sb = h_path->mnt->mnt_sb;
1198 if (!force
1199 && !au_test_fs_bad_iattr(h_sb)
1200 && udba_none)
1201 goto out; /* success */
1202
1203 if (au_dbtop(dentry) == bindex)
1204 h_path->dentry = au_h_dptr(dentry, bindex);
1205 else if (au_opt_test(mnt_flags, PLINK) && au_plink_test(inode)) {
1206 h_path->dentry = au_plink_lkup(inode, bindex);
1207 if (IS_ERR(h_path->dentry))
1208 /* pretending success */
1209 h_path->dentry = NULL;
1210 else
1211 dput(h_path->dentry);
1212 }
1213
1214 out:
1215 return err;
1216 }
1217
1218 static int aufs_getattr(const struct path *path, struct kstat *st,
1219 u32 request, unsigned int query)
1220 {
1221 int err;
1222 unsigned char positive;
1223 struct path h_path;
1224 struct dentry *dentry;
1225 struct inode *inode;
1226 struct super_block *sb;
1227
1228 dentry = path->dentry;
1229 inode = d_inode(dentry);
1230 sb = dentry->d_sb;
1231 err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM);
1232 if (unlikely(err))
1233 goto out;
1234 err = au_h_path_getattr(dentry, /*force*/0, &h_path, /*locked*/0);
1235 if (unlikely(err))
1236 goto out_si;
1237 if (unlikely(!h_path.dentry))
1238 /* illegally overlapped or something */
1239 goto out_fill; /* pretending success */
1240
1241 positive = d_is_positive(h_path.dentry);
1242 if (positive)
1243 /* no vfsub version */
1244 err = vfs_getattr(&h_path, st, request, query);
1245 if (!err) {
1246 if (positive)
1247 au_refresh_iattr(inode, st,
1248 d_inode(h_path.dentry)->i_nlink);
1249 goto out_fill; /* success */
1250 }
1251 AuTraceErr(err);
1252 goto out_di;
1253
1254 out_fill:
1255 generic_fillattr(inode, st);
1256 out_di:
1257 di_read_unlock(dentry, AuLock_IR);
1258 out_si:
1259 si_read_unlock(sb);
1260 out:
1261 AuTraceErr(err);
1262 return err;
1263 }
1264
1265 /* ---------------------------------------------------------------------- */
1266
1267 static const char *aufs_get_link(struct dentry *dentry, struct inode *inode,
1268 struct delayed_call *done)
1269 {
1270 const char *ret;
1271 struct dentry *h_dentry;
1272 struct inode *h_inode;
1273 int err;
1274 aufs_bindex_t bindex;
1275
1276 ret = NULL; /* suppress a warning */
1277 err = -ECHILD;
1278 if (!dentry)
1279 goto out;
1280
1281 err = aufs_read_lock(dentry, AuLock_IR | AuLock_GEN);
1282 if (unlikely(err))
1283 goto out;
1284
1285 err = au_d_hashed_positive(dentry);
1286 if (unlikely(err))
1287 goto out_unlock;
1288
1289 err = -EINVAL;
1290 inode = d_inode(dentry);
1291 bindex = au_ibtop(inode);
1292 h_inode = au_h_iptr(inode, bindex);
1293 if (unlikely(!h_inode->i_op->get_link))
1294 goto out_unlock;
1295
1296 err = -EBUSY;
1297 h_dentry = NULL;
1298 if (au_dbtop(dentry) <= bindex) {
1299 h_dentry = au_h_dptr(dentry, bindex);
1300 if (h_dentry)
1301 dget(h_dentry);
1302 }
1303 if (!h_dentry) {
1304 h_dentry = d_find_any_alias(h_inode);
1305 if (IS_ERR(h_dentry)) {
1306 err = PTR_ERR(h_dentry);
1307 goto out_unlock;
1308 }
1309 }
1310 if (unlikely(!h_dentry))
1311 goto out_unlock;
1312
1313 err = 0;
1314 AuDbg("%pf\n", h_inode->i_op->get_link);
1315 AuDbgDentry(h_dentry);
1316 ret = vfs_get_link(h_dentry, done);
1317 dput(h_dentry);
1318 if (IS_ERR(ret))
1319 err = PTR_ERR(ret);
1320
1321 out_unlock:
1322 aufs_read_unlock(dentry, AuLock_IR);
1323 out:
1324 if (unlikely(err))
1325 ret = ERR_PTR(err);
1326 AuTraceErrPtr(ret);
1327 return ret;
1328 }
1329
1330 /* ---------------------------------------------------------------------- */
1331
1332 static int au_is_special(struct inode *inode)
1333 {
1334 return (inode->i_mode & (S_IFBLK | S_IFCHR | S_IFIFO | S_IFSOCK));
1335 }
1336
1337 static int aufs_update_time(struct inode *inode, struct timespec *ts, int flags)
1338 {
1339 int err;
1340 aufs_bindex_t bindex;
1341 struct super_block *sb;
1342 struct inode *h_inode;
1343 struct vfsmount *h_mnt;
1344
1345 sb = inode->i_sb;
1346 WARN_ONCE((flags & S_ATIME) && !IS_NOATIME(inode),
1347 "unexpected s_flags 0x%lx", sb->s_flags);
1348
1349 /* mmap_sem might be acquired already, cf. aufs_mmap() */
1350 lockdep_off();
1351 si_read_lock(sb, AuLock_FLUSH);
1352 ii_write_lock_child(inode);
1353
1354 err = 0;
1355 bindex = au_ibtop(inode);
1356 h_inode = au_h_iptr(inode, bindex);
1357 if (!au_test_ro(sb, bindex, inode)) {
1358 h_mnt = au_sbr_mnt(sb, bindex);
1359 err = vfsub_mnt_want_write(h_mnt);
1360 if (!err) {
1361 err = vfsub_update_time(h_inode, ts, flags);
1362 vfsub_mnt_drop_write(h_mnt);
1363 }
1364 } else if (au_is_special(h_inode)) {
1365 /*
1366 * Never copy-up here.
1367 * These special files may already be opened and used for
1368 * communicating. If we copied it up, then the communication
1369 * would be corrupted.
1370 */
1371 AuWarn1("timestamps for i%lu are ignored "
1372 "since it is on readonly branch (hi%lu).\n",
1373 inode->i_ino, h_inode->i_ino);
1374 } else if (flags & ~S_ATIME) {
1375 err = -EIO;
1376 AuIOErr1("unexpected flags 0x%x\n", flags);
1377 AuDebugOn(1);
1378 }
1379
1380 if (!err)
1381 au_cpup_attr_timesizes(inode);
1382 ii_write_unlock(inode);
1383 si_read_unlock(sb);
1384 lockdep_on();
1385
1386 if (!err && (flags & S_VERSION))
1387 inode_inc_iversion(inode);
1388
1389 return err;
1390 }
1391
1392 /* ---------------------------------------------------------------------- */
1393
1394 /* no getattr version will be set by module.c:aufs_init() */
1395 struct inode_operations aufs_iop_nogetattr[AuIop_Last],
1396 aufs_iop[] = {
1397 [AuIop_SYMLINK] = {
1398 .permission = aufs_permission,
1399 #ifdef CONFIG_FS_POSIX_ACL
1400 .get_acl = aufs_get_acl,
1401 .set_acl = aufs_set_acl, /* unsupport for symlink? */
1402 #endif
1403
1404 .setattr = aufs_setattr,
1405 .getattr = aufs_getattr,
1406
1407 #ifdef CONFIG_AUFS_XATTR
1408 .listxattr = aufs_listxattr,
1409 #endif
1410
1411 .get_link = aufs_get_link,
1412
1413 /* .update_time = aufs_update_time */
1414 },
1415 [AuIop_DIR] = {
1416 .create = aufs_create,
1417 .lookup = aufs_lookup,
1418 .link = aufs_link,
1419 .unlink = aufs_unlink,
1420 .symlink = aufs_symlink,
1421 .mkdir = aufs_mkdir,
1422 .rmdir = aufs_rmdir,
1423 .mknod = aufs_mknod,
1424 .rename = aufs_rename,
1425
1426 .permission = aufs_permission,
1427 #ifdef CONFIG_FS_POSIX_ACL
1428 .get_acl = aufs_get_acl,
1429 .set_acl = aufs_set_acl,
1430 #endif
1431
1432 .setattr = aufs_setattr,
1433 .getattr = aufs_getattr,
1434
1435 #ifdef CONFIG_AUFS_XATTR
1436 .listxattr = aufs_listxattr,
1437 #endif
1438
1439 .update_time = aufs_update_time,
1440 .atomic_open = aufs_atomic_open,
1441 .tmpfile = aufs_tmpfile
1442 },
1443 [AuIop_OTHER] = {
1444 .permission = aufs_permission,
1445 #ifdef CONFIG_FS_POSIX_ACL
1446 .get_acl = aufs_get_acl,
1447 .set_acl = aufs_set_acl,
1448 #endif
1449
1450 .setattr = aufs_setattr,
1451 .getattr = aufs_getattr,
1452
1453 #ifdef CONFIG_AUFS_XATTR
1454 .listxattr = aufs_listxattr,
1455 #endif
1456
1457 .update_time = aufs_update_time
1458 }
1459 };
ubuntu-bionic-kernel mirror