]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - fs/aufs/i_op.c
projects / mirror_ubuntu-zesty-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
UBUNTU: SAUCE: Import aufs driver
[mirror_ubuntu-zesty-kernel.git] / fs / aufs / i_op.c
1 /*
2 * Copyright (C) 2005-2016 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 = -ENOMEM;
892 a = kzalloc(sizeof(*a), GFP_NOFS);
893 if (unlikely(!a))
894 goto out;
895
896 if (ia->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
897 ia->ia_valid &= ~ATTR_MODE;
898
899 file = NULL;
900 sb = dentry->d_sb;
901 err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM);
902 if (unlikely(err))
903 goto out_kfree;
904
905 if (ia->ia_valid & ATTR_FILE) {
906 /* currently ftruncate(2) only */
907 AuDebugOn(!d_is_reg(dentry));
908 file = ia->ia_file;
909 err = au_reval_and_lock_fdi(file, au_reopen_nondir, /*wlock*/1);
910 if (unlikely(err))
911 goto out_si;
912 ia->ia_file = au_hf_top(file);
913 a->udba = AuOpt_UDBA_NONE;
914 } else {
915 /* fchmod() doesn't pass ia_file */
916 a->udba = au_opt_udba(sb);
917 di_write_lock_child(dentry);
918 /* no d_unlinked(), to set UDBA_NONE for root */
919 if (d_unhashed(dentry))
920 a->udba = AuOpt_UDBA_NONE;
921 if (a->udba != AuOpt_UDBA_NONE) {
922 AuDebugOn(IS_ROOT(dentry));
923 err = au_reval_for_attr(dentry, au_sigen(sb));
924 if (unlikely(err))
925 goto out_dentry;
926 }
927 }
928
929 err = au_pin_and_icpup(dentry, ia, a);
930 if (unlikely(err < 0))
931 goto out_dentry;
932 if (au_ftest_icpup(a->flags, DID_CPUP)) {
933 ia->ia_file = NULL;
934 ia->ia_valid &= ~ATTR_FILE;
935 }
936
937 a->h_path.mnt = au_sbr_mnt(sb, a->btgt);
938 if ((ia->ia_valid & (ATTR_MODE | ATTR_CTIME))
939 == (ATTR_MODE | ATTR_CTIME)) {
940 err = security_path_chmod(&a->h_path, ia->ia_mode);
941 if (unlikely(err))
942 goto out_unlock;
943 } else if ((ia->ia_valid & (ATTR_UID | ATTR_GID))
944 && (ia->ia_valid & ATTR_CTIME)) {
945 err = security_path_chown(&a->h_path, ia->ia_uid, ia->ia_gid);
946 if (unlikely(err))
947 goto out_unlock;
948 }
949
950 if (ia->ia_valid & ATTR_SIZE) {
951 struct file *f;
952
953 if (ia->ia_size < i_size_read(inode))
954 /* unmap only */
955 truncate_setsize(inode, ia->ia_size);
956
957 f = NULL;
958 if (ia->ia_valid & ATTR_FILE)
959 f = ia->ia_file;
960 inode_unlock(a->h_inode);
961 err = vfsub_trunc(&a->h_path, ia->ia_size, ia->ia_valid, f);
962 inode_lock_nested(a->h_inode, AuLsc_I_CHILD);
963 } else {
964 delegated = NULL;
965 while (1) {
966 err = vfsub_notify_change(&a->h_path, ia, &delegated);
967 if (delegated) {
968 err = break_deleg_wait(&delegated);
969 if (!err)
970 continue;
971 }
972 break;
973 }
974 }
975 /*
976 * regardless aufs 'acl' option setting.
977 * why don't all acl-aware fs call this func from their ->setattr()?
978 */
979 if (!err && (ia->ia_valid & ATTR_MODE))
980 err = vfsub_acl_chmod(a->h_inode, ia->ia_mode);
981 if (!err)
982 au_cpup_attr_changeable(inode);
983
984 out_unlock:
985 inode_unlock(a->h_inode);
986 au_unpin(&a->pin);
987 if (unlikely(err))
988 au_update_dbtop(dentry);
989 out_dentry:
990 di_write_unlock(dentry);
991 if (file) {
992 fi_write_unlock(file);
993 ia->ia_file = file;
994 ia->ia_valid |= ATTR_FILE;
995 }
996 out_si:
997 si_read_unlock(sb);
998 out_kfree:
999 au_delayed_kfree(a);
1000 out:
1001 AuTraceErr(err);
1002 return err;
1003 }
1004
1005 #if IS_ENABLED(CONFIG_AUFS_XATTR) || IS_ENABLED(CONFIG_FS_POSIX_ACL)
1006 static int au_h_path_to_set_attr(struct dentry *dentry,
1007 struct au_icpup_args *a, struct path *h_path)
1008 {
1009 int err;
1010 struct super_block *sb;
1011
1012 sb = dentry->d_sb;
1013 a->udba = au_opt_udba(sb);
1014 /* no d_unlinked(), to set UDBA_NONE for root */
1015 if (d_unhashed(dentry))
1016 a->udba = AuOpt_UDBA_NONE;
1017 if (a->udba != AuOpt_UDBA_NONE) {
1018 AuDebugOn(IS_ROOT(dentry));
1019 err = au_reval_for_attr(dentry, au_sigen(sb));
1020 if (unlikely(err))
1021 goto out;
1022 }
1023 err = au_pin_and_icpup(dentry, /*ia*/NULL, a);
1024 if (unlikely(err < 0))
1025 goto out;
1026
1027 h_path->dentry = a->h_path.dentry;
1028 h_path->mnt = au_sbr_mnt(sb, a->btgt);
1029
1030 out:
1031 return err;
1032 }
1033
1034 ssize_t au_srxattr(struct dentry *dentry, struct inode *inode,
1035 struct au_srxattr *arg)
1036 {
1037 int err;
1038 struct path h_path;
1039 struct super_block *sb;
1040 struct au_icpup_args *a;
1041 struct inode *h_inode;
1042
1043 IMustLock(inode);
1044
1045 err = -ENOMEM;
1046 a = kzalloc(sizeof(*a), GFP_NOFS);
1047 if (unlikely(!a))
1048 goto out;
1049
1050 sb = dentry->d_sb;
1051 err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM);
1052 if (unlikely(err))
1053 goto out_kfree;
1054
1055 h_path.dentry = NULL; /* silence gcc */
1056 di_write_lock_child(dentry);
1057 err = au_h_path_to_set_attr(dentry, a, &h_path);
1058 if (unlikely(err))
1059 goto out_di;
1060
1061 inode_unlock(a->h_inode);
1062 switch (arg->type) {
1063 case AU_XATTR_SET:
1064 AuDebugOn(d_is_negative(h_path.dentry));
1065 err = vfsub_setxattr(h_path.dentry,
1066 arg->u.set.name, arg->u.set.value,
1067 arg->u.set.size, arg->u.set.flags);
1068 break;
1069 case AU_XATTR_REMOVE:
1070 err = vfsub_removexattr(h_path.dentry, arg->u.remove.name);
1071 break;
1072 case AU_ACL_SET:
1073 err = -EOPNOTSUPP;
1074 h_inode = d_inode(h_path.dentry);
1075 if (h_inode->i_op->set_acl)
1076 err = h_inode->i_op->set_acl(h_inode,
1077 arg->u.acl_set.acl,
1078 arg->u.acl_set.type);
1079 break;
1080 }
1081 if (!err)
1082 au_cpup_attr_timesizes(inode);
1083
1084 au_unpin(&a->pin);
1085 if (unlikely(err))
1086 au_update_dbtop(dentry);
1087
1088 out_di:
1089 di_write_unlock(dentry);
1090 si_read_unlock(sb);
1091 out_kfree:
1092 au_delayed_kfree(a);
1093 out:
1094 AuTraceErr(err);
1095 return err;
1096 }
1097 #endif
1098
1099 static void au_refresh_iattr(struct inode *inode, struct kstat *st,
1100 unsigned int nlink)
1101 {
1102 unsigned int n;
1103
1104 inode->i_mode = st->mode;
1105 /* don't i_[ug]id_write() here */
1106 inode->i_uid = st->uid;
1107 inode->i_gid = st->gid;
1108 inode->i_atime = st->atime;
1109 inode->i_mtime = st->mtime;
1110 inode->i_ctime = st->ctime;
1111
1112 au_cpup_attr_nlink(inode, /*force*/0);
1113 if (S_ISDIR(inode->i_mode)) {
1114 n = inode->i_nlink;
1115 n -= nlink;
1116 n += st->nlink;
1117 smp_mb(); /* for i_nlink */
1118 /* 0 can happen */
1119 set_nlink(inode, n);
1120 }
1121
1122 spin_lock(&inode->i_lock);
1123 inode->i_blocks = st->blocks;
1124 i_size_write(inode, st->size);
1125 spin_unlock(&inode->i_lock);
1126 }
1127
1128 /*
1129 * common routine for aufs_getattr() and aufs_getxattr().
1130 * returns zero or negative (an error).
1131 * @dentry will be read-locked in success.
1132 */
1133 int au_h_path_getattr(struct dentry *dentry, int force, struct path *h_path)
1134 {
1135 int err;
1136 unsigned int mnt_flags, sigen;
1137 unsigned char udba_none;
1138 aufs_bindex_t bindex;
1139 struct super_block *sb, *h_sb;
1140 struct inode *inode;
1141
1142 h_path->mnt = NULL;
1143 h_path->dentry = NULL;
1144
1145 err = 0;
1146 sb = dentry->d_sb;
1147 mnt_flags = au_mntflags(sb);
1148 udba_none = !!au_opt_test(mnt_flags, UDBA_NONE);
1149
1150 /* support fstat(2) */
1151 if (!d_unlinked(dentry) && !udba_none) {
1152 sigen = au_sigen(sb);
1153 err = au_digen_test(dentry, sigen);
1154 if (!err) {
1155 di_read_lock_child(dentry, AuLock_IR);
1156 err = au_dbrange_test(dentry);
1157 if (unlikely(err)) {
1158 di_read_unlock(dentry, AuLock_IR);
1159 goto out;
1160 }
1161 } else {
1162 AuDebugOn(IS_ROOT(dentry));
1163 di_write_lock_child(dentry);
1164 err = au_dbrange_test(dentry);
1165 if (!err)
1166 err = au_reval_for_attr(dentry, sigen);
1167 if (!err)
1168 di_downgrade_lock(dentry, AuLock_IR);
1169 else {
1170 di_write_unlock(dentry);
1171 goto out;
1172 }
1173 }
1174 } else
1175 di_read_lock_child(dentry, AuLock_IR);
1176
1177 inode = d_inode(dentry);
1178 bindex = au_ibtop(inode);
1179 h_path->mnt = au_sbr_mnt(sb, bindex);
1180 h_sb = h_path->mnt->mnt_sb;
1181 if (!force
1182 && !au_test_fs_bad_iattr(h_sb)
1183 && udba_none)
1184 goto out; /* success */
1185
1186 if (au_dbtop(dentry) == bindex)
1187 h_path->dentry = au_h_dptr(dentry, bindex);
1188 else if (au_opt_test(mnt_flags, PLINK) && au_plink_test(inode)) {
1189 h_path->dentry = au_plink_lkup(inode, bindex);
1190 if (IS_ERR(h_path->dentry))
1191 /* pretending success */
1192 h_path->dentry = NULL;
1193 else
1194 dput(h_path->dentry);
1195 }
1196
1197 out:
1198 return err;
1199 }
1200
1201 static int aufs_getattr(struct vfsmount *mnt __maybe_unused,
1202 struct dentry *dentry, struct kstat *st)
1203 {
1204 int err;
1205 unsigned char positive;
1206 struct path h_path;
1207 struct inode *inode;
1208 struct super_block *sb;
1209
1210 inode = d_inode(dentry);
1211 sb = dentry->d_sb;
1212 err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM);
1213 if (unlikely(err))
1214 goto out;
1215 err = au_h_path_getattr(dentry, /*force*/0, &h_path);
1216 if (unlikely(err))
1217 goto out_si;
1218 if (unlikely(!h_path.dentry))
1219 /* illegally overlapped or something */
1220 goto out_fill; /* pretending success */
1221
1222 positive = d_is_positive(h_path.dentry);
1223 if (positive)
1224 err = vfs_getattr(&h_path, st);
1225 if (!err) {
1226 if (positive)
1227 au_refresh_iattr(inode, st,
1228 d_inode(h_path.dentry)->i_nlink);
1229 goto out_fill; /* success */
1230 }
1231 AuTraceErr(err);
1232 goto out_di;
1233
1234 out_fill:
1235 generic_fillattr(inode, st);
1236 out_di:
1237 di_read_unlock(dentry, AuLock_IR);
1238 out_si:
1239 si_read_unlock(sb);
1240 out:
1241 AuTraceErr(err);
1242 return err;
1243 }
1244
1245 /* ---------------------------------------------------------------------- */
1246
1247 static const char *aufs_get_link(struct dentry *dentry, struct inode *inode,
1248 struct delayed_call *done)
1249 {
1250 const char *ret;
1251 struct dentry *h_dentry;
1252 struct inode *h_inode;
1253 int err;
1254 aufs_bindex_t bindex;
1255
1256 ret = NULL; /* suppress a warning */
1257 err = -ECHILD;
1258 if (!dentry)
1259 goto out;
1260
1261 err = aufs_read_lock(dentry, AuLock_IR | AuLock_GEN);
1262 if (unlikely(err))
1263 goto out;
1264
1265 err = au_d_hashed_positive(dentry);
1266 if (unlikely(err))
1267 goto out_unlock;
1268
1269 err = -EINVAL;
1270 inode = d_inode(dentry);
1271 bindex = au_ibtop(inode);
1272 h_inode = au_h_iptr(inode, bindex);
1273 if (unlikely(!h_inode->i_op->get_link))
1274 goto out_unlock;
1275
1276 err = -EBUSY;
1277 h_dentry = NULL;
1278 if (au_dbtop(dentry) <= bindex) {
1279 h_dentry = au_h_dptr(dentry, bindex);
1280 if (h_dentry)
1281 dget(h_dentry);
1282 }
1283 if (!h_dentry) {
1284 h_dentry = d_find_any_alias(h_inode);
1285 if (IS_ERR(h_dentry)) {
1286 err = PTR_ERR(h_dentry);
1287 goto out_unlock;
1288 }
1289 }
1290 if (unlikely(!h_dentry))
1291 goto out_unlock;
1292
1293 err = 0;
1294 AuDbg("%pf\n", h_inode->i_op->get_link);
1295 AuDbgDentry(h_dentry);
1296 ret = h_inode->i_op->get_link(h_dentry, h_inode, done);
1297 dput(h_dentry);
1298 if (IS_ERR(ret))
1299 err = PTR_ERR(ret);
1300
1301 out_unlock:
1302 aufs_read_unlock(dentry, AuLock_IR);
1303 out:
1304 if (unlikely(err))
1305 ret = ERR_PTR(err);
1306 AuTraceErrPtr(ret);
1307 return ret;
1308 }
1309
1310 /* ---------------------------------------------------------------------- */
1311
1312 static int au_is_special(struct inode *inode)
1313 {
1314 return (inode->i_mode & (S_IFBLK | S_IFCHR | S_IFIFO | S_IFSOCK));
1315 }
1316
1317 static int aufs_update_time(struct inode *inode, struct timespec *ts, int flags)
1318 {
1319 int err;
1320 aufs_bindex_t bindex;
1321 struct super_block *sb;
1322 struct inode *h_inode;
1323 struct vfsmount *h_mnt;
1324
1325 sb = inode->i_sb;
1326 WARN_ONCE((flags & S_ATIME) && !IS_NOATIME(inode),
1327 "unexpected s_flags 0x%lx", sb->s_flags);
1328
1329 /* mmap_sem might be acquired already, cf. aufs_mmap() */
1330 lockdep_off();
1331 si_read_lock(sb, AuLock_FLUSH);
1332 ii_write_lock_child(inode);
1333 lockdep_on();
1334
1335 err = 0;
1336 bindex = au_ibtop(inode);
1337 h_inode = au_h_iptr(inode, bindex);
1338 if (!au_test_ro(sb, bindex, inode)) {
1339 h_mnt = au_sbr_mnt(sb, bindex);
1340 err = vfsub_mnt_want_write(h_mnt);
1341 if (!err) {
1342 err = vfsub_update_time(h_inode, ts, flags);
1343 vfsub_mnt_drop_write(h_mnt);
1344 }
1345 } else if (au_is_special(h_inode)) {
1346 /*
1347 * Never copy-up here.
1348 * These special files may already be opened and used for
1349 * communicating. If we copied it up, then the communication
1350 * would be corrupted.
1351 */
1352 AuWarn1("timestamps for i%lu are ignored "
1353 "since it is on readonly branch (hi%lu).\n",
1354 inode->i_ino, h_inode->i_ino);
1355 } else if (flags & ~S_ATIME) {
1356 err = -EIO;
1357 AuIOErr1("unexpected flags 0x%x\n", flags);
1358 AuDebugOn(1);
1359 }
1360
1361 lockdep_off();
1362 if (!err)
1363 au_cpup_attr_timesizes(inode);
1364 ii_write_unlock(inode);
1365 si_read_unlock(sb);
1366 lockdep_on();
1367
1368 if (!err && (flags & S_VERSION))
1369 inode_inc_iversion(inode);
1370
1371 return err;
1372 }
1373
1374 /* ---------------------------------------------------------------------- */
1375
1376 /* no getattr version will be set by module.c:aufs_init() */
1377 struct inode_operations aufs_iop_nogetattr[AuIop_Last],
1378 aufs_iop[] = {
1379 [AuIop_SYMLINK] = {
1380 .permission = aufs_permission,
1381 #ifdef CONFIG_FS_POSIX_ACL
1382 .get_acl = aufs_get_acl,
1383 .set_acl = aufs_set_acl, /* unsupport for symlink? */
1384 #endif
1385
1386 .setattr = aufs_setattr,
1387 .getattr = aufs_getattr,
1388
1389 #ifdef CONFIG_AUFS_XATTR
1390 .setxattr = aufs_setxattr,
1391 .getxattr = aufs_getxattr,
1392 .listxattr = aufs_listxattr,
1393 .removexattr = aufs_removexattr,
1394 #endif
1395
1396 .readlink = generic_readlink,
1397 .get_link = aufs_get_link,
1398
1399 /* .update_time = aufs_update_time */
1400 },
1401 [AuIop_DIR] = {
1402 .create = aufs_create,
1403 .lookup = aufs_lookup,
1404 .link = aufs_link,
1405 .unlink = aufs_unlink,
1406 .symlink = aufs_symlink,
1407 .mkdir = aufs_mkdir,
1408 .rmdir = aufs_rmdir,
1409 .mknod = aufs_mknod,
1410 .rename = aufs_rename,
1411
1412 .permission = aufs_permission,
1413 #ifdef CONFIG_FS_POSIX_ACL
1414 .get_acl = aufs_get_acl,
1415 .set_acl = aufs_set_acl,
1416 #endif
1417
1418 .setattr = aufs_setattr,
1419 .getattr = aufs_getattr,
1420
1421 #ifdef CONFIG_AUFS_XATTR
1422 .setxattr = aufs_setxattr,
1423 .getxattr = aufs_getxattr,
1424 .listxattr = aufs_listxattr,
1425 .removexattr = aufs_removexattr,
1426 #endif
1427
1428 .update_time = aufs_update_time,
1429 .atomic_open = aufs_atomic_open,
1430 .tmpfile = aufs_tmpfile
1431 },
1432 [AuIop_OTHER] = {
1433 .permission = aufs_permission,
1434 #ifdef CONFIG_FS_POSIX_ACL
1435 .get_acl = aufs_get_acl,
1436 .set_acl = aufs_set_acl,
1437 #endif
1438
1439 .setattr = aufs_setattr,
1440 .getattr = aufs_getattr,
1441
1442 #ifdef CONFIG_AUFS_XATTR
1443 .setxattr = aufs_setxattr,
1444 .getxattr = aufs_getxattr,
1445 .listxattr = aufs_listxattr,
1446 .removexattr = aufs_removexattr,
1447 #endif
1448
1449 .update_time = aufs_update_time
1450 }
1451 };
ubuntu-zesty-kernel mirror