← Back to branch summary

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

« back to all changes in this revision

Viewing changes to fs/aufs/super.c

  • 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:
fs/aufs/super.c
16
16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
17
 */
18
18
 
19
 
/* $Id: super.c,v 1.53 2007/06/04 02:17:35 sfjro Exp $ */
 
19
/* $Id: super.c,v 1.72 2007/12/03 01:38:16 sfjro Exp $ */
20
20
 
21
21
#include <linux/module.h>
22
22
#include <linux/seq_file.h>
24
24
#include <linux/statfs.h>
25
25
 
26
26
#include <linux/version.h>
27
 
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
 
27
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20)
28
28
#include <linux/mnt_namespace.h>
29
29
typedef struct mnt_namespace au_mnt_ns_t;
30
30
#define au_nsproxy(tsk) (tsk)->nsproxy
31
31
#define au_mnt_ns(tsk)  (tsk)->nsproxy->mnt_ns
32
 
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
 
32
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
33
33
#include <linux/namespace.h>
34
34
typedef struct namespace au_mnt_ns_t;
35
35
#define au_nsproxy(tsk) (tsk)->nsproxy
36
36
#define au_mnt_ns(tsk)  (tsk)->nsproxy->namespace
37
 
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
 
37
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
38
38
#include <linux/namespace.h>
39
39
typedef struct namespace au_mnt_ns_t;
40
40
#define au_nsproxy(tsk) (tsk)->namespace
50
50
{
51
51
        struct aufs_icntnr *c;
52
52
 
53
 
        TraceEnter();
 
53
        AuTraceEnter();
54
54
 
55
 
        c = cache_alloc_icntnr();
56
 
        //if (LktrCond) {cache_free_icntnr(c); c = NULL;}
 
55
        c = au_cache_alloc_icntnr();
 
56
        //if (LktrCond) {au_cache_free_icntnr(c); c = NULL;}
57
57
        if (c) {
58
58
                inode_init_once(&c->vfs_inode);
59
59
                c->vfs_inode.i_version = 1; //sigen(sb);
67
67
{
68
68
        LKTRTrace("i%lu\n", inode->i_ino);
69
69
        au_iinfo_fin(inode);
70
 
        cache_free_icntnr(container_of(inode, struct aufs_icntnr, vfs_inode));
 
70
        au_cache_free_icntnr(container_of(inode, struct aufs_icntnr,
 
71
                                          vfs_inode));
71
72
}
72
73
 
73
74
//todo: how about merge with alloc_inode()?
74
75
static void aufs_read_inode(struct inode *inode)
75
76
{
76
77
        int err;
 
78
#if 0
 
79
        static struct backing_dev_info bdi = {
 
80
                .ra_pages       = 0,    /* No readahead */
 
81
                .capabilities   = BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK
 
82
        };
 
83
#endif
77
84
 
78
85
        LKTRTrace("i%lu\n", inode->i_ino);
79
86
 
84
91
                inode->i_op = &aufs_iop;
85
92
                inode->i_fop = &aufs_file_fop;
86
93
                inode->i_mapping->a_ops = &aufs_aop;
 
94
                //inode->i_mapping->backing_dev_info = &bdi;
87
95
                return; /* success */
88
96
        }
89
97
 
95
103
{
96
104
        int err;
97
105
        aufs_bindex_t bindex, bend;
98
 
        char a[16];
99
106
        struct dentry *root;
100
107
 
101
 
        TraceEnter();
 
108
        AuTraceEnter();
102
109
        SiMustAnyLock(sb);
103
110
        root = sb->s_root;
104
111
        DiMustAnyLock(root);
106
113
        err = 0;
107
114
        bend = sbend(sb);
108
115
        for (bindex = 0; !err && bindex <= bend; bindex++) {
109
 
                err = br_perm_str(a, sizeof(a), sbr_perm(sb, bindex));
110
 
                if (!err)
111
 
                        err = seq_path(seq, sbr_mnt(sb, bindex),
112
 
                                       au_h_dptr_i(root, bindex), au_esc_chars);
 
116
                err = seq_path(seq, sbr_mnt(sb, bindex),
 
117
                               au_h_dptr_i(root, bindex), au_esc_chars);
113
118
                if (err > 0)
114
 
                        err = seq_printf(seq, "=%s", a);
 
119
                        err = seq_printf
 
120
                                (seq, "=%s",
 
121
                                 au_optstr_br_perm(sbr_perm(sb, bindex)));
115
122
                if (!err && bindex != bend)
116
123
                        err = seq_putc(seq, ':');
117
124
        }
118
125
 
119
 
        TraceErr(err);
 
126
        AuTraceErr(err);
120
127
        return err;
121
128
}
122
129
 
127
134
        struct aufs_sbinfo *sbinfo;
128
135
        struct dentry *root;
129
136
        struct file *xino;
 
137
        struct au_opts_flags def;
130
138
 
131
 
        TraceEnter();
 
139
        AuTraceEnter();
132
140
 
133
141
        sb = mnt->mnt_sb;
134
142
        root = sb->s_root;
135
 
        aufs_read_lock(root, !AUFS_I_RLOCK);
136
 
        if (au_flag_test(sb, AuFlag_XINO)) {
 
143
        aufs_read_lock(root, !AuLock_IR);
 
144
        sbinfo = stosi(sb);
 
145
        if (AuFlag(sbinfo, f_xino) == AuXino_XINO) {
137
146
                err = seq_puts(m, ",xino=");
138
147
                if (unlikely(err))
139
148
                        goto out;
140
 
                xino = stobr(sb, 0)->br_xino;
 
149
                xino = sbinfo->si_xib;
141
150
                err = seq_path(m, xino->f_vfsmnt, xino->f_dentry, au_esc_chars);
142
151
                if (unlikely(err <= 0))
143
152
                        goto out;
151
160
        } else
152
161
                err = seq_puts(m, ",noxino");
153
162
 
154
 
        n = au_flag_test(sb, AuFlag_PLINK);
155
 
        if (unlikely(!err && (AuDefFlags & AuFlag_PLINK) != n))
156
 
                err = seq_printf(m, ",%splink", n ? "" : "no");
157
 
        n = au_flag_test_udba(sb);
158
 
        if (unlikely(!err && (AuDefFlags & AuMask_UDBA) != n))
159
 
                err = seq_printf(m, ",udba=%s", udba_str(n));
160
 
        n = au_flag_test(sb, AuFlag_ALWAYS_DIROPQ);
161
 
        if (unlikely(!err && (AuDefFlags & AuFlag_ALWAYS_DIROPQ) != n))
 
163
        au_opts_flags_def(&def);
 
164
 
 
165
#define Print(name) do { \
 
166
        n = AuFlag(sbinfo, f_##name); \
 
167
        if (unlikely(!err && n != def.f_##name)) \
 
168
                err = seq_printf(m, ",%s"#name, n ? "" : "no"); \
 
169
} while (0)
 
170
 
 
171
#define PrintStr(name, str) do { \
 
172
        n = AuFlag(sbinfo, f_##name); \
 
173
        if (unlikely(!err && n != def.f_##name)) \
 
174
                err = seq_printf(m, "," str "=%s", au_optstr_##name(n)); \
 
175
} while (0)
 
176
 
 
177
        Print(trunc_xino);
 
178
        Print(plink);
 
179
        PrintStr(udba, "udba");
 
180
        switch (AuFlag(sbinfo, f_wbr_create)) {
 
181
        case AuWbrCreate_TDP:
 
182
        case AuWbrCreate_RR:
 
183
        case AuWbrCreate_MFS:
 
184
        case AuWbrCreate_PMFS:
 
185
                PrintStr(wbr_create, "create");
 
186
                break;
 
187
        case AuWbrCreate_MFSV:
 
188
                err = seq_printf(m, ",create=mfs:%lu",
 
189
                                 sbinfo->si_wbr_mfs.mfs_expire / HZ);
 
190
                break;
 
191
        case AuWbrCreate_PMFSV:
 
192
                err = seq_printf(m, ",create=pmfs:%lu",
 
193
                                 sbinfo->si_wbr_mfs.mfs_expire / HZ);
 
194
                break;
 
195
        case AuWbrCreate_MFSRR:
 
196
                err = seq_printf(m, ",create=mfsrr:%Lu",
 
197
                                 sbinfo->si_wbr_mfs.mfsrr_watermark);
 
198
                break;
 
199
        case AuWbrCreate_MFSRRV:
 
200
                err = seq_printf(m, ",create=mfsrr:%Lu:%lu",
 
201
                                 sbinfo->si_wbr_mfs.mfsrr_watermark,
 
202
                                 sbinfo->si_wbr_mfs.mfs_expire / HZ);
 
203
                break;
 
204
        default:
 
205
                AuDebugOn(1);
 
206
        }
 
207
 
 
208
        PrintStr(wbr_copyup, "cpup");
 
209
        n = AuFlag(sbinfo, f_always_diropq);
 
210
        if (unlikely(!err && n != def.f_always_diropq))
162
211
                err = seq_printf(m, ",diropq=%c", n ? 'a' : 'w');
163
 
        n = au_flag_test(sb, AuFlag_DLGT);
164
 
        if (unlikely(!err && (AuDefFlags & AuFlag_DLGT) != n))
165
 
                err = seq_printf(m, ",%sdlgt", n ? "" : "no");
166
 
        n = au_flag_test(sb, AuFlag_WARN_PERM);
167
 
        if (unlikely(!err && (AuDefFlags & AuFlag_WARN_PERM) != n))
168
 
                err = seq_printf(m, ",%swarn_perm", n ? "" : "no");
 
212
        Print(refrof);
 
213
        Print(dlgt);
 
214
        Print(warn_perm);
 
215
        Print(verbose);
169
216
 
170
 
        sbinfo = stosi(sb);
171
217
        n = sbinfo->si_dirwh;
172
218
        if (unlikely(!err && n != AUFS_DIRWH_DEF))
173
219
                err = seq_printf(m, ",dirwh=%d", n);
174
220
        n = sbinfo->si_rdcache / HZ;
175
221
        if (unlikely(!err && n != AUFS_RDCACHE_DEF))
176
222
                err = seq_printf(m, ",rdcache=%d", n);
177
 
#if 0
178
 
        n = au_flag_test_coo(sb);
179
 
        if (unlikely(!err && (AuDefFlags & AuMask_COO) != n))
180
 
                err = seq_printf(m, ",coo=%s", coo_str(n));
181
 
#endif
 
223
 
 
224
        PrintStr(coo, "coo");
 
225
 
 
226
#undef Print
 
227
#undef PrintStr
182
228
 
183
229
        if (!err && !sysaufs_brs) {
184
230
#ifdef CONFIG_AUFS_COMPAT
191
237
        }
192
238
 
193
239
 out:
194
 
        aufs_read_unlock(root, !AUFS_I_RLOCK);
195
 
        TraceErr(err);
 
240
        aufs_read_unlock(root, !AuLock_IR);
 
241
        AuTraceErr(err);
196
242
        if (err)
197
243
                err = -E2BIG;
198
 
        TraceErr(err);
 
244
        AuTraceErr(err);
199
245
        return err;
200
246
}
201
247
 
202
 
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
 
248
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
203
249
#define StatfsLock(d)   aufs_read_lock((d)->d_sb->s_root, 0)
204
250
#define StatfsUnlock(d) aufs_read_unlock((d)->d_sb->s_root, 0)
205
251
#define StatfsArg(d)    au_h_dptr((d)->d_sb->s_root)
207
253
#define StatfsSb(d)     ((d)->d_sb)
208
254
static int aufs_statfs(struct dentry *arg, struct kstatfs *buf)
209
255
#else
210
 
#define StatfsLock(s)   si_read_lock(s)
 
256
#define StatfsLock(s)   si_read_lock(s, !AuLock_FLUSH)
211
257
#define StatfsUnlock(s) si_read_unlock(s)
212
258
#define StatfsArg(s)    sbr_sb(s, 0)
213
259
#define StatfsHInode(s) (StatfsArg(s)->s_root->d_inode)
217
263
{
218
264
        int err;
219
265
 
220
 
        TraceEnter();
 
266
        AuTraceEnter();
221
267
 
222
268
        StatfsLock(arg);
223
 
        err = vfsub_statfs(StatfsArg(arg), buf, need_dlgt(StatfsSb(arg)));
 
269
        err = vfsub_statfs(StatfsArg(arg), buf, au_need_dlgt(StatfsSb(arg)));
224
270
        //if (LktrCond) err = -1;
225
271
        StatfsUnlock(arg);
226
272
        if (!err) {
227
 
                //buf->f_type = AUFS_SUPER_MAGIC;
 
273
                buf->f_type = AUFS_SUPER_MAGIC;
228
274
                buf->f_type = 0;
229
275
                buf->f_namelen -= AUFS_WH_PFX_LEN;
 
276
                //todo: support uuid?
230
277
                memset(&buf->f_fsid, 0, sizeof(buf->f_fsid));
231
278
        }
232
 
        //buf->f_bsize = buf->f_blocks = buf->f_bfree = buf->f_bavail = -1;
 
279
        /* buf->f_bsize = buf->f_blocks = buf->f_bfree = buf->f_bavail = -1; */
233
280
 
234
 
        TraceErr(err);
 
281
        AuTraceErr(err);
235
282
        return err;
236
283
}
237
284
 
238
285
static void au_update_mnt(struct vfsmount *mnt)
239
286
{
240
 
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
 
287
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
241
288
        struct vfsmount *pos;
242
289
        struct super_block *sb = mnt->mnt_sb;
243
290
        struct dentry *root = sb->s_root;
244
291
        struct aufs_sbinfo *sbinfo = stosi(sb);
245
292
        au_mnt_ns_t *ns;
246
293
 
247
 
        TraceEnter();
 
294
        AuTraceEnter();
248
295
        AuDebugOn(!kernel_locked());
249
296
 
250
297
        if (sbinfo->si_mnt != mnt
265
312
#endif
266
313
}
267
314
 
268
 
#define UmountBeginHasMnt \
269
 
        (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18) || defined(UbuntuEdgy17Umount18))
 
315
#define UmountBeginHasMnt       (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18))
270
316
 
271
317
#if UmountBeginHasMnt
272
318
#define UmountBeginSb(mnt)      (mnt)->mnt_sb
282
328
        struct vfsmount *mnt = UmountBeginMnt(arg);
283
329
        struct aufs_sbinfo *sbinfo;
284
330
 
285
 
        TraceEnter();
 
331
        AuTraceEnter();
286
332
 
287
333
        sbinfo = stosi(sb);
288
334
        if (unlikely(!sbinfo))
289
335
                return;
290
336
 
291
 
#if 1
292
 
        flush_scheduled_work();
293
 
#else
294
 
        wait_event(sbinfo->si_wkq_nowait_wq,
295
 
                   !atomic_read(&sbinfo->si_wkq_nowait));
296
 
#endif
297
337
        si_write_lock(sb);
298
 
        if (au_flag_test(sb, AuFlag_PLINK))
 
338
        if (AuFlag(sbinfo, f_plink))
299
339
                au_put_plink(sb);
300
 
#if 0
 
340
#if 0 // remove
301
341
        if (unlikely(au_flag_test(sb, AuFlag_UDBA_INOTIFY)))
302
342
                shrink_dcache_sb(sb);
303
343
#endif
304
344
        au_update_mnt(mnt);
 
345
#if 0
 
346
        if (sbinfo->si_wbr_create_ops->fin)
 
347
                sbinfo->si_wbr_create_ops->fin(sb);
 
348
#endif
305
349
        si_write_unlock(sb);
306
350
}
307
351
 
308
 
static void free_sbinfo(struct aufs_sbinfo *sbinfo)
 
352
static void free_sbinfo(struct super_block *sb)
309
353
{
310
 
        TraceEnter();
311
 
        AuDebugOn(!sbinfo
312
 
                  || !list_empty(&sbinfo->si_plink)
313
 
                  /* || atomic_read(&sbinfo->si_wkq_nowait) */
314
 
                );
315
 
 
 
354
        struct aufs_sbinfo *sbinfo;
 
355
 
 
356
        AuTraceEnter();
 
357
        sbinfo = stosi(sb);
 
358
        AuDebugOn(!sbinfo || !list_empty(&sbinfo->si_plink));
 
359
 
 
360
        si_write_lock(sb);
 
361
        xino_clr(sb);
316
362
        free_branches(sbinfo);
317
363
        kfree(sbinfo->si_branch);
318
 
        //destroy_workqueue(sbinfo->si_wkq);
 
364
        si_write_unlock(sb);
319
365
        kfree(sbinfo);
320
366
}
321
367
 
324
370
{
325
371
        struct aufs_sbinfo *sbinfo;
326
372
 
327
 
        TraceEnter();
 
373
        AuTraceEnter();
328
374
 
329
375
        sbinfo = stosi(sb);
330
376
        if (unlikely(!sbinfo))
333
379
        sysaufs_del(sbinfo);
334
380
 
335
381
#if !UmountBeginHasMnt
336
 
        // umount_begin() may not be called.
 
382
        /* umount_begin() may not be called. */
337
383
        aufs_umount_begin(sb);
338
384
#endif
339
 
        free_sbinfo(sbinfo);
 
385
        free_sbinfo(sb);
340
386
}
341
387
 
342
388
/* ---------------------------------------------------------------------- */
343
389
 
344
390
/*
345
 
 * refresh directories at remount time.
 
391
 * refresh dentry and inode at remount time.
346
392
 */
347
 
static int do_refresh_dir(struct dentry *dentry, unsigned int flags)
 
393
static int do_refresh(struct dentry *dentry, mode_t type,
 
394
                      unsigned int dir_flags)
348
395
{
349
396
        int err;
350
397
        struct dentry *parent;
351
398
        struct inode *inode;
352
399
 
353
 
        LKTRTrace("%.*s\n", DLNPair(dentry));
 
400
        LKTRTrace("%.*s, 0%o\n", AuDLNPair(dentry), type);
354
401
        inode = dentry->d_inode;
355
 
        AuDebugOn(!inode || !S_ISDIR(inode->i_mode));
 
402
        AuDebugOn(!inode);
356
403
 
357
404
        di_write_lock_child(dentry);
358
405
        parent = dget_parent(dentry);
359
 
        di_read_lock_parent(parent, AUFS_I_RLOCK);
360
 
        err = au_refresh_hdentry(dentry, S_IFDIR);
 
406
        di_read_lock_parent(parent, AuLock_IR);
 
407
        /* returns a number of positive dentries */
 
408
        err = au_refresh_hdentry(dentry, type);
 
409
        //err = -1;
361
410
        if (err >= 0) {
362
411
                err = au_refresh_hinode(inode, dentry);
363
 
                if (!err)
364
 
                        au_reset_hinotify(inode, flags);
 
412
                //err = -1;
 
413
                if (unlikely(!err && type == S_IFDIR))
 
414
                        au_reset_hinotify(inode, dir_flags);
365
415
        }
366
416
        if (unlikely(err))
367
 
                Err("unrecoverable error %d\n", err);
368
 
        di_read_unlock(parent, AUFS_I_RLOCK);
 
417
                AuErr("unrecoverable error %d, %.*s\n", err, AuDLNPair(dentry));
 
418
        di_read_unlock(parent, AuLock_IR);
369
419
        dput(parent);
370
420
        di_write_unlock(dentry);
371
421
 
372
 
        TraceErr(err);
 
422
        AuTraceErr(err);
373
423
        return err;
374
424
}
375
425
 
378
428
        return S_ISDIR(dentry->d_inode->i_mode);
379
429
}
380
430
 
381
 
static int refresh_dir(struct dentry *root, int sgen)
 
431
static int refresh_dir(struct dentry *root, au_gen_t sgen)
382
432
{
383
 
        int err, i, j, ndentry;
 
433
        int err, i, j, ndentry, e;
384
434
        const unsigned int flags = au_hi_flags(root->d_inode, /*isdir*/1);
385
435
        struct au_dcsub_pages dpages;
386
436
        struct au_dpage *dpage;
387
437
        struct dentry **dentries;
 
438
        struct inode *inode;
388
439
 
389
440
        LKTRTrace("sgen %d\n", sgen);
390
441
        SiMustWriteLock(root->d_sb);
391
 
        AuDebugOn(au_digen(root) != sgen);
392
 
        DiMustWriteLock(root);
393
 
 
394
 
        err = au_dpages_init(&dpages, GFP_KERNEL);
395
 
        if (unlikely(err))
 
442
        AuDebugOn(au_digen(root) != sgen
 
443
                  || !kernel_locked());
 
444
 
 
445
        err = 0;
 
446
        list_for_each_entry(inode, &root->d_sb->s_inodes, i_sb_list)
 
447
                if (unlikely(S_ISDIR(inode->i_mode)
 
448
                             && au_iigen(inode) != sgen)) {
 
449
                        ii_write_lock_child(inode);
 
450
                        e = au_refresh_hinode_self(inode);
 
451
                        //e = -1;
 
452
                        ii_write_unlock(inode);
 
453
                        if (unlikely(e)) {
 
454
                                LKTRTrace("e %d, i%lu\n", e, inode->i_ino);
 
455
                                if (!err)
 
456
                                        err = e;
 
457
                                /* go on even if err */
 
458
                        }
 
459
                }
 
460
 
 
461
        e = au_dpages_init(&dpages, GFP_TEMPORARY);
 
462
        if (unlikely(e)) {
 
463
                if (!err)
 
464
                        err = e;
396
465
                goto out;
397
 
        err = au_dcsub_pages(&dpages, root, test_dir, NULL);
398
 
        if (unlikely(err))
 
466
        }
 
467
        e = au_dcsub_pages(&dpages, root, test_dir, NULL);
 
468
        if (unlikely(e)) {
 
469
                if (!err)
 
470
                        err = e;
399
471
                goto out_dpages;
 
472
        }
400
473
 
401
 
        DiMustNoWaiters(root);
402
 
        IiMustNoWaiters(root->d_inode);
403
 
        di_write_unlock(root);
404
 
        for (i = 0; !err && i < dpages.ndpage; i++) {
 
474
        e = 0;
 
475
        for (i = 0; !e && i < dpages.ndpage; i++) {
405
476
                dpage = dpages.dpages + i;
406
477
                dentries = dpage->dentries;
407
478
                ndentry = dpage->ndentry;
408
 
                for (j = 0; !err && j < ndentry; j++) {
 
479
                for (j = 0; !e && j < ndentry; j++) {
409
480
                        struct dentry *d;
410
481
                        d = dentries[j];
411
482
#ifdef CONFIG_AUFS_DEBUG
418
489
                                dput(parent);
419
490
                        }
420
491
#endif
421
 
                        if (au_digen(d) != sgen)
422
 
                                err = do_refresh_dir(d, flags);
423
 
                }
424
 
        }
425
 
        di_write_lock_child(root); /* aufs_write_lock() calls ..._child() */
426
 
 
427
 
 out_dpages:
428
 
        au_dpages_free(&dpages);
429
 
 out:
430
 
        TraceErr(err);
 
492
                        if (au_digen(d) != sgen) {
 
493
                                e = do_refresh(d, S_IFDIR, flags);
 
494
                                //e = -1;
 
495
                                if (unlikely(e && !err))
 
496
                                        err = e;
 
497
                                /* break on err */
 
498
                        }
 
499
                }
 
500
        }
 
501
 
 
502
 out_dpages:
 
503
        au_dpages_free(&dpages);
 
504
 out:
 
505
        AuTraceErr(err);
 
506
        return err;
 
507
}
 
508
 
 
509
static int test_nondir(struct dentry *dentry, void *arg)
 
510
{
 
511
        return !S_ISDIR(dentry->d_inode->i_mode);
 
512
}
 
513
 
 
514
static int refresh_nondir(struct dentry *root, au_gen_t sgen, int do_dentry)
 
515
{
 
516
        int err, i, j, ndentry, e;
 
517
        struct au_dcsub_pages dpages;
 
518
        struct au_dpage *dpage;
 
519
        struct dentry **dentries;
 
520
        struct inode *inode;
 
521
 
 
522
        LKTRTrace("sgen %d\n", sgen);
 
523
        SiMustWriteLock(root->d_sb);
 
524
        AuDebugOn(au_digen(root) != sgen
 
525
                  || !kernel_locked());
 
526
 
 
527
        err = 0;
 
528
        list_for_each_entry(inode, &root->d_sb->s_inodes, i_sb_list)
 
529
                if (unlikely(!S_ISDIR(inode->i_mode)
 
530
                             && au_iigen(inode) != sgen)) {
 
531
                        ii_write_lock_child(inode);
 
532
                        e = au_refresh_hinode_self(inode);
 
533
                        //e = -1;
 
534
                        ii_write_unlock(inode);
 
535
                        if (unlikely(e)) {
 
536
                                LKTRTrace("e %d, i%lu\n", e, inode->i_ino);
 
537
                                if (!err)
 
538
                                        err = e;
 
539
                                /* go on even if err */
 
540
                        }
 
541
                }
 
542
 
 
543
        if (unlikely(!do_dentry))
 
544
                goto out;
 
545
 
 
546
        e = au_dpages_init(&dpages, GFP_TEMPORARY);
 
547
        if (unlikely(e)) {
 
548
                if (!err)
 
549
                        err = e;
 
550
                goto out;
 
551
        }
 
552
        e = au_dcsub_pages(&dpages, root, test_nondir, NULL);
 
553
        if (unlikely(e)) {
 
554
                if (!err)
 
555
                        err = e;
 
556
                goto out_dpages;
 
557
        }
 
558
 
 
559
        for (i = 0; i < dpages.ndpage; i++) {
 
560
                dpage = dpages.dpages + i;
 
561
                dentries = dpage->dentries;
 
562
                ndentry = dpage->ndentry;
 
563
                for (j = 0; j < ndentry; j++) {
 
564
                        struct dentry *d;
 
565
                        d = dentries[j];
 
566
#ifdef CONFIG_AUFS_DEBUG
 
567
                        {
 
568
                                struct dentry *parent;
 
569
                                parent = dget_parent(d);
 
570
                                AuDebugOn(S_ISDIR(d->d_inode->i_mode)
 
571
                                          || au_digen(parent) != sgen);
 
572
                                dput(parent);
 
573
                        }
 
574
#endif
 
575
                        inode = d->d_inode;
 
576
                        if (inode && au_digen(d) != sgen) {
 
577
                                e = do_refresh(d, inode->i_mode & S_IFMT, 0);
 
578
                                //e = -1;
 
579
                                if (unlikely(e && !err))
 
580
                                        err = e;
 
581
                                /* go on even err */
 
582
                        }
 
583
                }
 
584
        }
 
585
 
 
586
 out_dpages:
 
587
        au_dpages_free(&dpages);
 
588
 out:
 
589
        AuTraceErr(err);
431
590
        return err;
432
591
}
433
592
 
434
593
/* stop extra interpretation of errno in mount(8), and strange error messages */
435
594
static int cvt_err(int err)
436
595
{
437
 
        TraceErr(err);
 
596
        AuTraceErr(err);
438
597
 
439
598
        switch (err) {
440
599
        case -ENOENT:
449
608
/* protected by s_umount */
450
609
static int aufs_remount_fs(struct super_block *sb, int *flags, char *data)
451
610
{
452
 
        int err, do_refresh;
 
611
        int err;
453
612
        struct dentry *root;
454
613
        struct inode *inode;
455
 
        struct opts opts;
456
 
        unsigned int given, dlgt;
 
614
        struct au_opts opts;
 
615
        unsigned int dlgt;
457
616
        struct aufs_sbinfo *sbinfo;
458
617
 
459
618
        //au_debug_on();
467
626
 
468
627
        err = -ENOMEM;
469
628
        memset(&opts, 0, sizeof(opts));
470
 
        opts.opt = (void*)__get_free_page(GFP_KERNEL);
 
629
        opts.opt = (void *)__get_free_page(GFP_TEMPORARY);
471
630
        //if (LktrCond) {free_page((unsigned long)opts.opt); opts.opt = NULL;}
472
631
        if (unlikely(!opts.opt))
473
632
                goto out;
474
633
        opts.max_opt = PAGE_SIZE / sizeof(*opts.opt);
 
634
        opts.remount = 1;
475
635
 
476
636
        /* parse it before aufs lock */
477
 
        err = au_parse_opts(sb, data, &opts);
 
637
        err = au_opts_parse(sb, data, &opts);
478
638
        //if (LktrCond) {au_free_opts(&opts); err = -1;}
479
639
        if (unlikely(err))
480
640
                goto out_opts;
481
641
 
482
642
        sbinfo = stosi(sb);
483
 
        //Dbg("%d\n", atomic_read(&sbinfo->si_wkq_nowait));
484
 
#if 1
485
 
        flush_scheduled_work();
486
 
#else
487
 
        err = wait_event_interruptible(sbinfo->si_wkq_nowait_wq,
488
 
                                       !atomic_read(&sbinfo->si_wkq_nowait));
489
 
        if (unlikely(err))
490
 
                goto out_opts;
491
 
#endif
492
 
 
493
643
        root = sb->s_root;
494
644
        inode = root->d_inode;
495
 
        i_lock(inode);
 
645
        vfsub_i_lock(inode);
496
646
        aufs_write_lock(root);
497
647
 
498
648
        //DbgSleep(3);
499
649
 
500
650
        /* au_do_opts() may return an error */
501
 
        do_refresh = 0;
502
 
        given = 0;
503
 
        err = au_do_opts_remount(sb, &opts, &do_refresh, &given);
 
651
        err = au_opts_remount(sb, &opts);
504
652
        //if (LktrCond) err = -1;
505
 
        au_free_opts(&opts);
 
653
        au_opts_free(&opts);
506
654
 
507
 
        if (do_refresh) {
 
655
        if (opts.refresh_dir || opts.refresh_nondir) {
508
656
                int rerr;
 
657
                au_gen_t sigen;
509
658
 
510
 
                dlgt = au_flag_test(sb, AuFlag_DLGT);
511
 
                au_flag_clr(sb, AuFlag_DLGT);
 
659
                dlgt = au_need_dlgt(sb);
 
660
                AuFlagSet(sbinfo, f_dlgt, 0);
512
661
                au_sigen_inc(sb);
513
662
                au_reset_hinotify(inode, au_hi_flags(inode, /*isdir*/1));
 
663
                sigen = au_sigen(sb);
514
664
                sbinfo->si_failed_refresh_dirs = 0;
515
 
                rerr = refresh_dir(root, au_sigen(sb));
 
665
 
 
666
                DiMustNoWaiters(root);
 
667
                IiMustNoWaiters(root->d_inode);
 
668
                di_write_unlock(root);
 
669
 
 
670
                rerr = refresh_dir(root, sigen);
516
671
                if (unlikely(rerr)) {
517
672
                        sbinfo->si_failed_refresh_dirs = 1;
518
 
                        Warn("Refreshing directories failed, ignores (%d)\n",
519
 
                             rerr);
520
 
                }
 
673
                        AuWarn("Refreshing directories failed, ignores (%d)\n",
 
674
                               rerr);
 
675
                }
 
676
 
 
677
                if (unlikely(opts.refresh_nondir)) {
 
678
                        //au_debug_on();
 
679
                        rerr = refresh_nondir(root, sigen, !rerr);
 
680
                        if (unlikely(rerr))
 
681
                                AuWarn("Refreshing non-directories failed,"
 
682
                                       " ignores (%d)\n", rerr);
 
683
                        //au_debug_off();
 
684
                }
 
685
 
 
686
                /* aufs_write_lock() calls ..._child() */
 
687
                di_write_lock_child(root);
 
688
 
521
689
                au_cpup_attr_all(inode);
522
 
                au_flag_set(sb, dlgt);
 
690
                AuFlagSet(sbinfo, f_dlgt, dlgt);
523
691
        }
524
692
 
525
693
        aufs_write_unlock(root);
526
 
        i_unlock(inode);
527
 
        if (do_refresh)
 
694
        vfsub_i_unlock(inode);
 
695
        if (opts.refresh_dir)
528
696
                sysaufs_notify_remount();
529
697
 
530
698
 out_opts:
531
699
        free_page((unsigned long)opts.opt);
532
700
 out:
533
701
        err = cvt_err(err);
534
 
        TraceErr(err);
 
702
        AuTraceErr(err);
535
703
        //au_debug_off();
536
704
        return err;
537
705
}
556
724
        //void (*write_super_lockfs) (struct super_block *);
557
725
        //void (*unlockfs) (struct super_block *);
558
726
        .remount_fs     = aufs_remount_fs,
559
 
        // depends upon umount flags. also use put_super() (< 2.6.18)
 
727
        /* depends upon umount flags. also use put_super() (< 2.6.18) */
560
728
        .umount_begin   = aufs_umount_begin
561
729
};
562
730
 
570
738
{
571
739
        struct aufs_sbinfo *sbinfo;
572
740
 
573
 
        TraceEnter();
 
741
        AuTraceEnter();
574
742
 
575
743
        sbinfo = kmalloc(sizeof(*sbinfo), GFP_KERNEL);
576
744
        //if (LktrCond) {kfree(sbinfo); sbinfo = NULL;}
583
751
 
584
752
        rw_init_wlock(&sbinfo->si_rwsem);
585
753
        sbinfo->si_generation = 0;
 
754
        //sbinfo->si_generation = INT_MAX - 2;
586
755
        sbinfo->si_failed_refresh_dirs = 0;
587
756
        sbinfo->si_bend = -1;
588
757
        sbinfo->si_last_br_id = 0;
589
 
        sbinfo->si_flags = AuDefFlags;
590
 
        atomic_long_set(&sbinfo->si_xino, AUFS_FIRST_INO);
591
 
#if 0
592
 
        sbinfo->si_wkq = create_workqueue(AUFS_WKQ_NAME);
593
 
        if (IS_ERR(sbinfo->si_wkq))
594
 
                goto out_branch;
595
 
#endif
596
 
#if 0
597
 
        atomic_set(&sbinfo->si_wkq_nowait, 0);
598
 
        init_waitqueue_head(&sbinfo->si_wkq_nowait_wq);
599
 
#endif
 
758
 
 
759
        sbinfo->si_wbr_copyup_ops = au_wbr_copyup_ops + AuWbrCopyup_TDP;
 
760
        sbinfo->si_wbr_create_ops = au_wbr_create_ops + AuWbrCreate_TDP;
 
761
 
 
762
        au_opts_flags_def(&sbinfo->au_si_flags);
 
763
 
 
764
        sbinfo->si_xread = NULL;
 
765
        sbinfo->si_xwrite = NULL;
 
766
        sbinfo->si_xib = NULL;
 
767
        mutex_init(&sbinfo->si_xib_mtx);
 
768
        sbinfo->si_xib_buf = NULL;
 
769
        /* leave si_xib_last_pindex and si_xib_next_bit */
 
770
 
 
771
        au_nwt_init(&sbinfo->si_nowait);
 
772
 
600
773
        sbinfo->si_rdcache = AUFS_RDCACHE_DEF * HZ;
601
774
        sbinfo->si_dirwh = AUFS_DIRWH_DEF;
 
775
 
602
776
        spin_lock_init(&sbinfo->si_plink_lock);
603
777
        INIT_LIST_HEAD(&sbinfo->si_plink);
 
778
 
 
779
        /* leave syaufs members, si_list, si_mnt and si_sysaufs. */
 
780
 
604
781
        init_lvma(sbinfo);
605
 
 
606
782
        sb->s_fs_info = sbinfo;
 
783
 
607
784
#ifdef ForceInotify
608
 
        udba_set(sb, AuFlag_UDBA_INOTIFY);
 
785
        AuFlagSet(sbinfo, f_udba, AuUdba_INOTIFY);
609
786
#endif
610
787
#ifdef ForceDlgt
611
 
        au_flag_set(sb, AuFlag_DLGT);
 
788
        AuFlagSet(sbinfo, f_dlgt, 1);
612
789
#endif
613
790
#ifdef ForceNoPlink
614
 
        au_flag_clr(sb, AuFlag_PLINK);
 
791
        AuFlagSet(sbinfo, f_plink, 0);
 
792
#endif
 
793
#ifdef ForceNoXino
 
794
        AuFlagSet(sbinfo, f_xino, AuXino_NONE);
 
795
#endif
 
796
#ifdef ForceNoRefrof
 
797
        AuFlagSet(sbinfo, f_refrof, 0);
615
798
#endif
616
799
        return 0; /* success */
617
800
 
618
 
        //out_branch:
 
801
// out_branch:
619
802
        kfree(sbinfo->si_branch);
620
803
 out_sbinfo:
621
804
        kfree(sbinfo);
622
805
 out:
623
 
        TraceErr(-ENOMEM);
 
806
        AuTraceErr(-ENOMEM);
624
807
        return -ENOMEM;
625
808
}
626
809
 
630
813
        struct inode *inode;
631
814
        struct dentry *root;
632
815
 
633
 
        TraceEnter();
 
816
        AuTraceEnter();
634
817
 
635
818
        err = -ENOMEM;
636
819
        inode = iget(sb, AUFS_ROOT_INO);
644
827
        if (unlikely(is_bad_inode(inode)))
645
828
                goto out_iput;
646
829
 
 
830
        inode->i_mode = S_IFDIR;
647
831
        root = d_alloc_root(inode);
648
832
        //if (LktrCond) {igrab(inode); dput(root); root = NULL;}
649
833
        if (unlikely(!root))
664
848
 out_iput:
665
849
        iput(inode);
666
850
 out:
667
 
        TraceErr(err);
 
851
        AuTraceErr(err);
668
852
        return err;
669
853
 
670
854
}
674
858
        int err;
675
859
        struct dentry *root;
676
860
        struct inode *inode;
677
 
        struct opts opts;
 
861
        struct au_opts opts;
678
862
        char *arg = raw_data;
679
863
 
680
864
        //au_debug_on();
681
865
        if (unlikely(!arg || !*arg)) {
682
866
                err = -EINVAL;
683
 
                Err("no arg\n");
 
867
                AuErr("no arg\n");
684
868
                goto out;
685
869
        }
686
870
        LKTRTrace("%s, silent %d\n", arg, silent);
687
871
 
688
872
        err = -ENOMEM;
689
873
        memset(&opts, 0, sizeof(opts));
690
 
        opts.opt = (void*)__get_free_page(GFP_KERNEL);
 
874
        opts.opt = (void *)__get_free_page(GFP_TEMPORARY);
691
875
        //if (LktrCond) {free_page((unsigned long)opts.opt); opts.opt = NULL;}
692
876
        if (unlikely(!opts.opt))
693
877
                goto out;
694
878
        opts.max_opt = PAGE_SIZE / sizeof(*opts.opt);
695
879
 
696
880
        err = alloc_sbinfo(sb);
697
 
        //if (LktrCond) {si_write_unlock(sb);free_sbinfo(stosi(sb));err=-1;}
 
881
        //if (LktrCond) {si_write_unlock(sb);free_sbinfo(sb);err=-1;}
698
882
        if (unlikely(err))
699
883
                goto out_opts;
700
884
        SiMustWriteLock(sb);
701
885
        /* all timestamps always follow the ones on the branch */
702
886
        sb->s_flags |= MS_NOATIME | MS_NODIRATIME;
703
887
        sb->s_op = &aufs_sop;
 
888
        sb->s_magic = AUFS_SUPER_MAGIC;
704
889
        au_init_export_op(sb);
705
890
 
706
891
        err = alloc_root(sb);
723
908
         */
724
909
        ii_write_lock_parent(inode);
725
910
        aufs_write_unlock(root);
726
 
        err = au_parse_opts(sb, arg, &opts);
727
 
        //if (LktrCond) {au_free_opts(&opts); err = -1;}
 
911
        err = au_opts_parse(sb, arg, &opts);
 
912
        //if (LktrCond) {au_opts_free(&opts); err = -1;}
728
913
        if (unlikely(err))
729
914
                goto out_root;
730
915
 
731
916
        /* lock vfs_inode first, then aufs. */
732
 
        i_lock(inode);
 
917
        vfsub_i_lock(inode);
733
918
        inode->i_op = &aufs_dir_iop;
734
919
        inode->i_fop = &aufs_dir_fop;
735
920
        aufs_write_lock(root);
736
921
 
737
922
        sb->s_maxbytes = 0;
738
 
        err = au_do_opts_mount(sb, &opts);
 
923
        err = au_opts_mount(sb, &opts);
739
924
        //if (LktrCond) err = -1;
740
 
        au_free_opts(&opts);
 
925
        au_opts_free(&opts);
741
926
        if (unlikely(err))
742
927
                goto out_unlock;
743
928
        AuDebugOn(!sb->s_maxbytes);
744
929
 
745
 
        //DbgDentry(root);
 
930
        //AuDbgDentry(root);
746
931
        aufs_write_unlock(root);
747
 
        i_unlock(inode);
748
 
        //DbgSb(sb);
 
932
        vfsub_i_unlock(inode);
 
933
        //AuDbgSb(sb);
749
934
        goto out_opts; /* success */
750
935
 
751
936
 out_unlock:
752
937
        aufs_write_unlock(root);
753
 
        i_unlock(inode);
 
938
        vfsub_i_unlock(inode);
754
939
 out_root:
755
940
        dput(root);
756
941
        sb->s_root = NULL;
757
942
 out_info:
758
 
        free_sbinfo(stosi(sb));
 
943
        free_sbinfo(sb);
759
944
        sb->s_fs_info = NULL;
760
945
 out_opts:
761
946
        free_page((unsigned long)opts.opt);
762
947
 out:
763
 
        TraceErr(err);
 
948
        AuTraceErr(err);
764
949
        err = cvt_err(err);
765
 
        TraceErr(err);
 
950
        AuTraceErr(err);
766
951
        //au_debug_off();
767
952
        return err;
768
953
}
769
954
 
770
955
/* ---------------------------------------------------------------------- */
771
956
 
772
 
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
 
957
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
773
958
static int aufs_get_sb(struct file_system_type *fs_type, int flags,
774
959
                       const char *dev_name, void *raw_data,
775
960
                       struct vfsmount *mnt)
777
962
        int err;
778
963
 
779
964
        /* all timestamps always follow the ones on the branch */
780
 
        //mnt->mnt_flags |= MNT_NOATIME | MNT_NODIRATIME;
 
965
        /* mnt->mnt_flags |= MNT_NOATIME | MNT_NODIRATIME; */
781
966
        err = get_sb_nodev(fs_type, flags, raw_data, aufs_fill_super, mnt);
782
967
        if (!err) {
783
968
                struct aufs_sbinfo *sbinfo = stosi(mnt->mnt_sb);
793
978
{
794
979
        return get_sb_nodev(fs_type, flags, raw_data, aufs_fill_super);
795
980
}
796
 
#endif
 
981
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18) */
797
982
 
798
983
struct file_system_type aufs_fs_type = {
799
984
        .name           = AUFS_FSTYPE,
800
 
        .fs_flags       = FS_REVAL_DOT, // for UDBA and NFS branch
 
985
        .fs_flags       = FS_REVAL_DOT, /* for UDBA and NFS branch */
801
986
        .get_sb         = aufs_get_sb,
802
987
        .kill_sb        = generic_shutdown_super,
803
 
        //no need to __module_get() and module_put().
 
988
        /* no need to __module_get() and module_put(). */
804
989
        .owner          = THIS_MODULE,
805
990
};