← Back to branch summary

~ubuntu-branches/ubuntu/vivid/aufs/vivid

« back to all changes in this revision

Viewing changes to patch/ubuntu-2.6.22-14.46.patch

  • Committer: Bazaar Package Importer
  • Author(s): Julian Andres Klode
  • Date: 2007-12-15 23:32:51 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20071215233251-2vgs2lmg8mai5d9e
Tags: 0+20071211-1ubuntu1
https://launchpad.net/bugs/175705
* Merge from debian unstable (LP: #175705), remaining changes:
  - Fix for Ubuntu Kernels (updated)
* patches/01_vserver.dpatch: Removed
* patches/06_ubuntu.dpatch: Added (update of ubuntu patch)

Show diffs side-by-side

added added

removed removed

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