← Back to branch summary

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

« back to all changes in this revision

Viewing changes to fs/aufs/dcsub.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/dcsub.c
16
16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
17
 */
18
18
 
19
 
/* $Id: dcsub.c,v 1.5 2007/06/04 02:15:32 sfjro Exp $ */
 
19
/* $Id: dcsub.c,v 1.9 2007/10/22 02:14:17 sfjro Exp $ */
20
20
 
21
21
#include "aufs.h"
22
22
 
24
24
{
25
25
        int i;
26
26
 
27
 
        TraceEnter();
 
27
        AuTraceEnter();
28
28
        AuDebugOn(!dpage);
29
29
 
30
30
        for (i = 0; i < dpage->ndentry; i++)
37
37
        int err;
38
38
        void *p;
39
39
 
40
 
        TraceEnter();
 
40
        AuTraceEnter();
41
41
 
42
42
        err = -ENOMEM;
43
43
        dpages->dpages = kmalloc(sizeof(*dpages->dpages), gfp);
44
44
        if (unlikely(!dpages->dpages))
45
45
                goto out;
46
 
        p = (void*)__get_free_page(gfp);
 
46
        p = (void *)__get_free_page(gfp);
47
47
        if (unlikely(!p))
48
48
                goto out_dpages;
49
49
        dpages->dpages[0].ndentry = 0;
54
54
 out_dpages:
55
55
        kfree(dpages->dpages);
56
56
 out:
57
 
        TraceErr(err);
 
57
        AuTraceErr(err);
58
58
        return err;
59
59
}
60
60
 
62
62
{
63
63
        int i;
64
64
 
65
 
        TraceEnter();
 
65
        AuTraceEnter();
66
66
 
67
67
        for (i = 0; i < dpages->ndpage; i++)
68
68
                au_dpage_free(dpages->dpages + i);
76
76
        struct au_dpage *dpage;
77
77
        void *p;
78
78
 
79
 
        //TraceEnter();
 
79
        //AuTraceEnter();
80
80
 
81
81
        dpage = dpages->dpages + dpages->ndpage - 1;
82
82
        AuDebugOn(!dpage);
90
90
                if (unlikely(!p))
91
91
                        goto out;
92
92
                dpage = dpages->dpages + dpages->ndpage;
93
 
                p = (void*)__get_free_page(gfp);
 
93
                p = (void *)__get_free_page(gfp);
94
94
                if (unlikely(!p))
95
95
                        goto out;
96
96
                dpage->ndentry = 0;
102
102
        return 0; /* success */
103
103
 
104
104
 out:
105
 
        //TraceErr(err);
 
105
        //AuTraceErr(err);
106
106
        return err;
107
107
}
108
108
 
114
114
        struct list_head *next;
115
115
        struct super_block *sb = root->d_sb;
116
116
 
117
 
        TraceEnter();
 
117
        AuTraceEnter();
118
118
 
119
119
        err = 0;
120
120
        spin_lock(&dcache_lock);
152
152
 
153
153
        if (this_parent != root) {
154
154
                next = this_parent->D_CHILD.next;
155
 
                this_parent = this_parent->d_parent;
 
155
                this_parent = this_parent->d_parent; /* dcache_lock is locked */
156
156
                goto resume;
157
157
        }
158
158
 out:
159
159
        spin_unlock(&dcache_lock);
160
 
#if 0
 
160
#if 0 // debug
161
161
        if (!err) {
162
162
                int i, j;
163
163
                j = 0;
164
164
                for (i = 0; i < dpages->ndpage; i++) {
165
165
                        if ((dpages->dpages + i)->ndentry)
166
 
                                Dbg("%d: %d\n",
167
 
                                    i, (dpages->dpages + i)->ndentry);
 
166
                                AuDbg("%d: %d\n",
 
167
                                      i, (dpages->dpages + i)->ndentry);
168
168
                        j += (dpages->dpages + i)->ndentry;
169
169
                }
170
170
                if (j)
171
 
                        Dbg("ndpage %d, %d\n", dpages->ndpage, j);
 
171
                        AuDbg("ndpage %d, %d\n", dpages->ndpage, j);
172
172
        }
173
173
#endif
174
 
        TraceErr(err);
 
174
        AuTraceErr(err);
175
175
        return err;
176
176
}
177
177
 
180
180
{
181
181
        int err;
182
182
 
183
 
        TraceEnter();
 
183
        AuTraceEnter();
184
184
 
185
185
        err = 0;
186
186
        spin_lock(&dcache_lock);
190
190
                        goto out;
191
191
        }
192
192
        while (!IS_ROOT(dentry)) {
193
 
                dentry = dentry->d_parent;
 
193
                dentry = dentry->d_parent; /* dcache_lock is locked */
194
194
                if (!test || test(dentry, arg)) {
195
195
                        err = au_dpages_append(dpages, dentry, GFP_ATOMIC);
196
196
                        if (unlikely(err))
201
201
 out:
202
202
        spin_unlock(&dcache_lock);
203
203
 
204
 
        TraceErr(err);
 
204
        AuTraceErr(err);
205
205
        return err;
206
206
}
207
207
 
208
 
int au_is_subdir(struct dentry *d1, struct dentry *d2)
 
208
int au_test_subdir(struct dentry *d1, struct dentry *d2)
209
209
{
210
210
        int err;
211
 
#ifndef AuUse_ISSUBDIR
212
211
        int i, j;
213
212
        struct au_dcsub_pages dpages;
214
213
        struct au_dpage *dpage;
215
214
        struct dentry **dentries;
216
 
#endif
217
 
 
218
 
        LKTRTrace("%.*s, %.*s\n", DLNPair(d1), DLNPair(d2));
219
 
 
220
 
#ifdef AuUse_ISSUBDIR
221
 
        spin_lock(&dcache_lock);
222
 
        err = is_subdir(d1, d2);
223
 
        spin_unlock(&dcache_lock);
224
 
#else
225
 
        err = au_dpages_init(&dpages, GFP_KERNEL);
 
215
 
 
216
        LKTRTrace("%.*s, %.*s\n", AuDLNPair(d1), AuDLNPair(d2));
 
217
 
 
218
        err = au_dpages_init(&dpages, GFP_TEMPORARY);
226
219
        if (unlikely(err))
227
220
                goto out;
228
221
        err = au_dcsub_pages_rev(&dpages, d1, /*do_include*/1, NULL, NULL);
235
228
                for (j = dpage->ndentry - 1; !err && j >= 0; j--) {
236
229
                        struct dentry *d;
237
230
                        d = dentries[j];
238
 
                        //Dbg("d %.*s\n", DLNPair(d));
 
231
                        //AuDbg("d %.*s\n", AuDLNPair(d));
239
232
                        err = (d == d2);
240
233
                }
241
234
        }
243
236
 out_dpages:
244
237
        au_dpages_free(&dpages);
245
238
 out:
246
 
#endif
247
 
        TraceErr(err);
 
239
        AuTraceErr(err);
248
240
        return err;
249
241
}