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