2 * Copyright (C) 2005-2017 Junjiro R. Okajima
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.
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.
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/>.
19 * handling file/dir, and address_space operation
22 #ifdef CONFIG_AUFS_DEBUG
23 #include <linux/migrate.h>
25 #include <linux/pagemap.h>
28 /* drop flags for writing */
29 unsigned int au_file_roflags(unsigned int flags
)
31 flags
&= ~(O_WRONLY
| O_RDWR
| O_APPEND
| O_CREAT
| O_TRUNC
);
32 flags
|= O_RDONLY
| O_NOATIME
;
36 /* common functions to regular file and dir */
37 struct file
*au_h_open(struct dentry
*dentry
, aufs_bindex_t bindex
, int flags
,
38 struct file
*file
, int force_wr
)
41 struct dentry
*h_dentry
;
42 struct inode
*h_inode
;
43 struct super_block
*sb
;
48 /* a race condition can happen between open and unlink/rmdir */
49 h_file
= ERR_PTR(-ENOENT
);
50 h_dentry
= au_h_dptr(dentry
, bindex
);
51 if (au_test_nfsd() && (!h_dentry
|| d_is_negative(h_dentry
)))
53 h_inode
= d_inode(h_dentry
);
54 spin_lock(&h_dentry
->d_lock
);
55 err
= (!d_unhashed(dentry
) && d_unlinked(h_dentry
))
56 /* || !d_inode(dentry)->i_nlink */
58 spin_unlock(&h_dentry
->d_lock
);
63 br
= au_sbr(sb
, bindex
);
64 err
= au_br_test_oflag(flags
, br
);
65 h_file
= ERR_PTR(err
);
69 /* drop flags for writing */
70 if (au_test_ro(sb
, bindex
, d_inode(dentry
))) {
71 if (force_wr
&& !(flags
& O_WRONLY
))
73 flags
= au_file_roflags(flags
);
75 h_file
= ERR_PTR(-EROFS
);
76 flags
= au_file_roflags(flags
);
77 if (unlikely(vfsub_native_ro(h_inode
)
78 || IS_APPEND(h_inode
)))
86 h_path
.dentry
= h_dentry
;
87 h_path
.mnt
= au_br_mnt(br
);
88 h_file
= vfsub_dentry_open(&h_path
, flags
);
92 if (flags
& __FMODE_EXEC
) {
93 err
= deny_write_access(h_file
);
96 h_file
= ERR_PTR(err
);
100 fsnotify_open(h_file
);
101 goto out
; /* success */
109 static int au_cmoo(struct dentry
*dentry
)
115 struct au_cp_generic cpg
= {
121 .flags
= AuCpup_DTIME
| AuCpup_HOPEN
123 struct inode
*delegated
;
124 struct super_block
*sb
;
125 struct au_sbinfo
*sbinfo
;
126 struct au_fhsm
*fhsm
;
128 struct au_branch
*br
;
129 struct dentry
*parent
;
130 struct au_hinode
*hdir
;
132 DiMustWriteLock(dentry
);
133 IiMustWriteLock(d_inode(dentry
));
138 cpg
.bsrc
= au_dbtop(dentry
);
144 fhsm
= &sbinfo
->si_fhsm
;
145 pid
= au_fhsm_pid(fhsm
);
147 && (current
->pid
== pid
148 || current
->real_parent
->pid
== pid
))
151 br
= au_sbr(sb
, cpg
.bsrc
);
152 cmoo
= au_br_cmoo(br
->br_perm
);
155 if (!d_is_reg(dentry
))
156 cmoo
&= AuBrAttr_COO_ALL
;
160 parent
= dget_parent(dentry
);
161 di_write_lock_parent(parent
);
162 err
= au_wbr_do_copyup_bu(dentry
, cpg
.bsrc
- 1);
164 if (unlikely(err
< 0)) {
165 err
= 0; /* there is no upper writable branch */
168 AuDbg("bsrc %d, bdst %d\n", cpg
.bsrc
, cpg
.bdst
);
170 /* do not respect the coo attrib for the target branch */
171 err
= au_cpup_dirs(dentry
, cpg
.bdst
);
175 di_downgrade_lock(parent
, AuLock_IR
);
176 udba
= au_opt_udba(sb
);
177 err
= au_pin(&pin
, dentry
, cpg
.bdst
, udba
,
178 AuPin_DI_LOCKED
| AuPin_MNT_WRITE
);
182 err
= au_sio_cpup_simple(&cpg
);
186 if (!(cmoo
& AuBrWAttr_MOO
))
187 goto out_parent
; /* success */
189 err
= au_pin(&pin
, dentry
, cpg
.bsrc
, udba
,
190 AuPin_DI_LOCKED
| AuPin_MNT_WRITE
);
194 h_path
.mnt
= au_br_mnt(br
);
195 h_path
.dentry
= au_h_dptr(dentry
, cpg
.bsrc
);
196 hdir
= au_hi(d_inode(parent
), cpg
.bsrc
);
198 err
= vfsub_unlink(hdir
->hi_inode
, &h_path
, &delegated
, /*force*/1);
200 /* todo: keep h_dentry or not? */
201 if (unlikely(err
== -EWOULDBLOCK
)) {
202 pr_warn("cannot retry for NFSv4 delegation"
203 " for an internal unlink\n");
207 pr_err("unlink %pd after coo failed (%d), ignored\n",
211 goto out_parent
; /* success */
214 di_downgrade_lock(parent
, AuLock_IR
);
216 di_read_unlock(parent
, AuLock_IR
);
223 int au_do_open(struct file
*file
, struct au_do_open_args
*args
)
225 int err
, no_lock
= args
->no_lock
;
226 struct dentry
*dentry
;
227 struct au_finfo
*finfo
;
230 err
= au_finfo_init(file
, args
->fidir
);
233 err
= au_finfo_init(file
, args
->fidir
);
239 dentry
= file
->f_path
.dentry
;
240 AuDebugOn(IS_ERR_OR_NULL(dentry
));
242 di_write_lock_child(dentry
);
243 err
= au_cmoo(dentry
);
244 di_downgrade_lock(dentry
, AuLock_IR
);
246 err
= args
->open(file
, vfsub_file_flags(file
), NULL
);
247 di_read_unlock(dentry
, AuLock_IR
);
249 err
= au_cmoo(dentry
);
251 err
= args
->open(file
, vfsub_file_flags(file
),
253 if (!err
&& au_fbtop(file
) != au_dbtop(dentry
))
255 * cmoo happens after h_file was opened.
256 * need to refresh file later.
258 atomic_dec(&au_fi(file
)->fi_generation
);
263 finfo
->fi_file
= file
;
264 au_sphl_add(&finfo
->fi_hlist
,
265 &au_sbi(file
->f_path
.dentry
->d_sb
)->si_files
);
268 fi_write_unlock(file
);
271 fi_write_unlock(file
);
275 finfo
->fi_hdir
= NULL
;
283 int au_reopen_nondir(struct file
*file
)
287 struct dentry
*dentry
;
288 struct file
*h_file
, *h_file_tmp
;
290 dentry
= file
->f_path
.dentry
;
291 btop
= au_dbtop(dentry
);
293 if (au_fbtop(file
) == btop
) {
294 h_file
= au_hf_top(file
);
295 if (file
->f_mode
== h_file
->f_mode
)
296 return 0; /* success */
298 get_file(h_file_tmp
);
299 au_set_h_fptr(file
, btop
, NULL
);
301 AuDebugOn(au_fi(file
)->fi_hdir
);
304 * file exists on both of rw and ro
305 * open --> dbtop and fbtop are both 0
306 * prepend a branch as rw, "rw" become ro
308 * delete the top branch, "rw" becomes rw again
309 * --> dbtop is 1, fbtop is still 0
310 * write --> fbtop is 0 but dbtop is 1
312 /* AuDebugOn(au_fbtop(file) < btop); */
314 h_file
= au_h_open(dentry
, btop
, vfsub_file_flags(file
) & ~O_TRUNC
,
315 file
, /*force_wr*/0);
316 err
= PTR_ERR(h_file
);
317 if (IS_ERR(h_file
)) {
319 au_sbr_get(dentry
->d_sb
, btop
);
320 au_set_h_fptr(file
, btop
, h_file_tmp
);
323 goto out
; /* todo: close all? */
327 au_set_fbtop(file
, btop
);
328 au_set_h_fptr(file
, btop
, h_file
);
329 au_update_figen(file
);
330 /* todo: necessary? */
331 /* file->f_ra = h_file->f_ra; */
339 /* ---------------------------------------------------------------------- */
341 static int au_reopen_wh(struct file
*file
, aufs_bindex_t btgt
,
342 struct dentry
*hi_wh
)
346 struct au_dinfo
*dinfo
;
347 struct dentry
*h_dentry
;
348 struct au_hdentry
*hdp
;
350 dinfo
= au_di(file
->f_path
.dentry
);
351 AuRwMustWriteLock(&dinfo
->di_rwsem
);
353 btop
= dinfo
->di_btop
;
354 dinfo
->di_btop
= btgt
;
355 hdp
= au_hdentry(dinfo
, btgt
);
356 h_dentry
= hdp
->hd_dentry
;
357 hdp
->hd_dentry
= hi_wh
;
358 err
= au_reopen_nondir(file
);
359 hdp
->hd_dentry
= h_dentry
;
360 dinfo
->di_btop
= btop
;
365 static int au_ready_to_write_wh(struct file
*file
, loff_t len
,
366 aufs_bindex_t bcpup
, struct au_pin
*pin
)
369 struct inode
*inode
, *h_inode
;
370 struct dentry
*h_dentry
, *hi_wh
;
371 struct au_cp_generic cpg
= {
372 .dentry
= file
->f_path
.dentry
,
379 au_update_dbtop(cpg
.dentry
);
380 inode
= d_inode(cpg
.dentry
);
382 if (au_dbtop(cpg
.dentry
) <= bcpup
383 && au_dbbot(cpg
.dentry
) >= bcpup
) {
384 h_dentry
= au_h_dptr(cpg
.dentry
, bcpup
);
385 if (h_dentry
&& d_is_positive(h_dentry
))
386 h_inode
= d_inode(h_dentry
);
388 hi_wh
= au_hi_wh(inode
, bcpup
);
389 if (!hi_wh
&& !h_inode
)
390 err
= au_sio_cpup_wh(&cpg
, file
);
392 /* already copied-up after unlink */
393 err
= au_reopen_wh(file
, bcpup
, hi_wh
);
396 && (inode
->i_nlink
> 1
397 || (inode
->i_state
& I_LINKABLE
))
398 && au_opt_test(au_mntflags(cpg
.dentry
->d_sb
), PLINK
))
399 au_plink_append(inode
, bcpup
, au_h_dptr(cpg
.dentry
, bcpup
));
405 * prepare the @file for writing.
407 int au_ready_to_write(struct file
*file
, loff_t len
, struct au_pin
*pin
)
411 struct dentry
*parent
;
413 struct super_block
*sb
;
415 struct au_cp_generic cpg
= {
416 .dentry
= file
->f_path
.dentry
,
421 .flags
= AuCpup_DTIME
424 sb
= cpg
.dentry
->d_sb
;
425 inode
= d_inode(cpg
.dentry
);
426 cpg
.bsrc
= au_fbtop(file
);
427 err
= au_test_ro(sb
, cpg
.bsrc
, inode
);
428 if (!err
&& (au_hf_top(file
)->f_mode
& FMODE_WRITE
)) {
429 err
= au_pin(pin
, cpg
.dentry
, cpg
.bsrc
, AuOpt_UDBA_NONE
,
434 /* need to cpup or reopen */
435 parent
= dget_parent(cpg
.dentry
);
436 di_write_lock_parent(parent
);
437 err
= AuWbrCopyup(au_sbi(sb
), cpg
.dentry
);
439 if (unlikely(err
< 0))
443 if (!d_unhashed(cpg
.dentry
) && !au_h_dptr(parent
, cpg
.bdst
)) {
444 err
= au_cpup_dirs(cpg
.dentry
, cpg
.bdst
);
449 err
= au_pin(pin
, cpg
.dentry
, cpg
.bdst
, AuOpt_UDBA_NONE
,
450 AuPin_DI_LOCKED
| AuPin_MNT_WRITE
);
454 dbtop
= au_dbtop(cpg
.dentry
);
455 if (dbtop
<= cpg
.bdst
)
458 if (dbtop
<= cpg
.bdst
/* just reopen */
459 || !d_unhashed(cpg
.dentry
) /* copyup and reopen */
461 h_file
= au_h_open_pre(cpg
.dentry
, cpg
.bsrc
, /*force_wr*/0);
463 err
= PTR_ERR(h_file
);
465 di_downgrade_lock(parent
, AuLock_IR
);
466 if (dbtop
> cpg
.bdst
)
467 err
= au_sio_cpup_simple(&cpg
);
469 err
= au_reopen_nondir(file
);
470 au_h_open_post(cpg
.dentry
, cpg
.bsrc
, h_file
);
472 } else { /* copyup as wh and reopen */
474 * since writable hfsplus branch is not supported,
475 * h_open_pre/post() are unnecessary.
477 err
= au_ready_to_write_wh(file
, len
, cpg
.bdst
, pin
);
478 di_downgrade_lock(parent
, AuLock_IR
);
482 au_pin_set_parent_lflag(pin
, /*lflag*/0);
483 goto out_dput
; /* success */
489 di_downgrade_lock(parent
, AuLock_IR
);
491 di_read_unlock(parent
, AuLock_IR
);
498 /* ---------------------------------------------------------------------- */
500 int au_do_flush(struct file
*file
, fl_owner_t id
,
501 int (*flush
)(struct file
*file
, fl_owner_t id
))
504 struct super_block
*sb
;
507 inode
= file_inode(file
);
509 si_noflush_read_lock(sb
);
511 ii_read_lock_child(inode
);
513 err
= flush(file
, id
);
514 au_cpup_attr_timesizes(inode
);
516 ii_read_unlock(inode
);
517 fi_read_unlock(file
);
522 /* ---------------------------------------------------------------------- */
524 static int au_file_refresh_by_inode(struct file
*file
, int *need_reopen
)
528 struct au_finfo
*finfo
;
529 struct dentry
*parent
, *hi_wh
;
531 struct super_block
*sb
;
532 struct au_cp_generic cpg
= {
533 .dentry
= file
->f_path
.dentry
,
538 .flags
= AuCpup_DTIME
541 FiMustWriteLock(file
);
545 sb
= cpg
.dentry
->d_sb
;
546 inode
= d_inode(cpg
.dentry
);
547 cpg
.bdst
= au_ibtop(inode
);
548 if (cpg
.bdst
== finfo
->fi_btop
|| IS_ROOT(cpg
.dentry
))
551 parent
= dget_parent(cpg
.dentry
);
552 if (au_test_ro(sb
, cpg
.bdst
, inode
)) {
553 di_read_lock_parent(parent
, !AuLock_IR
);
554 err
= AuWbrCopyup(au_sbi(sb
), cpg
.dentry
);
556 di_read_unlock(parent
, !AuLock_IR
);
557 if (unlikely(err
< 0))
562 di_read_lock_parent(parent
, AuLock_IR
);
563 hi_wh
= au_hi_wh(inode
, cpg
.bdst
);
564 if (!S_ISDIR(inode
->i_mode
)
565 && au_opt_test(au_mntflags(sb
), PLINK
)
566 && au_plink_test(inode
)
567 && !d_unhashed(cpg
.dentry
)
568 && cpg
.bdst
< au_dbtop(cpg
.dentry
)) {
569 err
= au_test_and_cpup_dirs(cpg
.dentry
, cpg
.bdst
);
573 /* always superio. */
574 err
= au_pin(&pin
, cpg
.dentry
, cpg
.bdst
, AuOpt_UDBA_NONE
,
575 AuPin_DI_LOCKED
| AuPin_MNT_WRITE
);
577 err
= au_sio_cpup_simple(&cpg
);
581 /* already copied-up after unlink */
582 err
= au_reopen_wh(file
, cpg
.bdst
, hi_wh
);
587 di_read_unlock(parent
, AuLock_IR
);
594 static void au_do_refresh_dir(struct file
*file
)
596 aufs_bindex_t bindex
, bbot
, new_bindex
, brid
;
597 struct au_hfile
*p
, tmp
, *q
;
598 struct au_finfo
*finfo
;
599 struct super_block
*sb
;
600 struct au_fidir
*fidir
;
602 FiMustWriteLock(file
);
604 sb
= file
->f_path
.dentry
->d_sb
;
606 fidir
= finfo
->fi_hdir
;
608 p
= fidir
->fd_hfile
+ finfo
->fi_btop
;
609 brid
= p
->hf_br
->br_id
;
610 bbot
= fidir
->fd_bbot
;
611 for (bindex
= finfo
->fi_btop
; bindex
<= bbot
; bindex
++, p
++) {
615 new_bindex
= au_br_index(sb
, p
->hf_br
->br_id
);
616 if (new_bindex
== bindex
)
618 if (new_bindex
< 0) {
619 au_set_h_fptr(file
, bindex
, NULL
);
623 /* swap two lower inode, and loop again */
624 q
= fidir
->fd_hfile
+ new_bindex
;
635 if (!au_test_mmapped(file
) && !d_unlinked(file
->f_path
.dentry
)) {
637 for (finfo
->fi_btop
= 0; finfo
->fi_btop
<= bbot
;
638 finfo
->fi_btop
++, p
++)
640 if (file_inode(p
->hf_file
))
642 au_hfput(p
, /*execed*/0);
645 bbot
= au_br_index(sb
, brid
);
646 for (finfo
->fi_btop
= 0; finfo
->fi_btop
< bbot
;
647 finfo
->fi_btop
++, p
++)
649 au_hfput(p
, /*execed*/0);
653 p
= fidir
->fd_hfile
+ bbot
;
654 for (fidir
->fd_bbot
= bbot
; fidir
->fd_bbot
>= finfo
->fi_btop
;
655 fidir
->fd_bbot
--, p
--)
657 if (file_inode(p
->hf_file
))
659 au_hfput(p
, /*execed*/0);
661 AuDebugOn(fidir
->fd_bbot
< finfo
->fi_btop
);
665 * after branch manipulating, refresh the file.
667 static int refresh_file(struct file
*file
, int (*reopen
)(struct file
*file
))
669 int err
, need_reopen
, nbr
;
670 aufs_bindex_t bbot
, bindex
;
671 struct dentry
*dentry
;
672 struct super_block
*sb
;
673 struct au_finfo
*finfo
;
674 struct au_hfile
*hfile
;
676 dentry
= file
->f_path
.dentry
;
678 nbr
= au_sbbot(sb
) + 1;
680 if (!finfo
->fi_hdir
) {
681 hfile
= &finfo
->fi_htop
;
682 AuDebugOn(!hfile
->hf_file
);
683 bindex
= au_br_index(sb
, hfile
->hf_br
->br_id
);
684 AuDebugOn(bindex
< 0);
685 if (bindex
!= finfo
->fi_btop
)
686 au_set_fbtop(file
, bindex
);
688 err
= au_fidir_realloc(finfo
, nbr
, /*may_shrink*/0);
691 au_do_refresh_dir(file
);
696 if (!au_test_mmapped(file
))
697 err
= au_file_refresh_by_inode(file
, &need_reopen
);
699 /* harmless if err */
700 au_fidir_realloc(finfo
, nbr
, /*may_shrink*/1);
701 if (!err
&& need_reopen
&& !d_unlinked(dentry
))
704 au_update_figen(file
);
705 goto out
; /* success */
708 /* error, close all lower files */
709 if (finfo
->fi_hdir
) {
710 bbot
= au_fbbot_dir(file
);
711 for (bindex
= au_fbtop(file
); bindex
<= bbot
; bindex
++)
712 au_set_h_fptr(file
, bindex
, NULL
);
719 /* common function to regular file and dir */
720 int au_reval_and_lock_fdi(struct file
*file
, int (*reopen
)(struct file
*file
),
721 int wlock
, unsigned int fi_lsc
)
724 unsigned int sigen
, figen
;
726 unsigned char pseudo_link
;
727 struct dentry
*dentry
;
731 dentry
= file
->f_path
.dentry
;
732 inode
= d_inode(dentry
);
733 sigen
= au_sigen(dentry
->d_sb
);
734 fi_write_lock_nested(file
, fi_lsc
);
735 figen
= au_figen(file
);
737 di_write_lock_child(dentry
);
739 di_write_lock_child2(dentry
);
740 btop
= au_dbtop(dentry
);
741 pseudo_link
= (btop
!= au_ibtop(inode
));
742 if (sigen
== figen
&& !pseudo_link
&& au_fbtop(file
) == btop
) {
744 di_downgrade_lock(dentry
, AuLock_IR
);
745 fi_downgrade_lock(file
);
747 goto out
; /* success */
750 AuDbg("sigen %d, figen %d\n", sigen
, figen
);
751 if (au_digen_test(dentry
, sigen
)) {
752 err
= au_reval_dpath(dentry
, sigen
);
753 AuDebugOn(!err
&& au_digen_test(dentry
, sigen
));
757 err
= refresh_file(file
, reopen
);
760 di_downgrade_lock(dentry
, AuLock_IR
);
761 fi_downgrade_lock(file
);
764 di_write_unlock(dentry
);
765 fi_write_unlock(file
);
772 /* ---------------------------------------------------------------------- */
774 /* cf. aufs_nopage() */
776 static int aufs_readpage(struct file
*file __maybe_unused
, struct page
*page
)
782 /* it will never be called, but necessary to support O_DIRECT */
783 static ssize_t
aufs_direct_IO(struct kiocb
*iocb
, struct iov_iter
*iter
)
786 /* they will never be called. */
787 #ifdef CONFIG_AUFS_DEBUG
788 static int aufs_write_begin(struct file
*file
, struct address_space
*mapping
,
789 loff_t pos
, unsigned len
, unsigned flags
,
790 struct page
**pagep
, void **fsdata
)
791 { AuUnsupport(); return 0; }
792 static int aufs_write_end(struct file
*file
, struct address_space
*mapping
,
793 loff_t pos
, unsigned len
, unsigned copied
,
794 struct page
*page
, void *fsdata
)
795 { AuUnsupport(); return 0; }
796 static int aufs_writepage(struct page
*page
, struct writeback_control
*wbc
)
797 { AuUnsupport(); return 0; }
799 static int aufs_set_page_dirty(struct page
*page
)
800 { AuUnsupport(); return 0; }
801 static void aufs_invalidatepage(struct page
*page
, unsigned int offset
,
804 static int aufs_releasepage(struct page
*page
, gfp_t gfp
)
805 { AuUnsupport(); return 0; }
806 #if 0 /* called by memory compaction regardless file */
807 static int aufs_migratepage(struct address_space
*mapping
, struct page
*newpage
,
808 struct page
*page
, enum migrate_mode mode
)
809 { AuUnsupport(); return 0; }
811 static bool aufs_isolate_page(struct page
*page
, isolate_mode_t mode
)
812 { AuUnsupport(); return true; }
813 static void aufs_putback_page(struct page
*page
)
815 static int aufs_launder_page(struct page
*page
)
816 { AuUnsupport(); return 0; }
817 static int aufs_is_partially_uptodate(struct page
*page
,
820 { AuUnsupport(); return 0; }
821 static void aufs_is_dirty_writeback(struct page
*page
, bool *dirty
,
824 static int aufs_error_remove_page(struct address_space
*mapping
,
826 { AuUnsupport(); return 0; }
827 static int aufs_swap_activate(struct swap_info_struct
*sis
, struct file
*file
,
829 { AuUnsupport(); return 0; }
830 static void aufs_swap_deactivate(struct file
*file
)
832 #endif /* CONFIG_AUFS_DEBUG */
834 const struct address_space_operations aufs_aop
= {
835 .readpage
= aufs_readpage
,
836 .direct_IO
= aufs_direct_IO
,
837 #ifdef CONFIG_AUFS_DEBUG
838 .writepage
= aufs_writepage
,
839 /* no writepages, because of writepage */
840 .set_page_dirty
= aufs_set_page_dirty
,
841 /* no readpages, because of readpage */
842 .write_begin
= aufs_write_begin
,
843 .write_end
= aufs_write_end
,
844 /* no bmap, no block device */
845 .invalidatepage
= aufs_invalidatepage
,
846 .releasepage
= aufs_releasepage
,
847 /* is fallback_migrate_page ok? */
848 /* .migratepage = aufs_migratepage, */
849 .isolate_page
= aufs_isolate_page
,
850 .putback_page
= aufs_putback_page
,
851 .launder_page
= aufs_launder_page
,
852 .is_partially_uptodate
= aufs_is_partially_uptodate
,
853 .is_dirty_writeback
= aufs_is_dirty_writeback
,
854 .error_remove_page
= aufs_error_remove_page
,
855 .swap_activate
= aufs_swap_activate
,
856 .swap_deactivate
= aufs_swap_deactivate
857 #endif /* CONFIG_AUFS_DEBUG */