← Back to branch summary

~ubuntu-branches/ubuntu/quantal/aufs/quantal

« back to all changes in this revision

Viewing changes to patch/ubuntu-2.6.24-5.8.patch

  • Committer: Bazaar Package Importer
  • Author(s): Julian Andres Klode
  • Date: 2008-04-01 18:26:37 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20080401182637-ujuqq47eiggw4y5w
Tags: 0+20080401-1
http://bugs.debian.org/471288
http://bugs.debian.org/473767
http://bugs.debian.org/473430
* New upstream snapshot
  - Remove bashisms in script (Closes: #471288)
* debian/conf.mk, linux-patch-aufs.kpatches.sysfs_get_dentry:
  - Remove support for this patch, no longer used
* debian/conf.mk:
  - Add hacks for arm to armel (Closes: #473767)
* debian/control:
  - Add Dm-Upload-Allowed
* debian/copyright:
  - Use http://wiki.debian.org/Proposals/CopyrightFormat
* debian/linux-patch-aufs.kpatches.{splice,put_filp}:
  - Add support for Kernel 2.6.24 (and 2.6.25)
* debian/patches:
  - 01_vserver_apparmor: Update patch
  - 06_rt: Add patch for realtime kernel
  - 07_splice_hack: Add hack to support splice operations (Closes: #473430)

Show diffs side-by-side

added added

removed removed

Lines of Context:
patch/ubuntu-2.6.24-5.8.patch
 
1
This patch makes aufs version 20080128 to support the ubuntu kernel only
 
2
(http://archive.ubuntu.com/ubuntu/pool/main/l/linux/linux-source-2.6.24_2.6.24-5.8_all.deb).
 
3
You may also want to try the updated lhash patch posted by an aufs user,
 
4
see Tips file in detail.
 
5
 
 
6
This patch is NOT tested because I am not an ubuntu user.
 
7
 
 
8
 
 
9
Index: fs/aufs/cpup.c
 
10
===================================================================
 
11
RCS file: /cvsroot/aufs/aufs/fs/aufs/cpup.c,v
 
12
retrieving revision 1.60
 
13
diff -u -p -r1.60 cpup.c
 
14
--- fs/aufs/cpup.c      21 Jan 2008 04:55:55 -0000      1.60
 
15
+++ fs/aufs/cpup.c      29 Jan 2008 14:42:07 -0000
 
16
@@ -120,7 +120,8 @@ void au_cpup_attr_all(struct inode *inod
 
17
 
 
18
 /* keep the timestamps of the parent dir when cpup */
 
19
 void au_dtime_store(struct au_dtime *dt, struct dentry *dentry,
 
20
-                   struct dentry *h_dentry, struct aufs_hinode *hdir)
 
21
+                   struct dentry *h_dentry, struct aufs_hinode *hdir,
 
22
+                   struct vfsmount *h_mnt)
 
23
 {
 
24
        struct inode *inode;
 
25
 
 
26
@@ -130,6 +131,7 @@ void au_dtime_store(struct au_dtime *dt,
 
27
        dt->dt_dentry = dentry;
 
28
        dt->dt_h_dentry = h_dentry;
 
29
        dt->dt_hdir = hdir;
 
30
+       dt->dt_h_mnt = h_mnt;
 
31
        inode = h_dentry->d_inode;
 
32
        dt->dt_atime = inode->i_atime;
 
33
        dt->dt_mtime = inode->i_mtime;
 
34
@@ -153,14 +155,15 @@ void au_dtime_revert(struct au_dtime *dt
 
35
        vfsub_args_init(&vargs, &ign, au_need_dlgt(dt->dt_dentry->d_sb), 0);
 
36
        if (unlikely(dt->dt_hdir))
 
37
                vfsub_ign_hinode(&vargs, IN_ATTRIB, dt->dt_hdir);
 
38
-       err = vfsub_notify_change(dt->dt_h_dentry, &attr, &vargs);
 
39
+       err = vfsub_notify_change(dt->dt_h_dentry, dt->dt_h_mnt, &attr, &vargs);
 
40
        if (unlikely(err))
 
41
                AuWarn("restoring timestamps failed(%d). ignored\n", err);
 
42
 }
 
43
 
 
44
 /* ---------------------------------------------------------------------- */
 
45
 
 
46
-static int cpup_iattr(struct dentry *h_dst, struct dentry *h_src, int dlgt)
 
47
+static int cpup_iattr(struct dentry *h_dst, struct dentry *h_src,
 
48
+                     struct vfsmount *h_dst_mnt, int dlgt)
 
49
 {
 
50
        int err, sbits;
 
51
        struct iattr ia;
 
52
@@ -184,7 +187,7 @@ static int cpup_iattr(struct dentry *h_d
 
53
        sbits = !!(ia.ia_mode & (S_ISUID | S_ISGID));
 
54
 
 
55
        vfsub_args_init(&vargs, NULL, dlgt, /*force_unlink*/0);
 
56
-       err = vfsub_notify_change(h_dst, &ia, &vargs);
 
57
+       err = vfsub_notify_change(h_dst, h_dst_mnt, &ia, &vargs);
 
58
        //if (LktrCond) err = -1;
 
59
 
 
60
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
 
61
@@ -192,7 +195,7 @@ static int cpup_iattr(struct dentry *h_d
 
62
        if (!err && sbits && au_test_nfs(h_dst->d_sb)) {
 
63
                ia.ia_valid = ATTR_FORCE | ATTR_MODE;
 
64
                ia.ia_mode = h_isrc->i_mode;
 
65
-               err = vfsub_notify_change(h_dst, &ia, &vargs);
 
66
+               err = vfsub_notify_change(h_dst, h_dst_mnt, &ia, &vargs);
 
67
        }
 
68
 #endif
 
69
        if (!err)
 
70
@@ -263,7 +266,8 @@ static int cpup_regular(struct dentry *d
 
71
 
 
72
        /* stop updating while we copyup */
 
73
        IMustLock(hidden[SRC].dentry->d_inode);
 
74
-       err = au_copy_file(hidden[DST].file, hidden[SRC].file, len, sb);
 
75
+       err = au_copy_file(hidden[DST].file, hidden[SRC].file, len, sb,
 
76
+                          sbr_mnt(sb, bdst));
 
77
 
 
78
  out_dst_file:
 
79
        fput(hidden[DST].file);
 
80
@@ -289,6 +293,7 @@ static int cpup_entry(struct dentry *den
 
81
        char *sym;
 
82
        mm_segment_t old_fs;
 
83
        struct super_block *sb;
 
84
+       struct vfsmount *h_mnt;
 
85
        struct vfsub_args vargs;
 
86
        struct aufs_hinode *hgdir;
 
87
        const int do_dt = flags->dtime;
 
88
@@ -299,6 +304,7 @@ static int cpup_entry(struct dentry *den
 
89
        sb = dentry->d_sb;
 
90
        AuDebugOn(bdst >= bsrc || au_test_ro(sb, bdst, NULL));
 
91
        /* bsrc branch can be ro/rw. */
 
92
+       h_mnt = sbr_mnt(sb, bdst);
 
93
 
 
94
        h_src = au_h_dptr_i(dentry, bsrc);
 
95
        AuDebugOn(!h_src);
 
96
@@ -322,7 +328,7 @@ static int cpup_entry(struct dentry *den
 
97
                        hgdir = itohi(gparent->d_inode, bdst);
 
98
                        dput(gparent);
 
99
                }
 
100
-               au_dtime_store(&dt, parent, h_parent, hgdir);
 
101
+               au_dtime_store(&dt, parent, h_parent, hgdir, h_mnt);
 
102
        }
 
103
 
 
104
        mode = h_inode->i_mode;
 
105
@@ -344,7 +350,8 @@ static int cpup_entry(struct dentry *den
 
106
                        if (unlikely(err)) {
 
107
                                int rerr;
 
108
                                vfsub_args_init(&vargs, NULL, dlgt, 0);
 
109
-                               rerr = vfsub_unlink(h_dir, h_dst, &vargs);
 
110
+                               rerr = vfsub_unlink(h_dir, h_dst, h_mnt,
 
111
+                                                   &vargs);
 
112
                                if (rerr) {
 
113
                                        AuIOErr("failed unlinking cpup-ed %.*s"
 
114
                                                "(%d, %d)\n",
 
115
@@ -355,7 +362,7 @@ static int cpup_entry(struct dentry *den
 
116
                }
 
117
                break;
 
118
        case S_IFDIR:
 
119
-               err = vfsub_mkdir(h_dir, h_dst, mode, dlgt);
 
120
+               err = vfsub_mkdir(h_dir, h_dst, h_mnt, mode, dlgt);
 
121
                //if (LktrCond) {vfs_rmdir(h_dir, h_dst); err = -1;}
 
122
                if (!err) {
 
123
                        /* setattr case: dir is not locked */
 
124
@@ -379,7 +386,8 @@ static int cpup_entry(struct dentry *den
 
125
                set_fs(old_fs);
 
126
                if (symlen > 0) {
 
127
                        sym[symlen] = 0;
 
128
-                       err = vfsub_symlink(h_dir, h_dst, sym, mode, dlgt);
 
129
+                       err = vfsub_symlink(h_dir, h_dst, h_mnt, sym, mode,
 
130
+                                           dlgt);
 
131
                        //if (LktrCond)
 
132
                        //{vfs_unlink(h_dir, h_dst); err = -1;}
 
133
                }
 
134
@@ -391,7 +399,7 @@ static int cpup_entry(struct dentry *den
 
135
                /*FALLTHROUGH*/
 
136
        case S_IFIFO:
 
137
        case S_IFSOCK:
 
138
-               err = vfsub_mknod(h_dir, h_dst, mode,
 
139
+               err = vfsub_mknod(h_dir, h_dst, h_mnt, mode,
 
140
                                  au_h_rdev(h_inode, /*h_mnt*/NULL, h_src),
 
141
                                  dlgt);
 
142
                //if (LktrCond) {vfs_unlink(h_dir, h_dst); err = -1;}
 
143
@@ -425,6 +433,7 @@ int au_cpup_single(struct dentry *dentry
 
144
        struct vfsub_args vargs;
 
145
        struct aufs_sbinfo *sbinfo;
 
146
        struct aufs_hinode *hgdir;
 
147
+       struct vfsmount *h_mnt;
 
148
 
 
149
        LKTRTrace("%.*s, i%lu, bdst %d, bsrc %d, len %Ld, dtime %u\n",
 
150
                  AuDLNPair(dentry), dentry->d_inode->i_ino, bdst, bsrc, len,
 
151
@@ -444,6 +453,7 @@ int au_cpup_single(struct dentry *dentry
 
152
        dir = parent->d_inode;
 
153
 
 
154
        sbinfo = stosi(sb);
 
155
+       h_mnt = sbr_mnt(sb, bdst);
 
156
        dlgt = au_need_dlgt(sb);
 
157
        dst_inode = au_h_iptr_i(inode, bdst);
 
158
        if (unlikely(dst_inode)) {
 
159
@@ -460,7 +470,8 @@ int au_cpup_single(struct dentry *dentry
 
160
                        if (IS_ERR(h_src))
 
161
                                goto out;
 
162
                        AuDebugOn(!h_src->d_inode);
 
163
-                       err = vfsub_link(h_src, h_dir, h_dst, dlgt);
 
164
+                       err = vfsub_link(h_src, h_mnt, h_dir, h_dst, h_mnt,
 
165
+                                        dlgt);
 
166
                        dput(h_src);
 
167
                        goto out;
 
168
                } else
 
169
@@ -477,7 +488,7 @@ int au_cpup_single(struct dentry *dentry
 
170
        vfsub_i_lock_nested(dst_inode, AuLsc_I_CHILD2);
 
171
 
 
172
        //todo: test dlgt
 
173
-       err = cpup_iattr(h_dst, h_src, dlgt);
 
174
+       err = cpup_iattr(h_dst, h_src, h_mnt, dlgt);
 
175
        //if (LktrCond) err = -1;
 
176
 #if 0 // xattr
 
177
        if (0 && !err)
 
178
@@ -506,12 +517,12 @@ int au_cpup_single(struct dentry *dentry
 
179
                hgdir = itohi(gparent->d_inode, bdst);
 
180
                dput(gparent);
 
181
        }
 
182
-       au_dtime_store(&dt, parent, h_parent, hgdir);
 
183
+       au_dtime_store(&dt, parent, h_parent, hgdir, h_mnt);
 
184
        vfsub_args_init(&vargs, NULL, dlgt, 0);
 
185
        if (!isdir)
 
186
-               rerr = vfsub_unlink(h_dir, h_dst, &vargs);
 
187
+               rerr = vfsub_unlink(h_dir, h_dst, h_mnt, &vargs);
 
188
        else
 
189
-               rerr = vfsub_rmdir(h_dir, h_dst, &vargs);
 
190
+               rerr = vfsub_rmdir(h_dir, h_dst, h_mnt, &vargs);
 
191
        //rerr = -1;
 
192
        au_dtime_revert(&dt);
 
193
        if (rerr) {
 
194
@@ -689,6 +700,7 @@ int au_cpup_wh(struct dentry *dentry, au
 
195
        struct au_dtime dt;
 
196
        struct aufs_dinfo *dinfo;
 
197
        aufs_bindex_t bstart;
 
198
+       struct vfsmount *h_mnt;
 
199
        struct vfsub_args vargs;
 
200
        struct aufs_hinode *hgdir;
 
201
        struct aufs_ndx ndx = {
 
202
@@ -726,7 +738,8 @@ int au_cpup_wh(struct dentry *dentry, au
 
203
                hgdir = itohi(gparent->d_inode, bdst);
 
204
                dput(gparent);
 
205
        }
 
206
-       au_dtime_store(&dt, parent, h_parent, hgdir);
 
207
+       h_mnt = sbr_mnt(sb, bdst);
 
208
+       au_dtime_store(&dt, parent, h_parent, hgdir, h_mnt);
 
209
        dinfo = dtodi(dentry);
 
210
        bstart = dinfo->di_bstart;
 
211
        h_dentry_bdst = dinfo->di_hdentry[0 + bdst].hd_dentry;
 
212
@@ -752,7 +765,7 @@ int au_cpup_wh(struct dentry *dentry, au
 
213
        /* dget first to force sillyrename on nfs */
 
214
        dget(wh_dentry);
 
215
        vfsub_args_init(&vargs, NULL, ndx.dlgt, 0);
 
216
-       err = vfsub_unlink(h_dir, wh_dentry, &vargs);
 
217
+       err = vfsub_unlink(h_dir, wh_dentry, h_mnt, &vargs);
 
218
        //if (LktrCond) err = -1;
 
219
        if (unlikely(err)) {
 
220
                AuIOErr("failed remove copied-up tmp file %.*s(%d)\n",
 
221
Index: fs/aufs/cpup.h
 
222
===================================================================
 
223
RCS file: /cvsroot/aufs/aufs/fs/aufs/cpup.h,v
 
224
retrieving revision 1.26
 
225
diff -u -p -r1.26 cpup.h
 
226
--- fs/aufs/cpup.h      21 Jan 2008 04:56:10 -0000      1.26
 
227
+++ fs/aufs/cpup.h      29 Jan 2008 14:42:07 -0000
 
228
@@ -76,10 +76,12 @@ int au_test_and_cpup_dirs(struct dentry 
 
229
 struct au_dtime {
 
230
        struct dentry *dt_dentry, *dt_h_dentry;
 
231
        struct aufs_hinode *dt_hdir;
 
232
+       struct vfsmount *dt_h_mnt;
 
233
        struct timespec dt_atime, dt_mtime;
 
234
 };
 
235
 void au_dtime_store(struct au_dtime *dt, struct dentry *dentry,
 
236
-                   struct dentry *h_dentry, struct aufs_hinode *hdir);
 
237
+                   struct dentry *h_dentry, struct aufs_hinode *hdir,
 
238
+                   struct vfsmount *h_mnt);
 
239
 void au_dtime_revert(struct au_dtime *dt);
 
240
 
 
241
 #endif /* __KERNEL__ */
 
242
Index: fs/aufs/i_op.c
 
243
===================================================================
 
244
RCS file: /cvsroot/aufs/aufs/fs/aufs/i_op.c,v
 
245
retrieving revision 1.53
 
246
diff -u -p -r1.53 i_op.c
 
247
--- fs/aufs/i_op.c      28 Jan 2008 05:01:42 -0000      1.53
 
248
+++ fs/aufs/i_op.c      29 Jan 2008 14:42:07 -0000
 
249
@@ -547,7 +547,7 @@ static int aufs_setattr(struct dentry *d
 
250
                        vfsub_ign_hinode(&vargs, events, itohi(dir, bcpup));
 
251
        }
 
252
        HiLock(bcpup);
 
253
-       err = vfsub_notify_change(h_dentry, ia, &vargs);
 
254
+       err = vfsub_notify_change(h_dentry, sbr_mnt(sb, bcpup), ia, &vargs);
 
255
        //err = -1;
 
256
        if (!err)
 
257
                au_cpup_attr_changeable(inode);
 
258
Index: fs/aufs/i_op_add.c
 
259
===================================================================
 
260
RCS file: /cvsroot/aufs/aufs/fs/aufs/i_op_add.c,v
 
261
retrieving revision 1.58
 
262
diff -u -p -r1.58 i_op_add.c
 
263
--- fs/aufs/i_op_add.c  28 Jan 2008 05:02:00 -0000      1.58
 
264
+++ fs/aufs/i_op_add.c  29 Jan 2008 14:42:08 -0000
 
265
@@ -27,7 +27,7 @@
 
266
  * if it failed, re-create the removed whiteout.
 
267
  */
 
268
 static int epilog(struct inode *dir, struct dentry *wh_dentry,
 
269
-                 struct dentry *dentry)
 
270
+                 struct vfsmount *h_mnt, struct dentry *dentry)
 
271
 {
 
272
        int err, rerr;
 
273
        aufs_bindex_t bwh;
 
274
@@ -42,7 +42,7 @@ static int epilog(struct inode *dir, str
 
275
                h_dir = wh_dentry->d_parent->d_inode; /* dir inode is locked */
 
276
                IMustLock(h_dir);
 
277
                bwh = dbwh(dentry);
 
278
-               err = au_unlink_wh_dentry(h_dir, wh_dentry, dentry, dir,
 
279
+               err = au_unlink_wh_dentry(h_dir, wh_dentry, h_mnt, dentry, dir,
 
280
                                          /*dlgt*/0);
 
281
                //err = -1;
 
282
                if (unlikely(err))
 
283
@@ -148,7 +148,8 @@ lock_hdir_lkup_wh(struct dentry *dentry,
 
284
 #endif
 
285
 
 
286
        if (dt)
 
287
-               au_dtime_store(dt, parent, h_parent, hgdir);
 
288
+               au_dtime_store(dt, parent, h_parent, hgdir,
 
289
+                              sbr_mnt(parent->d_sb, bcpup));
 
290
        wh_dentry = NULL;
 
291
        if (/* bcpup != bstart || */ bcpup != dbwh(dentry))
 
292
                goto out; /* success */
 
293
@@ -197,6 +198,7 @@ static int add_simple(struct inode *dir,
 
294
        struct au_dtime dt;
 
295
        struct vfsub_args vargs;
 
296
        struct super_block *sb;
 
297
+       struct vfsmount *h_mnt;
 
298
        struct au_wr_dir_args wr_dir_args = {
 
299
                .force_btgt     = -1,
 
300
                .add_entry      = 1,
 
301
@@ -223,6 +225,7 @@ static int add_simple(struct inode *dir,
 
302
        IMustLock(h_dir);
 
303
        sb = dir->i_sb;
 
304
        dlgt = au_need_dlgt(sb);
 
305
+       h_mnt = sbr_mnt(sb, dbstart(dentry));
 
306
 
 
307
 #if 1 // partial testing
 
308
        switch (arg->type) {
 
309
@@ -232,11 +235,11 @@ static int add_simple(struct inode *dir,
 
310
                                  arg->u.c.nd, au_nfsmnt(sb, dbstart(dentry)));
 
311
                break;
 
312
        case Symlink:
 
313
-               err = vfsub_symlink(h_dir, h_dentry,
 
314
+               err = vfsub_symlink(h_dir, h_dentry, h_mnt,
 
315
                                    arg->u.s.symname, S_IALLUGO, dlgt);
 
316
                break;
 
317
        case Mknod:
 
318
-               err = vfsub_mknod(h_dir, h_dentry,
 
319
+               err = vfsub_mknod(h_dir, h_dentry, h_mnt,
 
320
                                  arg->u.m.mode, arg->u.m.dev, dlgt);
 
321
                break;
 
322
        default:
 
323
@@ -247,14 +250,14 @@ static int add_simple(struct inode *dir,
 
324
 #endif
 
325
        created = !err;
 
326
        if (!err)
 
327
-               err = epilog(dir, wh_dentry, dentry);
 
328
+               err = epilog(dir, wh_dentry, h_mnt, dentry);
 
329
        //err = -1;
 
330
 
 
331
        /* revert */
 
332
        if (unlikely(created && err && h_dentry->d_inode)) {
 
333
                int rerr;
 
334
                vfsub_args_init(&vargs, NULL, dlgt, 0);
 
335
-               rerr = vfsub_unlink(h_dir, h_dentry, &vargs);
 
336
+               rerr = vfsub_unlink(h_dir, h_dentry, h_mnt, &vargs);
 
337
                //rerr = -1;
 
338
                if (rerr) {
 
339
                        AuIOErr("%.*s revert failure(%d, %d)\n",
 
340
@@ -403,6 +406,7 @@ static int cpup_or_link(struct dentry *s
 
341
        aufs_bindex_t bstart;
 
342
        struct super_block *sb;
 
343
        struct au_cpup_flags cflags;
 
344
+       struct vfsmount *h_mnt;
 
345
 
 
346
        AuTraceEnter();
 
347
 
 
348
@@ -412,8 +416,11 @@ static int cpup_or_link(struct dentry *s
 
349
        h_inode = h_dentry->d_inode;
 
350
        bstart = ibstart(inode);
 
351
        h_dst_inode = NULL;
 
352
-       if (bstart <= a->bdst)
 
353
+       h_mnt = NULL;
 
354
+       if (bstart <= a->bdst) {
 
355
                h_dst_inode = au_h_iptr_i(inode, a->bdst);
 
356
+               h_mnt = sbr_mnt(sb, a->bdst);
 
357
+       }
 
358
 
 
359
        if (!h_dst_inode || !h_dst_inode->i_nlink) {
 
360
                /* copyup src_dentry as the name of dentry. */
 
361
@@ -431,8 +438,8 @@ static int cpup_or_link(struct dentry *s
 
362
                /* the inode of src_dentry already exists on a.bdst branch */
 
363
                h_dentry = d_find_alias(h_dst_inode);
 
364
                if (h_dentry) {
 
365
-                       err = vfsub_link(h_dentry, a->h_dir,
 
366
-                                        a->h_dentry, a->dlgt);
 
367
+                       err = vfsub_link(h_dentry, h_mnt, a->h_dir, a->h_dentry,
 
368
+                                        h_mnt, a->dlgt);
 
369
                        dput(h_dentry);
 
370
                } else {
 
371
                        AuIOErr("no dentry found for i%lu on b%d\n",
 
372
@@ -456,6 +463,7 @@ int aufs_link(struct dentry *src_dentry,
 
373
        struct au_dtime dt;
 
374
        struct link_arg a;
 
375
        struct super_block *sb;
 
376
+       struct vfsmount *h_mnt;
 
377
        struct vfsub_args vargs;
 
378
        struct au_wr_dir_args wr_dir_args = {
 
379
                //.force_btgt   = -1,
 
380
@@ -499,6 +507,7 @@ int aufs_link(struct dentry *src_dentry,
 
381
        a.bsrc = dbstart(src_dentry);
 
382
        a.bdst = dbstart(dentry);
 
383
        h_src_dentry = au_h_dptr(src_dentry);
 
384
+       h_mnt = sbr_mnt(sb, a.bdst);
 
385
        if (unlikely(!AuFlag(stosi(sb), f_plink))) {
 
386
                /*
 
387
                 * copyup src_dentry to the branch we process,
 
388
@@ -511,8 +520,8 @@ int aufs_link(struct dentry *src_dentry,
 
389
                        err = cpup_before_link(src_dentry, dir, &a);
 
390
                if (!err) {
 
391
                        h_src_dentry = au_h_dptr(src_dentry);
 
392
-                       err = vfsub_link(h_src_dentry, a.h_dir,
 
393
-                                        a.h_dentry, a.dlgt);
 
394
+                       err = vfsub_link(h_src_dentry, h_mnt, a.h_dir,
 
395
+                                        a.h_dentry, h_mnt, a.dlgt);
 
396
                        //err = -1;
 
397
                }
 
398
        } else {
 
399
@@ -521,15 +530,15 @@ int aufs_link(struct dentry *src_dentry,
 
400
                        err = cpup_or_link(src_dentry, &a);
 
401
                else {
 
402
                        h_src_dentry = au_h_dptr(src_dentry);
 
403
-                       err = vfsub_link(h_src_dentry, a.h_dir,
 
404
-                                        a.h_dentry, a.dlgt);
 
405
+                       err = vfsub_link(h_src_dentry, h_mnt, a.h_dir,
 
406
+                                        a.h_dentry, h_mnt, a.dlgt);
 
407
                        //err = -1;
 
408
                }
 
409
        }
 
410
        if (unlikely(err))
 
411
                goto out_unlock;
 
412
        if (wh_dentry) {
 
413
-               err = au_unlink_wh_dentry(a.h_dir, wh_dentry, dentry,
 
414
+               err = au_unlink_wh_dentry(a.h_dir, wh_dentry, h_mnt, dentry,
 
415
                                          dir, /*dlgt*/0);
 
416
                //err = -1;
 
417
                if (unlikely(err))
 
418
@@ -600,7 +609,7 @@ int aufs_link(struct dentry *src_dentry,
 
419
        }
 
420
 #endif
 
421
        vfsub_args_init(&vargs, NULL, a.dlgt, 0);
 
422
-       rerr = vfsub_unlink(a.h_dir, a.h_dentry, &vargs);
 
423
+       rerr = vfsub_unlink(a.h_dir, a.h_dentry, h_mnt, &vargs);
 
424
        //rerr = -1;
 
425
        if (!rerr)
 
426
                goto out_dt;
 
427
@@ -635,6 +644,7 @@ int aufs_mkdir(struct inode *dir, struct
 
428
        struct au_dtime dt;
 
429
        aufs_bindex_t bindex;
 
430
        struct super_block *sb;
 
431
+       struct vfsmount *h_mnt;
 
432
        struct vfsub_args vargs;
 
433
        struct au_wr_dir_args wr_dir_args = {
 
434
                .force_btgt     = -1,
 
435
@@ -664,8 +674,9 @@ int aufs_mkdir(struct inode *dir, struct
 
436
        h_dir = h_parent->d_inode;
 
437
        IMustLock(h_dir);
 
438
        dlgt = au_need_dlgt(sb);
 
439
+       h_mnt = sbr_mnt(sb, bindex);
 
440
 
 
441
-       err = vfsub_mkdir(h_dir, h_dentry, mode, dlgt);
 
442
+       err = vfsub_mkdir(h_dir, h_dentry, h_mnt, mode, dlgt);
 
443
        //err = -1;
 
444
        if (unlikely(err))
 
445
                goto out_unlock;
 
446
@@ -685,7 +696,7 @@ int aufs_mkdir(struct inode *dir, struct
 
447
                diropq = 1;
 
448
        }
 
449
 
 
450
-       err = epilog(dir, wh_dentry, dentry);
 
451
+       err = epilog(dir, wh_dentry, h_mnt, dentry);
 
452
        //err = -1;
 
453
        if (!err) {
 
454
                dir->i_nlink++;
 
455
@@ -709,7 +720,7 @@ int aufs_mkdir(struct inode *dir, struct
 
456
  out_dir:
 
457
        LKTRLabel(revert dir);
 
458
        vfsub_args_init(&vargs, NULL, dlgt, 0);
 
459
-       rerr = vfsub_rmdir(h_dir, h_dentry, &vargs);
 
460
+       rerr = vfsub_rmdir(h_dir, h_dentry, h_mnt, &vargs);
 
461
        //rerr = -1;
 
462
        if (rerr) {
 
463
                AuIOErr("%.*s reverting dir failed(%d, %d)\n",
 
464
Index: fs/aufs/i_op_del.c
 
465
===================================================================
 
466
RCS file: /cvsroot/aufs/aufs/fs/aufs/i_op_del.c,v
 
467
retrieving revision 1.57
 
468
diff -u -p -r1.57 i_op_del.c
 
469
--- fs/aufs/i_op_del.c  28 Jan 2008 05:02:03 -0000      1.57
 
470
+++ fs/aufs/i_op_del.c  29 Jan 2008 14:42:08 -0000
 
471
@@ -153,7 +153,8 @@ lock_hdir_create_wh(struct dentry *dentr
 
472
        revalidate h_positive
 
473
 #endif
 
474
 
 
475
-       au_dtime_store(dt, parent, h_parent, hgdir);
 
476
+       au_dtime_store(dt, parent, h_parent, hgdir,
 
477
+                      sbr_mnt(dentry->d_sb, bcpup));
 
478
        wh_dentry = NULL;
 
479
        if (!need_wh)
 
480
                goto out; /* success, no need to create whiteout */
 
481
@@ -243,16 +244,17 @@ struct revert_flags {
 
482
        unsigned int    dlgt:1;
 
483
 };
 
484
 
 
485
-static int do_revert(int err, struct dentry *wh_dentry, struct dentry *dentry,
 
486
-                    aufs_bindex_t bwh, struct au_dtime *dt,
 
487
-                    struct revert_flags *flags)
 
488
+static int do_revert(int err, struct dentry *wh_dentry, struct vfsmount *h_mnt,
 
489
+                    struct dentry *dentry, aufs_bindex_t bwh,
 
490
+                    struct au_dtime *dt, struct revert_flags *flags)
 
491
 {
 
492
        int rerr;
 
493
        struct inode *dir;
 
494
 
 
495
        dir = wh_dentry->d_parent->d_inode; /* dir inode is locked */
 
496
        IMustLock(dir);
 
497
-       rerr = au_unlink_wh_dentry(dir, wh_dentry, dentry, dir, !!flags->dlgt);
 
498
+       rerr = au_unlink_wh_dentry(dir, wh_dentry, h_mnt, dentry, dir,
 
499
+                                  !!flags->dlgt);
 
500
        //rerr = -1;
 
501
        if (!rerr) {
 
502
                set_dbwh(dentry, bwh);
 
503
@@ -275,6 +277,7 @@ int aufs_unlink(struct inode *dir, struc
 
504
        struct au_dtime dt;
 
505
        aufs_bindex_t bwh, bindex, bstart;
 
506
        struct super_block *sb;
 
507
+       struct vfsmount *h_mnt;
 
508
        struct vfsub_args vargs;
 
509
 
 
510
        LKTRTrace("i%lu, %.*s\n", dir->i_ino, AuDLNPair(dentry));
 
511
@@ -301,12 +304,13 @@ int aufs_unlink(struct inode *dir, struc
 
512
        dlgt = au_need_dlgt(sb);
 
513
        h_dentry = au_h_dptr(dentry);
 
514
        dget(h_dentry);
 
515
+       h_mnt = sbr_mnt(sb, dbstart(dentry));
 
516
 
 
517
        if (bindex == bstart) {
 
518
                vfsub_args_init(&vargs, NULL, dlgt, 0);
 
519
                h_dir = h_dentry->d_parent->d_inode; /* dir inode is locked */
 
520
                IMustLock(h_dir);
 
521
-               err = vfsub_unlink(h_dir, h_dentry, &vargs);
 
522
+               err = vfsub_unlink(h_dir, h_dentry, h_mnt, &vargs);
 
523
                //err = -1;
 
524
        } else {
 
525
                /* dir inode is locked */
 
526
@@ -339,7 +343,8 @@ int aufs_unlink(struct inode *dir, struc
 
527
                struct revert_flags rev_flags = {
 
528
                        .dlgt   = dlgt
 
529
                };
 
530
-               rerr = do_revert(err, wh_dentry, dentry, bwh, &dt, &rev_flags);
 
531
+               rerr = do_revert(err, wh_dentry, h_mnt, dentry, bwh, &dt,
 
532
+                                &rev_flags);
 
533
                if (rerr)
 
534
                        err = rerr;
 
535
        }
 
536
@@ -365,6 +370,7 @@ int aufs_rmdir(struct inode *dir, struct
 
537
        struct rmdir_whtmp_args *args;
 
538
        struct aufs_nhash *whlist;
 
539
        struct super_block *sb;
 
540
+       struct vfsmount *h_mnt;
 
541
 
 
542
        LKTRTrace("i%lu, %.*s\n", dir->i_ino, AuDLNPair(dentry));
 
543
        IMustLock(dir);
 
544
@@ -403,6 +409,7 @@ int aufs_rmdir(struct inode *dir, struct
 
545
 
 
546
        h_dentry = au_h_dptr(dentry);
 
547
        dget(h_dentry);
 
548
+       h_mnt = sbr_mnt(dentry->d_sb, dbstart(dentry));
 
549
 
 
550
        rmdir_later = 0;
 
551
        if (bindex == bstart) {
 
552
@@ -449,7 +456,8 @@ int aufs_rmdir(struct inode *dir, struct
 
553
                struct revert_flags rev_flags = {
 
554
                        .dlgt   = au_need_dlgt(sb)
 
555
                };
 
556
-               rerr = do_revert(err, wh_dentry, dentry, bwh, &dt, &rev_flags);
 
557
+               rerr = do_revert(err, wh_dentry, h_mnt, dentry, bwh, &dt,
 
558
+                                &rev_flags);
 
559
                if (rerr)
 
560
                        err = rerr;
 
561
        }
 
562
Index: fs/aufs/i_op_ren.c
 
563
===================================================================
 
564
RCS file: /cvsroot/aufs/aufs/fs/aufs/i_op_ren.c,v
 
565
retrieving revision 1.63
 
566
diff -u -p -r1.63 i_op_ren.c
 
567
--- fs/aufs/i_op_ren.c  28 Jan 2008 05:02:03 -0000      1.63
 
568
+++ fs/aufs/i_op_ren.c  29 Jan 2008 14:42:08 -0000
 
569
@@ -26,6 +26,7 @@ struct rename_args {
 
570
        struct aufs_nhash whlist;
 
571
        aufs_bindex_t btgt, bstart[2];
 
572
        struct super_block *sb;
 
573
+       struct vfsmount *h_mnt;
 
574
 
 
575
        unsigned int isdir:1;
 
576
        unsigned int issamedir:1;
 
577
@@ -146,8 +147,9 @@ static int do_rename(struct inode *src_d
 
578
                if (unlikely(a->udba && a->isdir))
 
579
                        vfsub_ign_hinode(&vargs, IN_MOVE_SELF,
 
580
                                         itohi(src_dentry->d_inode, a->btgt));
 
581
-               err = vfsub_rename(h_dir[SRC], au_h_dptr(src_dentry),
 
582
-                                  h_dir[DST], a->h_dentry[DST], &vargs);
 
583
+               err = vfsub_rename(h_dir[SRC], au_h_dptr(src_dentry), a->h_mnt,
 
584
+                                  h_dir[DST], a->h_dentry[DST], a->h_mnt,
 
585
+                                  &vargs);
 
586
                //err = -1;
 
587
        } else {
 
588
                bycpup = 1;
 
589
@@ -185,7 +187,7 @@ static int do_rename(struct inode *src_d
 
590
 
 
591
        /* remove whiteout for dentry */
 
592
        if (wh_dentry[DST]) {
 
593
-               err = au_unlink_wh_dentry(h_dir[DST], wh_dentry[DST],
 
594
+               err = au_unlink_wh_dentry(h_dir[DST], wh_dentry[DST], a->h_mnt,
 
595
                                          dentry, dir, /*dlgt*/0);
 
596
                //err = -1;
 
597
                if (unlikely(err))
 
598
@@ -254,8 +256,8 @@ static int do_rename(struct inode *src_d
 
599
                        vfsub_ign_hinode(&vargs, IN_MOVE_SELF,
 
600
                                         itohi(src_dentry->d_inode, a->btgt));
 
601
                rerr = vfsub_rename
 
602
-                       (h_dir[DST], au_h_dptr_i(src_dentry, a->btgt),
 
603
-                        h_dir[SRC], d, &vargs);
 
604
+                       (h_dir[DST], au_h_dptr_i(src_dentry, a->btgt), a->h_mnt,
 
605
+                        h_dir[SRC], d, a->h_mnt, &vargs);
 
606
                //rerr = -1;
 
607
                d_drop(d);
 
608
                dput(d);
 
609
@@ -264,7 +266,8 @@ static int do_rename(struct inode *src_d
 
610
                        RevertFailure("rename %.*s", AuDLNPair(src_dentry));
 
611
        } else {
 
612
                vfsub_args_init(&vargs, NULL, a->dlgt, 0);
 
613
-               rerr = vfsub_unlink(h_dir[DST], a->h_dentry[DST], &vargs);
 
614
+               rerr = vfsub_unlink(h_dir[DST], a->h_dentry[DST], a->h_mnt,
 
615
+                                   &vargs);
 
616
                //rerr = -1;
 
617
                set_h_dptr(src_dentry, a->btgt, NULL);
 
618
                set_dbstart(src_dentry, a->bstart[SRC]);
 
619
@@ -294,7 +297,8 @@ static int do_rename(struct inode *src_d
 
620
                if (unlikely(0 && a->udba && a->isdir))
 
621
                        vfsub_ign_hinode(&vargs, IN_MOVE_SELF,
 
622
                                         itohi(dentry->d_inode, a->btgt));
 
623
-               rerr = vfsub_rename(h_dir[DST], h_dst, h_dir[DST], d, &vargs);
 
624
+               rerr = vfsub_rename(h_dir[DST], h_dst, a->h_mnt, h_dir[DST], d,
 
625
+                                   a->h_mnt, &vargs);
 
626
                //rerr = -1;
 
627
                d_drop(d);
 
628
                dput(d);
 
629
@@ -311,7 +315,7 @@ static int do_rename(struct inode *src_d
 
630
  out_whsrc:
 
631
        if (wh_dentry[SRC]) {
 
632
                LKTRLabel(here);
 
633
-               rerr = au_unlink_wh_dentry(h_dir[SRC], wh_dentry[SRC],
 
634
+               rerr = au_unlink_wh_dentry(h_dir[SRC], wh_dentry[SRC], a->h_mnt,
 
635
                                           src_dentry, src_dir, /*dlgt*/0);
 
636
                //rerr = -1;
 
637
                if (rerr)
 
638
@@ -572,6 +576,7 @@ int aufs_rename(struct inode *src_dir, s
 
639
        hgdir[SRC] = NULL;
 
640
        hgdir[DST] = NULL;
 
641
        au_hgdirs(hgdir, &p->a);
 
642
+       p->a.h_mnt = sbr_mnt(p->a.sb, p->a.btgt);
 
643
        p->a.h_parent[SRC] = au_h_dptr_i(p->a.parent[SRC], p->a.btgt);
 
644
        p->a.h_parent[DST] = au_h_dptr_i(p->a.parent[DST], p->a.btgt);
 
645
        dirs[0] = src_dir;
 
646
@@ -602,20 +607,22 @@ int aufs_rename(struct inode *src_dir, s
 
647
 
 
648
        /* store timestamps to be revertible */
 
649
        au_dtime_store(p->dt[PARENT] + SRC, p->a.parent[SRC],
 
650
-                      p->a.h_parent[SRC], hgdir[SRC]);
 
651
+                      p->a.h_parent[SRC], hgdir[SRC], p->a.h_mnt);
 
652
        if (!p->a.issamedir)
 
653
                au_dtime_store(p->dt[PARENT] + DST, p->a.parent[DST],
 
654
-                              p->a.h_parent[DST], hgdir[DST]);
 
655
+                              p->a.h_parent[DST], hgdir[DST], p->a.h_mnt);
 
656
        do_dt_dstdir = 0;
 
657
        if (p->a.isdir) {
 
658
                au_dtime_store
 
659
                        (p->dt[CHILD] + SRC, src_dentry, p->a.h_dentry[SRC],
 
660
-                        itohi(p->a.parent[SRC]->d_inode, p->a.btgt));
 
661
+                        itohi(p->a.parent[SRC]->d_inode, p->a.btgt),
 
662
+                        p->a.h_mnt);
 
663
                if (p->a.h_dentry[DST]->d_inode) {
 
664
                        do_dt_dstdir = 1;
 
665
                        au_dtime_store
 
666
                                (p->dt[CHILD] + DST, dentry, p->a.h_dentry[DST],
 
667
-                                itohi(p->a.parent[DST]->d_inode, p->a.btgt));
 
668
+                                itohi(p->a.parent[DST]->d_inode, p->a.btgt),
 
669
+                                p->a.h_mnt);
 
670
                }
 
671
        }
 
672
 
 
673
Index: fs/aufs/misc.c
 
674
===================================================================
 
675
RCS file: /cvsroot/aufs/aufs/fs/aufs/misc.c,v
 
676
retrieving revision 1.47
 
677
diff -u -p -r1.47 misc.c
 
678
--- fs/aufs/misc.c      12 Nov 2007 01:40:06 -0000      1.47
 
679
+++ fs/aufs/misc.c      29 Jan 2008 14:42:08 -0000
 
680
@@ -154,7 +154,7 @@ int au_h_create(struct inode *h_dir, str
 
681
 /* ---------------------------------------------------------------------- */
 
682
 
 
683
 int au_copy_file(struct file *dst, struct file *src, loff_t len,
 
684
-                struct super_block *sb)
 
685
+                struct super_block *sb, struct vfsmount *dst_mnt)
 
686
 {
 
687
        int err, all_zero;
 
688
        unsigned long blksize;
 
689
@@ -265,10 +265,9 @@ int au_copy_file(struct file *dst, struc
 
690
                } while (err == -EAGAIN || err == -EINTR);
 
691
                if (err == 1) {
 
692
                        ia->ia_size = dst->f_pos;
 
693
-                       ia->ia_valid = ATTR_SIZE | ATTR_FILE;
 
694
-                       ia->ia_file = dst;
 
695
+                       ia->ia_valid = ATTR_SIZE;
 
696
                        vfsub_i_lock_nested(h_i, AuLsc_I_CHILD2);
 
697
-                       err = vfsub_notify_change(h_d, ia, &vargs);
 
698
+                       err = vfsub_notify_change(h_d, dst_mnt, ia, &vargs);
 
699
                        vfsub_i_unlock(h_i);
 
700
                }
 
701
        }
 
702
Index: fs/aufs/misc.h
 
703
===================================================================
 
704
RCS file: /cvsroot/aufs/aufs/fs/aufs/misc.h,v
 
705
retrieving revision 1.39
 
706
diff -u -p -r1.39 misc.h
 
707
--- fs/aufs/misc.h      21 Jan 2008 04:57:48 -0000      1.39
 
708
+++ fs/aufs/misc.h      29 Jan 2008 14:42:08 -0000
 
709
@@ -201,7 +201,7 @@ int au_h_create(struct inode *h_dir, str
 
710
                int dlgt, struct nameidata *nd, struct vfsmount *nfsmnt);
 
711
 
 
712
 int au_copy_file(struct file *dst, struct file *src, loff_t len,
 
713
-                struct super_block *sb);
 
714
+                struct super_block *sb, struct vfsmount *dst_mnt);
 
715
 int au_test_ro(struct super_block *sb, aufs_bindex_t bindex,
 
716
               struct inode *inode);
 
717
 int au_test_perm(struct inode *h_inode, int mask, int dlgt);
 
718
Index: fs/aufs/plink.c
 
719
===================================================================
 
720
RCS file: /cvsroot/aufs/aufs/fs/aufs/plink.c,v
 
721
retrieving revision 1.16
 
722
diff -u -p -r1.16 plink.c
 
723
--- fs/aufs/plink.c     29 Oct 2007 04:41:10 -0000      1.16
 
724
+++ fs/aufs/plink.c     29 Jan 2008 14:42:08 -0000
 
725
@@ -119,8 +119,8 @@ struct dentry *au_lkup_plink(struct supe
 
726
 }
 
727
 
 
728
 static int do_whplink(char *tgt, int len, struct dentry *h_parent,
 
729
-                     struct dentry *h_dentry, struct vfsmount *nfsmnt,
 
730
-                     struct super_block *sb)
 
731
+                     struct dentry *h_dentry, struct vfsmount *h_mnt,
 
732
+                     struct vfsmount *nfsmnt, struct super_block *sb)
 
733
 {
 
734
        int err;
 
735
        struct dentry *h_tgt;
 
736
@@ -142,9 +142,9 @@ static int do_whplink(char *tgt, int len
 
737
        vfsub_args_init(&vargs, NULL, ndx.dlgt, 0);
 
738
        h_dir = h_parent->d_inode;
 
739
        if (unlikely(h_tgt->d_inode && h_tgt->d_inode != h_dentry->d_inode))
 
740
-               err = vfsub_unlink(h_dir, h_tgt, &vargs);
 
741
+               err = vfsub_unlink(h_dir, h_tgt, h_mnt, &vargs);
 
742
        if (!err && !h_tgt->d_inode) {
 
743
-               err = vfsub_link(h_dentry, h_dir, h_tgt, ndx.dlgt);
 
744
+               err = vfsub_link(h_dentry, h_mnt, h_dir, h_tgt, h_mnt, ndx.dlgt);
 
745
                //inode->i_nlink++;
 
746
        }
 
747
        dput(h_tgt);
 
748
@@ -160,6 +160,7 @@ struct do_whplink_args {
 
749
        int len;
 
750
        struct dentry *h_parent;
 
751
        struct dentry *h_dentry;
 
752
+       struct vfsmount *h_mnt;
 
753
        struct vfsmount *nfsmnt;
 
754
        struct super_block *sb;
 
755
 };
 
756
@@ -168,7 +169,7 @@ static void call_do_whplink(void *args)
 
757
 {
 
758
        struct do_whplink_args *a = args;
 
759
        *a->errp = do_whplink(a->tgt, a->len, a->h_parent, a->h_dentry,
 
760
-                             a->nfsmnt, a->sb);
 
761
+                             a->h_mnt, a->nfsmnt, a->sb);
 
762
 }
 
763
 
 
764
 static int whplink(struct dentry *h_dentry, struct inode *inode,
 
765
@@ -198,6 +199,7 @@ static int whplink(struct dentry *h_dent
 
766
                        .len            = len,
 
767
                        .h_parent       = h_parent,
 
768
                        .h_dentry       = h_dentry,
 
769
+                       .h_mnt          = br->br_mnt,
 
770
                        .nfsmnt         = au_do_nfsmnt(br->br_mnt),
 
771
                        .sb             = sb
 
772
                };
 
773
@@ -206,7 +208,7 @@ static int whplink(struct dentry *h_dent
 
774
                        err = wkq_err;
 
775
        } else
 
776
                err = do_whplink(tgtname, len, h_parent, h_dentry,
 
777
-                                au_do_nfsmnt(br->br_mnt), sb);
 
778
+                                br->br_mnt, au_do_nfsmnt(br->br_mnt), sb);
 
779
        vfsub_i_unlock(h_dir);
 
780
 
 
781
        AuTraceErr(err);
 
782
Index: fs/aufs/vfsub.c
 
783
===================================================================
 
784
RCS file: /cvsroot/aufs/aufs/fs/aufs/vfsub.c,v
 
785
retrieving revision 1.26
 
786
diff -u -p -r1.26 vfsub.c
 
787
--- fs/aufs/vfsub.c     28 Jan 2008 05:01:42 -0000      1.26
 
788
+++ fs/aufs/vfsub.c     29 Jan 2008 14:42:08 -0000
 
789
@@ -369,6 +369,7 @@ struct symlink_args {
 
790
        int *errp;
 
791
        struct inode *dir;
 
792
        struct dentry *dentry;
 
793
+       struct vfsmount *mnt;
 
794
        const char *symname;
 
795
        int mode;
 
796
 };
 
797
@@ -376,20 +377,22 @@ struct symlink_args {
 
798
 static void call_symlink(void *args)
 
799
 {
 
800
        struct symlink_args *a = args;
 
801
-       *a->errp = do_vfsub_symlink(a->dir, a->dentry, a->symname, a->mode);
 
802
+       *a->errp = do_vfsub_symlink(a->dir, a->dentry, a->mnt, a->symname,
 
803
+                                   a->mode);
 
804
 }
 
805
 
 
806
-int vfsub_symlink(struct inode *dir, struct dentry *dentry, const char *symname,
 
807
-                 int mode, int dlgt)
 
808
+int vfsub_symlink(struct inode *dir, struct dentry *dentry,
 
809
+                 struct vfsmount *mnt, const char *symname, int mode, int dlgt)
 
810
 {
 
811
        if (!dlgt)
 
812
-               return do_vfsub_symlink(dir, dentry, symname, mode);
 
813
+               return do_vfsub_symlink(dir, dentry, mnt, symname, mode);
 
814
        else {
 
815
                int err, wkq_err;
 
816
                struct symlink_args args = {
 
817
                        .errp           = &err,
 
818
                        .dir            = dir,
 
819
                        .dentry         = dentry,
 
820
+                       .mnt            = mnt,
 
821
                        .symname        = symname,
 
822
                        .mode           = mode
 
823
                };
 
824
@@ -404,6 +407,7 @@ struct mknod_args {
 
825
        int *errp;
 
826
        struct inode *dir;
 
827
        struct dentry *dentry;
 
828
+       struct vfsmount *mnt;
 
829
        int mode;
 
830
        dev_t dev;
 
831
 };
 
832
@@ -411,20 +415,21 @@ struct mknod_args {
 
833
 static void call_mknod(void *args)
 
834
 {
 
835
        struct mknod_args *a = args;
 
836
-       *a->errp = do_vfsub_mknod(a->dir, a->dentry, a->mode, a->dev);
 
837
+       *a->errp = do_vfsub_mknod(a->dir, a->dentry, a->mnt, a->mode, a->dev);
 
838
 }
 
839
 
 
840
-int vfsub_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev,
 
841
-               int dlgt)
 
842
+int vfsub_mknod(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,
 
843
+               int mode, dev_t dev, int dlgt)
 
844
 {
 
845
        if (!dlgt)
 
846
-               return do_vfsub_mknod(dir, dentry, mode, dev);
 
847
+               return do_vfsub_mknod(dir, dentry, mnt, mode, dev);
 
848
        else {
 
849
                int err, wkq_err;
 
850
                struct mknod_args args = {
 
851
                        .errp   = &err,
 
852
                        .dir    = dir,
 
853
                        .dentry = dentry,
 
854
+                       .mnt    = mnt,
 
855
                        .mode   = mode,
 
856
                        .dev    = dev
 
857
                };
 
858
@@ -439,25 +444,28 @@ struct mkdir_args {
 
859
        int *errp;
 
860
        struct inode *dir;
 
861
        struct dentry *dentry;
 
862
+       struct vfsmount *mnt;
 
863
        int mode;
 
864
 };
 
865
 
 
866
 static void call_mkdir(void *args)
 
867
 {
 
868
        struct mkdir_args *a = args;
 
869
-       *a->errp = do_vfsub_mkdir(a->dir, a->dentry, a->mode);
 
870
+       *a->errp = do_vfsub_mkdir(a->dir, a->dentry, a->mnt, a->mode);
 
871
 }
 
872
 
 
873
-int vfsub_mkdir(struct inode *dir, struct dentry *dentry, int mode, int dlgt)
 
874
+int vfsub_mkdir(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,
 
875
+               int mode, int dlgt)
 
876
 {
 
877
        if (!dlgt)
 
878
-               return do_vfsub_mkdir(dir, dentry, mode);
 
879
+               return do_vfsub_mkdir(dir, dentry, mnt, mode);
 
880
        else {
 
881
                int err, wkq_err;
 
882
                struct mkdir_args args = {
 
883
                        .errp   = &err,
 
884
                        .dir    = dir,
 
885
                        .dentry = dentry,
 
886
+                       .mnt    = mnt,
 
887
                        .mode   = mode
 
888
                };
 
889
                wkq_err = au_wkq_wait(call_mkdir, &args, /*dlgt*/1);
 
890
@@ -473,6 +481,7 @@ struct link_args {
 
891
        int *errp;
 
892
        struct inode *dir;
 
893
        struct dentry *src_dentry, *dentry;
 
894
+       struct vfsmount *src_mnt, *mnt;
 
895
 };
 
896
 
 
897
 static void call_link(void *args)
 
898
@@ -481,18 +490,21 @@ static void call_link(void *args)
 
899
        *a->errp = do_vfsub_link(a->src_dentry, a->dir, a->dentry);
 
900
 }
 
901
 
 
902
-int vfsub_link(struct dentry *src_dentry, struct inode *dir,
 
903
-              struct dentry *dentry, int dlgt)
 
904
+int vfsub_link(struct dentry *src_dentry, struct vfsmount *src_mnt,
 
905
+              struct inode *dir, struct dentry *dentry,
 
906
+              struct vfsmount *mnt, int dlgt)
 
907
 {
 
908
        if (!dlgt)
 
909
-               return do_vfsub_link(src_dentry, dir, dentry);
 
910
+               return do_vfsub_link(src_dentry, src_mnt, dir, dentry, mnt);
 
911
        else {
 
912
                int err, wkq_err;
 
913
                struct link_args args = {
 
914
                        .errp           = &err,
 
915
                        .src_dentry     = src_dentry,
 
916
+                       .src_mnt        = src_mnt,
 
917
                        .dir            = dir,
 
918
-                       .dentry         = dentry
 
919
+                       .dentry         = dentry,
 
920
+                       .mnt            = mnt
 
921
                };
 
922
                wkq_err = au_wkq_wait(call_link, &args, /*dlgt*/1);
 
923
                if (unlikely(wkq_err))
 
924
@@ -505,6 +517,7 @@ struct rename_args {
 
925
        int *errp;
 
926
        struct inode *src_dir, *dir;
 
927
        struct dentry *src_dentry, *dentry;
 
928
+       struct vfsmount *src_mnt, *mnt;
 
929
        struct vfsub_args *vargs;
 
930
 };
 
931
 
 
932
@@ -512,21 +525,23 @@ static void call_rename(void *args)
 
933
 {
 
934
        struct rename_args *a = args;
 
935
        vfsub_ignore(a->vargs);
 
936
-       *a->errp = do_vfsub_rename(a->src_dir, a->src_dentry, a->dir,
 
937
-                                  a->dentry);
 
938
+       *a->errp = do_vfsub_rename(a->src_dir, a->src_dentry, a->src_mnt,
 
939
+                                  a->dir, a->dentry, a->mnt);
 
940
        if (unlikely(*a->errp))
 
941
                vfsub_unignore(a->vargs);
 
942
 }
 
943
 
 
944
 int vfsub_rename(struct inode *src_dir, struct dentry *src_dentry,
 
945
-                struct inode *dir, struct dentry *dentry,
 
946
+                struct vfsmount *src_mnt,
 
947
+                struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,
 
948
                 struct vfsub_args *vargs)
 
949
 {
 
950
        int err;
 
951
 
 
952
        if (!vargs->dlgt) {
 
953
                vfsub_ignore(vargs);
 
954
-               err = do_vfsub_rename(src_dir, src_dentry, dir, dentry);
 
955
+               err = do_vfsub_rename(src_dir, src_dentry, src_mnt, dir, dentry,
 
956
+                                     mnt);
 
957
                if (unlikely(err))
 
958
                        vfsub_unignore(vargs);
 
959
        } else {
 
960
@@ -535,8 +550,10 @@ int vfsub_rename(struct inode *src_dir, 
 
961
                        .errp           = &err,
 
962
                        .src_dir        = src_dir,
 
963
                        .src_dentry     = src_dentry,
 
964
+                       .src_mnt        = src_mnt,
 
965
                        .dir            = dir,
 
966
                        .dentry         = dentry,
 
967
+                       .mnt            = mnt,
 
968
                        .vargs          = vargs
 
969
                };
 
970
                wkq_err = au_wkq_wait(call_rename, &args, /*dlgt*/1);
 
971
@@ -550,6 +567,7 @@ struct rmdir_args {
 
972
        int *errp;
 
973
        struct inode *dir;
 
974
        struct dentry *dentry;
 
975
+       struct vfsmount *mnt;
 
976
        struct vfsub_args *vargs;
 
977
 };
 
978
 
 
979
@@ -557,19 +575,19 @@ static void call_rmdir(void *args)
 
980
 {
 
981
        struct rmdir_args *a = args;
 
982
        vfsub_ignore(a->vargs);
 
983
-       *a->errp = do_vfsub_rmdir(a->dir, a->dentry);
 
984
+       *a->errp = do_vfsub_rmdir(a->dir, a->dentry, a->mnt);
 
985
        if (unlikely(*a->errp))
 
986
                vfsub_unignore(a->vargs);
 
987
 }
 
988
 
 
989
-int vfsub_rmdir(struct inode *dir, struct dentry *dentry,
 
990
+int vfsub_rmdir(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,
 
991
                struct vfsub_args *vargs)
 
992
 {
 
993
        int err;
 
994
 
 
995
        if (!vargs->dlgt) {
 
996
                vfsub_ignore(vargs);
 
997
-               err = do_vfsub_rmdir(dir, dentry);
 
998
+               err = do_vfsub_rmdir(dir, dentry, mnt);
 
999
                if (unlikely(err))
 
1000
                        vfsub_unignore(vargs);
 
1001
        } else {
 
1002
@@ -578,6 +596,7 @@ int vfsub_rmdir(struct inode *dir, struc
 
1003
                        .errp   = &err,
 
1004
                        .dir    = dir,
 
1005
                        .dentry = dentry,
 
1006
+                       .mnt    = mnt,
 
1007
                        .vargs  = vargs
 
1008
                };
 
1009
                wkq_err = au_wkq_wait(call_rmdir, &args, /*dlgt*/1);
 
1010
@@ -975,6 +994,7 @@ struct au_vfsub_mkdir_args {
 
1011
        int *errp;
 
1012
        struct inode *dir;
 
1013
        struct dentry *dentry;
 
1014
+       struct vfsmount *mnt;
 
1015
        int mode;
 
1016
        int dlgt;
 
1017
 };
 
1018
@@ -982,11 +1002,11 @@ struct au_vfsub_mkdir_args {
 
1019
 static void au_call_vfsub_mkdir(void *args)
 
1020
 {
 
1021
        struct au_vfsub_mkdir_args *a = args;
 
1022
-       *a->errp = vfsub_mkdir(a->dir, a->dentry, a->mode, a->dlgt);
 
1023
+       *a->errp = vfsub_mkdir(a->dir, a->dentry, a->mnt, a->mode, a->dlgt);
 
1024
 }
 
1025
 
 
1026
-int vfsub_sio_mkdir(struct inode *dir, struct dentry *dentry, int mode,
 
1027
-                   int dlgt)
 
1028
+int vfsub_sio_mkdir(struct inode *dir, struct dentry *dentry,
 
1029
+                   struct vfsmount *mnt, int mode, int dlgt)
 
1030
 {
 
1031
        int err, do_sio, wkq_err;
 
1032
 
 
1033
@@ -994,12 +1014,13 @@ int vfsub_sio_mkdir(struct inode *dir, s
 
1034
 
 
1035
        do_sio = au_test_perm(dir, MAY_EXEC | MAY_WRITE, dlgt);
 
1036
        if (!do_sio)
 
1037
-               err = vfsub_mkdir(dir, dentry, mode, dlgt);
 
1038
+               err = vfsub_mkdir(dir, dentry, mnt, mode, dlgt);
 
1039
        else {
 
1040
                struct au_vfsub_mkdir_args args = {
 
1041
                        .errp   = &err,
 
1042
                        .dir    = dir,
 
1043
                        .dentry = dentry,
 
1044
+                       .mnt    = mnt,
 
1045
                        .mode   = mode,
 
1046
                        .dlgt   = dlgt
 
1047
                };
 
1048
@@ -1016,16 +1037,18 @@ struct au_vfsub_rmdir_args {
 
1049
        int *errp;
 
1050
        struct inode *dir;
 
1051
        struct dentry *dentry;
 
1052
+       struct vfsmount *mnt;
 
1053
        struct vfsub_args *vargs;
 
1054
 };
 
1055
 
 
1056
 static void au_call_vfsub_rmdir(void *args)
 
1057
 {
 
1058
        struct au_vfsub_rmdir_args *a = args;
 
1059
-       *a->errp = vfsub_rmdir(a->dir, a->dentry, a->vargs);
 
1060
+       *a->errp = vfsub_rmdir(a->dir, a->dentry, a->mnt, a->vargs);
 
1061
 }
 
1062
 
 
1063
-int vfsub_sio_rmdir(struct inode *dir, struct dentry *dentry, int dlgt)
 
1064
+int vfsub_sio_rmdir(struct inode *dir, struct dentry *dentry,
 
1065
+                   struct vfsmount *mnt, int dlgt)
 
1066
 {
 
1067
        int err, do_sio, wkq_err;
 
1068
        struct vfsub_args vargs;
 
1069
@@ -1035,12 +1058,13 @@ int vfsub_sio_rmdir(struct inode *dir, s
 
1070
        vfsub_args_init(&vargs, /*ign*/NULL, dlgt, /*force_unlink*/0);
 
1071
        do_sio = au_test_perm(dir, MAY_EXEC | MAY_WRITE, dlgt);
 
1072
        if (!do_sio)
 
1073
-               err = vfsub_rmdir(dir, dentry, &vargs);
 
1074
+               err = vfsub_rmdir(dir, dentry, mnt, &vargs);
 
1075
        else {
 
1076
                struct au_vfsub_rmdir_args args = {
 
1077
                        .errp           = &err,
 
1078
                        .dir            = dir,
 
1079
                        .dentry         = dentry,
 
1080
+                       .mnt            = mnt,
 
1081
                        .vargs          = &vargs
 
1082
                };
 
1083
                wkq_err = au_wkq_wait(au_call_vfsub_rmdir, &args, /*dlgt*/0);
 
1084
@@ -1057,6 +1081,7 @@ int vfsub_sio_rmdir(struct inode *dir, s
 
1085
 struct notify_change_args {
 
1086
        int *errp;
 
1087
        struct dentry *h_dentry;
 
1088
+       struct vfsmount *h_mnt;
 
1089
        struct iattr *ia;
 
1090
        struct vfsub_args *vargs;
 
1091
 };
 
1092
@@ -1075,7 +1100,7 @@ static void call_notify_change(void *arg
 
1093
        if (!IS_IMMUTABLE(h_inode) && !IS_APPEND(h_inode)) {
 
1094
                vfsub_ignore(a->vargs);
 
1095
                lockdep_off();
 
1096
-               *a->errp = notify_change(a->h_dentry, a->ia);
 
1097
+               *a->errp = notify_change(a->h_dentry, a->h_mnt, a->ia);
 
1098
                lockdep_on();
 
1099
                if (!*a->errp)
 
1100
                        au_update_fuse_h_inode(NULL, a->h_dentry); /*ignore*/
 
1101
@@ -1085,13 +1110,14 @@ static void call_notify_change(void *arg
 
1102
        AuTraceErr(*a->errp);
 
1103
 }
 
1104
 
 
1105
-int vfsub_notify_change(struct dentry *dentry, struct iattr *ia,
 
1106
-                       struct vfsub_args *vargs)
 
1107
+int vfsub_notify_change(struct dentry *dentry, struct vfsmount *mnt,
 
1108
+                       struct iattr *ia, struct vfsub_args *vargs)
 
1109
 {
 
1110
        int err;
 
1111
        struct notify_change_args args = {
 
1112
                .errp           = &err,
 
1113
                .h_dentry       = dentry,
 
1114
+               .h_mnt          = mnt,
 
1115
                .ia             = ia,
 
1116
                .vargs          = vargs
 
1117
        };
 
1118
@@ -1119,6 +1145,7 @@ struct unlink_args {
 
1119
        int *errp;
 
1120
        struct inode *dir;
 
1121
        struct dentry *dentry;
 
1122
+       struct vfsmount *mnt;
 
1123
        struct vfsub_args *vargs;
 
1124
 };
 
1125
 
 
1126
@@ -1149,7 +1176,7 @@ static void call_unlink(void *args)
 
1127
                        err = -1;
 
1128
        }
 
1129
 #else
 
1130
-       *a->errp = do_vfsub_unlink(a->dir, a->dentry);
 
1131
+       *a->errp = do_vfsub_unlink(a->dir, a->dentry, a->mnt);
 
1132
 #endif
 
1133
 
 
1134
        if (!stop_sillyrename)
 
1135
@@ -1164,7 +1191,7 @@ static void call_unlink(void *args)
 
1136
  * @dir: must be locked.
 
1137
  * @dentry: target dentry.
 
1138
  */
 
1139
-int vfsub_unlink(struct inode *dir, struct dentry *dentry,
 
1140
+int vfsub_unlink(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,
 
1141
                 struct vfsub_args *vargs)
 
1142
 {
 
1143
        int err;
 
1144
@@ -1172,6 +1199,7 @@ int vfsub_unlink(struct inode *dir, stru
 
1145
                .errp   = &err,
 
1146
                .dir    = dir,
 
1147
                .dentry = dentry,
 
1148
+               .mnt    = mnt,
 
1149
                .vargs  = vargs
 
1150
        };
 
1151
 
 
1152
Index: fs/aufs/vfsub.h
 
1153
===================================================================
 
1154
RCS file: /cvsroot/aufs/aufs/fs/aufs/vfsub.h,v
 
1155
retrieving revision 1.28
 
1156
diff -u -p -r1.28 vfsub.h
 
1157
--- fs/aufs/vfsub.h     28 Jan 2008 05:01:42 -0000      1.28
 
1158
+++ fs/aufs/vfsub.h     29 Jan 2008 14:42:08 -0000
 
1159
@@ -368,7 +368,7 @@ int do_vfsub_create(struct inode *dir, s
 
1160
 
 
1161
 static inline
 
1162
 int do_vfsub_symlink(struct inode *dir, struct dentry *dentry,
 
1163
-                    const char *symname, int mode)
 
1164
+                    struct vfsmount *mnt, const char *symname, int mode)
 
1165
 {
 
1166
        int err;
 
1167
 
 
1168
@@ -376,7 +376,7 @@ int do_vfsub_symlink(struct inode *dir, 
 
1169
                  dir->i_ino, AuDLNPair(dentry), symname, mode);
 
1170
        IMustLock(dir);
 
1171
 
 
1172
-       err = vfs_symlink(dir, dentry, symname, mode);
 
1173
+       err = vfs_symlink(dir, dentry, mnt, symname, mode);
 
1174
        if (!err) {
 
1175
                /* dir inode is locked */
 
1176
                au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/
 
1177
@@ -386,15 +386,15 @@ int do_vfsub_symlink(struct inode *dir, 
 
1178
 }
 
1179
 
 
1180
 static inline
 
1181
-int do_vfsub_mknod(struct inode *dir, struct dentry *dentry, int mode,
 
1182
-                  dev_t dev)
 
1183
+int do_vfsub_mknod(struct inode *dir, struct dentry *dentry,
 
1184
+                  struct vfsmount *mnt, int mode, dev_t dev)
 
1185
 {
 
1186
        int err;
 
1187
 
 
1188
        LKTRTrace("i%lu, %.*s, 0x%x\n", dir->i_ino, AuDLNPair(dentry), mode);
 
1189
        IMustLock(dir);
 
1190
 
 
1191
-       err = vfs_mknod(dir, dentry, mode, dev);
 
1192
+       err = vfs_mknod(dir, dentry, mnt, mode, dev);
 
1193
        if (!err) {
 
1194
                /* dir inode is locked */
 
1195
                au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/
 
1196
@@ -404,8 +404,9 @@ int do_vfsub_mknod(struct inode *dir, st
 
1197
 }
 
1198
 
 
1199
 static inline
 
1200
-int do_vfsub_link(struct dentry *src_dentry, struct inode *dir,
 
1201
-                 struct dentry *dentry)
 
1202
+int do_vfsub_link(struct dentry *src_dentry, struct vfsmount *src_mnt,
 
1203
+                 struct inode *dir, struct dentry *dentry,
 
1204
+                 struct vfsmount *mnt)
 
1205
 {
 
1206
        int err;
 
1207
 
 
1208
@@ -414,7 +415,7 @@ int do_vfsub_link(struct dentry *src_den
 
1209
        IMustLock(dir);
 
1210
 
 
1211
        lockdep_off();
 
1212
-       err = vfs_link(src_dentry, dir, dentry);
 
1213
+       err = vfs_link(src_dentry, src_mnt, dir, dentry, mnt);
 
1214
        lockdep_on();
 
1215
        if (!err) {
 
1216
                LKTRTrace("src_i %p, dst_i %p\n",
 
1217
@@ -430,7 +431,9 @@ int do_vfsub_link(struct dentry *src_den
 
1218
 
 
1219
 static inline
 
1220
 int do_vfsub_rename(struct inode *src_dir, struct dentry *src_dentry,
 
1221
-                   struct inode *dir, struct dentry *dentry)
 
1222
+                   struct vfsmount *src_mnt,
 
1223
+                   struct inode *dir, struct dentry *dentry,
 
1224
+                   struct vfsmount *mnt)
 
1225
 {
 
1226
        int err;
 
1227
 
 
1228
@@ -441,7 +444,7 @@ int do_vfsub_rename(struct inode *src_di
 
1229
        IMustLock(src_dir);
 
1230
 
 
1231
        lockdep_off();
 
1232
-       err = vfs_rename(src_dir, src_dentry, dir, dentry);
 
1233
+       err = vfs_rename(src_dir, src_dentry, src_mnt, dir, dentry, mnt);
 
1234
        lockdep_on();
 
1235
        if (!err) {
 
1236
                /* dir inode is locked */
 
1237
@@ -453,14 +456,15 @@ int do_vfsub_rename(struct inode *src_di
 
1238
 }
 
1239
 
 
1240
 static inline
 
1241
-int do_vfsub_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 
1242
+int do_vfsub_mkdir(struct inode *dir, struct dentry *dentry,
 
1243
+                  struct vfsmount *mnt, int mode)
 
1244
 {
 
1245
        int err;
 
1246
 
 
1247
        LKTRTrace("i%lu, %.*s, 0x%x\n", dir->i_ino, AuDLNPair(dentry), mode);
 
1248
        IMustLock(dir);
 
1249
 
 
1250
-       err = vfs_mkdir(dir, dentry, mode);
 
1251
+       err = vfs_mkdir(dir, dentry, mnt, mode);
 
1252
        if (!err) {
 
1253
                /* dir inode is locked */
 
1254
                au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/
 
1255
@@ -469,7 +473,8 @@ int do_vfsub_mkdir(struct inode *dir, st
 
1256
        return err;
 
1257
 }
 
1258
 
 
1259
-static inline int do_vfsub_rmdir(struct inode *dir, struct dentry *dentry)
 
1260
+static inline int do_vfsub_rmdir(struct inode *dir, struct dentry *dentry,
 
1261
+                                struct vfsmount *mnt)
 
1262
 {
 
1263
        int err;
 
1264
 
 
1265
@@ -477,7 +482,7 @@ static inline int do_vfsub_rmdir(struct 
 
1266
        IMustLock(dir);
 
1267
 
 
1268
        lockdep_off();
 
1269
-       err = vfs_rmdir(dir, dentry);
 
1270
+       err = vfs_rmdir(dir, dentry, mnt);
 
1271
        lockdep_on();
 
1272
        /* dir inode is locked */
 
1273
        if (!err)
 
1274
@@ -485,7 +490,8 @@ static inline int do_vfsub_rmdir(struct 
 
1275
        return err;
 
1276
 }
 
1277
 
 
1278
-static inline int do_vfsub_unlink(struct inode *dir, struct dentry *dentry)
 
1279
+static inline int do_vfsub_unlink(struct inode *dir, struct dentry *dentry,
 
1280
+                                 struct vfsmount *mnt)
 
1281
 {
 
1282
        int err;
 
1283
 
 
1284
@@ -494,7 +500,7 @@ static inline int do_vfsub_unlink(struct
 
1285
 
 
1286
        /* vfs_unlink() locks inode */
 
1287
        lockdep_off();
 
1288
-       err = vfs_unlink(dir, dentry);
 
1289
+       err = vfs_unlink(dir, dentry, mnt);
 
1290
        lockdep_on();
 
1291
        /* dir inode is locked */
 
1292
        if (!err)
 
1293
@@ -721,54 +727,57 @@ int vfsub_create(struct inode *dir, stru
 
1294
 }
 
1295
 
 
1296
 static inline
 
1297
-int vfsub_symlink(struct inode *dir, struct dentry *dentry, const char *symname,
 
1298
-                 int mode, int dlgt)
 
1299
+int vfsub_symlink(struct inode *dir, struct dentry *dentry,
 
1300
+                 struct vfsmount *mnt, const char *symname, int mode, int dlgt)
 
1301
 {
 
1302
-       return do_vfsub_symlink(dir, dentry, symname, mode);
 
1303
+       return do_vfsub_symlink(dir, dentry, mnt, symname, mode);
 
1304
 }
 
1305
 
 
1306
 static inline
 
1307
-int vfsub_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev,
 
1308
-               int dlgt)
 
1309
+int vfsub_mknod(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,
 
1310
+               int mode, dev_t dev, int dlgt)
 
1311
 {
 
1312
-       return do_vfsub_mknod(dir, dentry, mode, dev);
 
1313
+       return do_vfsub_mknod(dir, dentry, mnt, mode, dev);
 
1314
 }
 
1315
 
 
1316
 static inline
 
1317
-int vfsub_link(struct dentry *src_dentry, struct inode *dir,
 
1318
-              struct dentry *dentry, int dlgt)
 
1319
+int vfsub_link(struct dentry *src_dentry, struct vfsmount *src_mnt,
 
1320
+              struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,
 
1321
+              int dlgt)
 
1322
 {
 
1323
-       return do_vfsub_link(src_dentry, dir, dentry);
 
1324
+       return do_vfsub_link(src_dentry, src_mnt, dir, dentry, mnt);
 
1325
 }
 
1326
 
 
1327
 static inline
 
1328
 int vfsub_rename(struct inode *src_dir, struct dentry *src_dentry,
 
1329
-                struct inode *dir, struct dentry *dentry,
 
1330
+                struct vfsmount *src_mnt,
 
1331
+                struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,
 
1332
                 struct vfsub_args *vargs)
 
1333
 {
 
1334
        int err;
 
1335
 
 
1336
        vfsub_ignore(vargs);
 
1337
-       err = do_vfsub_rename(src_dir, src_dentry, dir, dentry);
 
1338
+       err = do_vfsub_rename(src_dir, src_dentry, src_mnt, dir, dentry, mnt);
 
1339
        if (unlikely(err))
 
1340
                vfsub_unignore(vargs);
 
1341
        return err;
 
1342
 }
 
1343
 
 
1344
 static inline
 
1345
-int vfsub_mkdir(struct inode *dir, struct dentry *dentry, int mode, int dlgt)
 
1346
+int vfsub_mkdir(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,
 
1347
+               int mode, int dlgt)
 
1348
 {
 
1349
-       return do_vfsub_mkdir(dir, dentry, mode);
 
1350
+       return do_vfsub_mkdir(dir, dentry, mnt, mode);
 
1351
 }
 
1352
 
 
1353
 static inline
 
1354
-int vfsub_rmdir(struct inode *dir, struct dentry *dentry,
 
1355
+int vfsub_rmdir(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,
 
1356
                struct vfsub_args *vargs)
 
1357
 {
 
1358
        int err;
 
1359
 
 
1360
        vfsub_ignore(vargs);
 
1361
-       err = do_vfsub_rmdir(dir, dentry);
 
1362
+       err = do_vfsub_rmdir(dir, dentry, mnt);
 
1363
        if (unlikely(err))
 
1364
                vfsub_unignore(vargs);
 
1365
        return err;
 
1366
@@ -851,15 +860,16 @@ static inline int vfsub_getattr(struct v
 
1367
 
 
1368
 /* ---------------------------------------------------------------------- */
 
1369
 
 
1370
-int vfsub_sio_mkdir(struct inode *dir, struct dentry *dentry, int mode,
 
1371
-                   int dlgt);
 
1372
-int vfsub_sio_rmdir(struct inode *dir, struct dentry *dentry, int dlgt);
 
1373
+int vfsub_sio_mkdir(struct inode *dir, struct dentry *dentry,
 
1374
+                   struct vfsmount *mnt, int mode, int dlgt);
 
1375
+int vfsub_sio_rmdir(struct inode *dir, struct dentry *dentry,
 
1376
+                   struct vfsmount *mnt, int dlgt);
 
1377
 
 
1378
 /* ---------------------------------------------------------------------- */
 
1379
 
 
1380
-int vfsub_notify_change(struct dentry *dentry, struct iattr *ia,
 
1381
-                       struct vfsub_args *vargs);
 
1382
-int vfsub_unlink(struct inode *dir, struct dentry *dentry,
 
1383
+int vfsub_notify_change(struct dentry *dentry, struct vfsmount *mnt,
 
1384
+                       struct iattr *ia, struct vfsub_args *vargs);
 
1385
+int vfsub_unlink(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,
 
1386
                 struct vfsub_args *vargs);
 
1387
 int vfsub_statfs(void *arg, struct kstatfs *buf, int dlgt);
 
1388
 
 
1389
Index: fs/aufs/wbr_policy.c
 
1390
===================================================================
 
1391
RCS file: /cvsroot/aufs/aufs/fs/aufs/wbr_policy.c,v
 
1392
retrieving revision 1.5
 
1393
diff -u -p -r1.5 wbr_policy.c
 
1394
--- fs/aufs/wbr_policy.c        26 Nov 2007 01:34:50 -0000      1.5
 
1395
+++ fs/aufs/wbr_policy.c        29 Jan 2008 14:42:08 -0000
 
1396
@@ -21,7 +21,8 @@
 
1397
 #include <linux/statfs.h>
 
1398
 #include "aufs.h"
 
1399
 
 
1400
-static int au_cpdown_attr(struct dentry *h_dst, struct dentry *h_src, int dlgt)
 
1401
+static int au_cpdown_attr(struct dentry *h_dst, struct dentry *h_src,
 
1402
+                         struct vfsmount *h_dst_mnt, int dlgt)
 
1403
 {
 
1404
        int err, sbits;
 
1405
        struct iattr ia;
 
1406
@@ -41,14 +42,14 @@ static int au_cpdown_attr(struct dentry 
 
1407
        sbits = !!(ia.ia_mode & (S_ISUID | S_ISGID));
 
1408
 
 
1409
        vfsub_args_init(&vargs, NULL, dlgt, /*force_unlink*/0);
 
1410
-       err = vfsub_notify_change(h_dst, &ia, &vargs);
 
1411
+       err = vfsub_notify_change(h_dst, h_dst_mnt, &ia, &vargs);
 
1412
 
 
1413
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
 
1414
        /* is this nfs only? */
 
1415
        if (!err && sbits && au_test_nfs(h_dst->d_sb)) {
 
1416
                ia.ia_valid = ATTR_FORCE | ATTR_MODE;
 
1417
                ia.ia_mode = h_isrc->i_mode;
 
1418
-               err = vfsub_notify_change(h_dst, &ia, &vargs);
 
1419
+               err = vfsub_notify_change(h_dst, h_dst_mnt, &ia, &vargs);
 
1420
        }
 
1421
 #endif
 
1422
        if (!err)
 
1423
@@ -71,6 +72,7 @@ static int au_cpdown_dir(struct dentry *
 
1424
        aufs_bindex_t bend, bopq;
 
1425
        struct dentry *h_dentry, *opq_dentry, *wh_dentry;
 
1426
        struct inode *h_dir, *h_inode, *inode;
 
1427
+       struct vfsmount *h_mnt;
 
1428
 
 
1429
        LKTRTrace("%.*s, b%d\n", AuDLNPair(dentry), bdst);
 
1430
        AuDebugOn(dbstart(dentry) <= bdst
 
1431
@@ -84,9 +86,10 @@ static int au_cpdown_dir(struct dentry *
 
1432
        err = au_lkup_neg(dentry, bdst);
 
1433
        if (unlikely(err < 0))
 
1434
                goto out;
 
1435
+       h_mnt = sbr_mnt(dentry->d_sb, bdst);
 
1436
        h_dentry = au_h_dptr_i(dentry, bdst);
 
1437
        dlgt = au_need_dlgt(dentry->d_sb);
 
1438
-       err = vfsub_sio_mkdir(h_dir, h_dentry, 0755, dlgt);
 
1439
+       err = vfsub_sio_mkdir(h_dir, h_dentry, h_mnt, 0755, dlgt);
 
1440
        if (unlikely(err))
 
1441
                goto out_put;
 
1442
 
 
1443
@@ -112,7 +115,7 @@ static int au_cpdown_dir(struct dentry *
 
1444
                diropq = 1;
 
1445
        }
 
1446
 
 
1447
-       err = au_cpdown_attr(h_dentry, au_h_dptr(dentry), dlgt);
 
1448
+       err = au_cpdown_attr(h_dentry, au_h_dptr(dentry), h_mnt, dlgt);
 
1449
        vfsub_i_unlock(h_inode);
 
1450
        if (unlikely(err))
 
1451
                goto out_opq;
 
1452
@@ -125,8 +128,8 @@ static int au_cpdown_dir(struct dentry *
 
1453
                        goto out_opq;
 
1454
                err = 0;
 
1455
                if (wh_dentry->d_inode)
 
1456
-                       err = au_unlink_wh_dentry(h_dir, wh_dentry, dentry,
 
1457
-                                                 NULL, dlgt);
 
1458
+                       err = au_unlink_wh_dentry(h_dir, wh_dentry, h_mnt,
 
1459
+                                                 dentry, NULL, dlgt);
 
1460
                dput(wh_dentry);
 
1461
                if (unlikely(err))
 
1462
                        goto out_opq;
 
1463
@@ -153,7 +156,7 @@ static int au_cpdown_dir(struct dentry *
 
1464
        }
 
1465
  out_dir:
 
1466
        if (made_dir) {
 
1467
-               rerr = vfsub_sio_rmdir(h_dir, h_dentry, dlgt);
 
1468
+               rerr = vfsub_sio_rmdir(h_dir, h_dentry, h_mnt, dlgt);
 
1469
                if (unlikely(rerr)) {
 
1470
                        AuIOErr("failed removing %.*s b%d (%d)\n",
 
1471
                                AuDLNPair(dentry), bdst, rerr);
 
1472
Index: fs/aufs/whout.c
 
1473
===================================================================
 
1474
RCS file: /cvsroot/aufs/aufs/fs/aufs/whout.c,v
 
1475
retrieving revision 1.30
 
1476
diff -u -p -r1.30 whout.c
 
1477
--- fs/aufs/whout.c     28 Jan 2008 05:01:42 -0000      1.30
 
1478
+++ fs/aufs/whout.c     29 Jan 2008 14:42:08 -0000
 
1479
@@ -219,6 +219,7 @@ int rename_whtmp(struct inode *dir, stru
 
1480
        struct dentry *h_dentry, *h_parent, *tmp_dentry;
 
1481
        struct super_block *sb;
 
1482
        struct aufs_hin_ignore ign;
 
1483
+       struct vfsmount *h_mnt;
 
1484
        struct vfsub_args vargs;
 
1485
        struct aufs_ndx ndx = {
 
1486
                .nd     = NULL,
 
1487
@@ -240,13 +241,15 @@ int rename_whtmp(struct inode *dir, stru
 
1488
        err = PTR_ERR(tmp_dentry);
 
1489
        if (!IS_ERR(tmp_dentry)) {
 
1490
                /* under the same dir, no need to lock_rename() */
 
1491
+               h_mnt = sbr_mnt(sb, bindex);
 
1492
                vfsub_args_init(&vargs, &ign, ndx.dlgt, 0);
 
1493
                AuDebugOn(!S_ISDIR(dentry->d_inode->i_mode));
 
1494
                if (unlikely(au_flag_test_udba_inotify(sb)
 
1495
                             && !noself))
 
1496
                        vfsub_ign_hinode(&vargs, IN_MOVE_SELF,
 
1497
                                         itohi(dentry->d_inode, bindex));
 
1498
-               err = vfsub_rename(h_dir, h_dentry, h_dir, tmp_dentry, &vargs);
 
1499
+               err = vfsub_rename(h_dir, h_dentry, h_mnt, h_dir, tmp_dentry,
 
1500
+                                  h_mnt, &vargs);
 
1501
                //if (LktrCond) err = -1; //unavailable
 
1502
                AuTraceErr(err);
 
1503
                dput(tmp_dentry);
 
1504
@@ -259,7 +262,7 @@ int rename_whtmp(struct inode *dir, stru
 
1505
 /* ---------------------------------------------------------------------- */
 
1506
 
 
1507
 static int do_unlink_wh(struct inode *h_dir, struct dentry *wh_dentry,
 
1508
-                       struct inode *dir, int dlgt)
 
1509
+                       struct vfsmount *h_mnt, struct inode *dir, int dlgt)
 
1510
 {
 
1511
        struct vfsub_args vargs;
 
1512
 
 
1513
@@ -274,11 +277,12 @@ static int do_unlink_wh(struct inode *h_
 
1514
        vfsub_args_init(&vargs, NULL, dlgt,
 
1515
                        (h_dir->i_mode & S_ISVTX)
 
1516
                        && wh_dentry->d_inode->i_uid != current->fsuid);
 
1517
-       return vfsub_unlink(h_dir, wh_dentry, &vargs);
 
1518
+       return vfsub_unlink(h_dir, wh_dentry, h_mnt, &vargs);
 
1519
 }
 
1520
 
 
1521
 int au_unlink_wh_dentry(struct inode *h_dir, struct dentry *wh_dentry,
 
1522
-                       struct dentry *dentry, struct inode *dir, int dlgt)
 
1523
+                       struct vfsmount *h_mnt, struct dentry *dentry,
 
1524
+                       struct inode *dir, int dlgt)
 
1525
 {
 
1526
        int err;
 
1527
 
 
1528
@@ -288,7 +292,7 @@ int au_unlink_wh_dentry(struct inode *h_
 
1529
                  || !wh_dentry->d_inode
 
1530
                  || !S_ISREG(wh_dentry->d_inode->i_mode));
 
1531
 
 
1532
-       err = do_unlink_wh(h_dir, wh_dentry, dir, dlgt);
 
1533
+       err = do_unlink_wh(h_dir, wh_dentry, h_mnt, dir, dlgt);
 
1534
        //if (LktrCond) err = -1; // unavailable
 
1535
        if (!err && dentry)
 
1536
                set_dbwh(dentry, -1);
 
1537
@@ -298,7 +302,8 @@ int au_unlink_wh_dentry(struct inode *h_
 
1538
 }
 
1539
 
 
1540
 static int unlink_wh_name(struct dentry *h_parent, struct qstr *wh,
 
1541
-                         struct inode *dir, struct aufs_ndx *ndx)
 
1542
+                         struct vfsmount *h_mnt, struct inode *dir,
 
1543
+                         struct aufs_ndx *ndx)
 
1544
 {
 
1545
        int err;
 
1546
        struct inode *h_dir;
 
1547
@@ -314,7 +319,8 @@ static int unlink_wh_name(struct dentry 
 
1548
                err = 0;
 
1549
                if (h_dentry->d_inode
 
1550
                    && S_ISREG(h_dentry->d_inode->i_mode))
 
1551
-                       err = do_unlink_wh(h_dir, h_dentry, dir, ndx->dlgt);
 
1552
+                       err = do_unlink_wh(h_dir, h_dentry, h_mnt, dir,
 
1553
+                                          ndx->dlgt);
 
1554
                dput(h_dentry);
 
1555
        } else
 
1556
                err = PTR_ERR(h_dentry);
 
1557
@@ -325,7 +331,8 @@ static int unlink_wh_name(struct dentry 
 
1558
 
 
1559
 /* ---------------------------------------------------------------------- */
 
1560
 
 
1561
-static void clean_wh(struct inode *h_dir, struct dentry *wh)
 
1562
+static void clean_wh(struct inode *h_dir, struct dentry *wh,
 
1563
+                    struct vfsmount *h_mnt)
 
1564
 {
 
1565
        int err;
 
1566
        struct vfsub_args vargs;
 
1567
@@ -334,14 +341,15 @@ static void clean_wh(struct inode *h_dir
 
1568
 
 
1569
        if (wh->d_inode) {
 
1570
                vfsub_args_init(&vargs, NULL, 0, 0);
 
1571
-               err = vfsub_unlink(h_dir, wh, &vargs);
 
1572
+               err = vfsub_unlink(h_dir, wh, h_mnt, &vargs);
 
1573
                if (unlikely(err))
 
1574
                        AuWarn("failed unlink %.*s (%d), ignored.\n",
 
1575
                               AuDLNPair(wh), err);
 
1576
        }
 
1577
 }
 
1578
 
 
1579
-static void clean_plink(struct inode *h_dir, struct dentry *plink)
 
1580
+static void clean_plink(struct inode *h_dir, struct dentry *plink,
 
1581
+                       struct vfsmount *h_mnt)
 
1582
 {
 
1583
        int err;
 
1584
        struct vfsub_args vargs;
 
1585
@@ -350,7 +358,7 @@ static void clean_plink(struct inode *h_
 
1586
 
 
1587
        if (plink->d_inode) {
 
1588
                vfsub_args_init(&vargs, NULL, 0, 0);
 
1589
-               err = vfsub_rmdir(h_dir, plink, &vargs);
 
1590
+               err = vfsub_rmdir(h_dir, plink, h_mnt, &vargs);
 
1591
                if (unlikely(err))
 
1592
                        AuWarn("failed rmdir %.*s (%d), ignored.\n",
 
1593
                               AuDLNPair(plink), err);
 
1594
@@ -364,7 +372,8 @@ static int test_linkable(struct inode *h
 
1595
        return -ENOSYS;
 
1596
 }
 
1597
 
 
1598
-static int plink_dir(struct inode *h_dir, struct dentry *plink)
 
1599
+static int plink_dir(struct inode *h_dir, struct dentry *plink,
 
1600
+                    struct vfsmount *h_mnt)
 
1601
 {
 
1602
        int err;
 
1603
 
 
1604
@@ -373,7 +382,7 @@ static int plink_dir(struct inode *h_dir
 
1605
                int mode = S_IRWXU;
 
1606
                if (unlikely(au_test_nfs(plink->d_sb)))
 
1607
                        mode |= S_IXUGO;
 
1608
-               err = vfsub_mkdir(h_dir, plink, mode, /*dlgt*/0);
 
1609
+               err = vfsub_mkdir(h_dir, plink, h_mnt, mode, /*dlgt*/0);
 
1610
        } else if (S_ISDIR(plink->d_inode->i_mode))
 
1611
                err = 0;
 
1612
        else
 
1613
@@ -439,23 +448,23 @@ int init_wh(struct dentry *h_root, struc
 
1614
        case AuBr_RO:
 
1615
        case AuBr_RRWH:
 
1616
        case AuBr_ROWH:
 
1617
-               clean_wh(h_dir, wh);
 
1618
-               clean_plink(h_dir, plink);
 
1619
+               clean_wh(h_dir, wh, br->br_mnt);
 
1620
+               clean_plink(h_dir, plink, br->br_mnt);
 
1621
                break;
 
1622
 
 
1623
        case AuBr_RWNoLinkWH:
 
1624
-               clean_wh(h_dir, wh);
 
1625
+               clean_wh(h_dir, wh, br->br_mnt);
 
1626
                if (do_plink) {
 
1627
                        err = test_linkable(h_dir);
 
1628
                        if (unlikely(err))
 
1629
                                goto out_nolink;
 
1630
 
 
1631
-                       err = plink_dir(h_dir, plink);
 
1632
+                       err = plink_dir(h_dir, plink, br->br_mnt);
 
1633
                        if (unlikely(err))
 
1634
                                goto out_err;
 
1635
                        br->br_plink = dget(plink);
 
1636
                } else
 
1637
-                       clean_plink(h_dir, plink);
 
1638
+                       clean_plink(h_dir, plink, br->br_mnt);
 
1639
                break;
 
1640
 
 
1641
        case AuBr_RW:
 
1642
@@ -484,12 +493,12 @@ int init_wh(struct dentry *h_root, struc
 
1643
                        goto out_err;
 
1644
 
 
1645
                if (do_plink) {
 
1646
-                       err = plink_dir(h_dir, plink);
 
1647
+                       err = plink_dir(h_dir, plink, br->br_mnt);
 
1648
                        if (unlikely(err))
 
1649
                                goto out_err;
 
1650
                        br->br_plink = dget(plink);
 
1651
                } else
 
1652
-                       clean_plink(h_dir, plink);
 
1653
+                       clean_plink(h_dir, plink, br->br_mnt);
 
1654
                br->br_wh = dget(wh);
 
1655
                break;
 
1656
 
 
1657
@@ -550,7 +559,7 @@ static void reinit_br_wh(void *arg)
 
1658
        revalidate h_wh
 
1659
 #endif
 
1660
        br_wh_write_lock(a->br);
 
1661
-       err = vfsub_unlink(h_dir, a->br->br_wh, &vargs);
 
1662
+       err = vfsub_unlink(h_dir, a->br->br_wh, a->br->br_mnt, &vargs);
 
1663
        //if (LktrCond) err = -1;
 
1664
        dput(a->br->br_wh);
 
1665
        a->br->br_wh = NULL;
 
1666
@@ -624,7 +633,8 @@ static int link_or_create_wh(struct dent
 
1667
        br = stobr(sb, bindex);
 
1668
        br_wh_read_lock(br);
 
1669
        if (br->br_wh) {
 
1670
-               err = vfsub_link(br->br_wh, h_dir, wh, dlgt);
 
1671
+               err = vfsub_link(br->br_wh, br->br_mnt, h_dir, wh, br->br_mnt,
 
1672
+                                dlgt);
 
1673
                if (!err || err != -EMLINK)
 
1674
                        goto out;
 
1675
 
 
1676
@@ -688,8 +698,8 @@ static struct dentry *do_diropq(struct d
 
1677
        } else {
 
1678
                AuDebugOn(/* !S_ISDIR(dentry->d_inode->i_mode)
 
1679
                           * ||  */!opq_dentry->d_inode);
 
1680
-               err = do_unlink_wh(h_dir, opq_dentry, dentry->d_inode,
 
1681
-                                  ndx.dlgt);
 
1682
+               err = do_unlink_wh(h_dir, opq_dentry, sbr_mnt(sb, bindex),
 
1683
+                                  dentry->d_inode, ndx.dlgt);
 
1684
                //if (LktrCond) err = -1;
 
1685
                if (!err)
 
1686
                        set_dbdiropq(dentry, -1);
 
1687
@@ -820,6 +830,7 @@ static int del_wh_children(struct aufs_n
 
1688
        struct aufs_wh *tpos;
 
1689
        struct hlist_node *pos;
 
1690
        struct aufs_destr *str;
 
1691
+       struct vfsmount *h_mnt;
 
1692
 
 
1693
        LKTRTrace("%.*s\n", AuDLNPair(h_parent));
 
1694
        h_dir = h_parent->d_inode;
 
1695
@@ -837,6 +848,7 @@ static int del_wh_children(struct aufs_n
 
1696
 
 
1697
        /* already checked by au_test_perm(). */
 
1698
        err = 0;
 
1699
+       h_mnt = sbr_mnt(inode->i_sb, bindex);
 
1700
        for (i = 0; !err && i < AuSize_NHASH; i++) {
 
1701
                head = whlist->heads + i;
 
1702
                hlist_for_each_entry(tpos, pos, head, wh_hash) {
 
1703
@@ -846,8 +858,8 @@ static int del_wh_children(struct aufs_n
 
1704
                        if (str->len + AUFS_WH_PFX_LEN <= PATH_MAX) {
 
1705
                                memcpy(p, str->name, str->len);
 
1706
                                wh_name.len = AUFS_WH_PFX_LEN + str->len;
 
1707
-                               err = unlink_wh_name(h_parent, &wh_name, inode,
 
1708
-                                                    ndx);
 
1709
+                               err = unlink_wh_name(h_parent, &wh_name, h_mnt,
 
1710
+                                                    inode, ndx);
 
1711
                                //if (LktrCond) err = -1;
 
1712
                                if (!err)
 
1713
                                        continue;
 
1714
@@ -949,7 +961,7 @@ int rmdir_whtmp(struct dentry *h_dentry,
 
1715
                             && !noself))
 
1716
                        vfsub_ign_hinode(&vargs, IN_DELETE_SELF,
 
1717
                                         itohi(inode, bindex));
 
1718
-               err = vfsub_rmdir(h_dir, h_dentry, &vargs);
 
1719
+               err = vfsub_rmdir(h_dir, h_dentry, sbr_mnt(sb, bindex), &vargs);
 
1720
                //d_drop(h_dentry);
 
1721
                //if (LktrCond) err = -1;
 
1722
        }
 
1723
Index: fs/aufs/whout.h
 
1724
===================================================================
 
1725
RCS file: /cvsroot/aufs/aufs/fs/aufs/whout.h,v
 
1726
retrieving revision 1.13
 
1727
diff -u -p -r1.13 whout.h
 
1728
--- fs/aufs/whout.h     1 Oct 2007 04:48:51 -0000       1.13
 
1729
+++ fs/aufs/whout.h     29 Jan 2008 14:42:08 -0000
 
1730
@@ -39,7 +39,8 @@ struct dentry *lkup_whtmp(struct dentry 
 
1731
 int rename_whtmp(struct inode *dir, struct dentry *dentry, aufs_bindex_t bindex,
 
1732
                 int noself);
 
1733
 int au_unlink_wh_dentry(struct inode *h_dir, struct dentry *wh_dentry,
 
1734
-                       struct dentry *dentry, struct inode *dir, int dlgt);
 
1735
+                       struct vfsmount *h_mnt, struct dentry *dentry,
 
1736
+                       struct inode *dir, int dlgt);
 
1737
 
 
1738
 struct aufs_branch;
 
1739
 int init_wh(struct dentry *h_parent, struct aufs_branch *br,
 
1740
Index: fs/aufs/xino.c
 
1741
===================================================================
 
1742
RCS file: /cvsroot/aufs/aufs/fs/aufs/xino.c,v
 
1743
retrieving revision 1.47
 
1744
diff -u -p -r1.47 xino.c
 
1745
--- fs/aufs/xino.c      10 Dec 2007 01:19:54 -0000      1.47
 
1746
+++ fs/aufs/xino.c      29 Jan 2008 14:42:08 -0000
 
1747
@@ -520,7 +520,7 @@ struct file *xino_create(struct super_bl
 
1748
        h_dir = h_parent->d_inode;
 
1749
        vfsub_args_init(&vargs, NULL, 0, 0);
 
1750
        vfsub_i_lock_nested(h_dir, AuLsc_I_PARENT);
 
1751
-       err = vfsub_unlink(h_dir, file->f_dentry, &vargs);
 
1752
+       err = vfsub_unlink(h_dir, file->f_dentry, file->f_vfsmnt, &vargs);
 
1753
        vfsub_i_unlock(h_dir);
 
1754
        dput(h_parent);
 
1755
        if (unlikely(err)) {
 
1756
@@ -611,7 +611,7 @@ static struct file *xino_create2(struct 
 
1757
                goto out_dput;
 
1758
        }
 
1759
        vfsub_args_init(&vargs, NULL, 0, 0);
 
1760
-       err = vfsub_unlink(dir, dentry, &vargs);
 
1761
+       err = vfsub_unlink(dir, dentry, file->f_vfsmnt, &vargs);
 
1762
        //if (LktrCond) err = -1;
 
1763
        if (unlikely(err)) {
 
1764
                AuErr("%.*s unlink err %d\n", AuLNPair(name), err);
 
1765
@@ -620,7 +620,8 @@ static struct file *xino_create2(struct 
 
1766
 
 
1767
        if (unlikely(copy_src)) {
 
1768
                inode = copy_src->f_dentry->d_inode;
 
1769
-               err = au_copy_file(file, copy_src, i_size_read(inode), sb);
 
1770
+               err = au_copy_file(file, copy_src, i_size_read(inode), sb,
 
1771
+                                  file->f_vfsmnt);
 
1772
                if (unlikely(err)) {
 
1773
                        AuErr("%.*s copy err %d\n", AuLNPair(name), err);
 
1774
                        goto out_fput;