← Back to branch summary

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

« back to all changes in this revision

Viewing changes to fs/aufs/inode.c

  • Committer: Bazaar Package Importer
  • Author(s): Julian Andres Klode
  • Date: 2008-05-06 18:35:50 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20080506183550-0b6c974kkgc46oeh
Tags: 0+20080506-1
http://bugs.debian.org/479717
http://bugs.debian.org/475042
* New upstream release, supports Kernel 2.6.25 (Closes: #479717)
* Fix building with older Kernels (Closes: #475042)
* Update the patches 01, 04 and 07 to also patch fs/aufs25

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/aufs/inode.c
1
1
/*
2
 
 * Copyright (C) 2005, 2006, 2007, 2008 Junjiro Okajima
 
2
 * Copyright (C) 2005-2008 Junjiro Okajima
3
3
 *
4
4
 * This program, aufs is free software; you can redistribute it and/or modify
5
5
 * it under the terms of the GNU General Public License as published by
16
16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
17
 */
18
18
 
19
 
/* $Id: inode.c,v 1.40 2008/03/24 02:17:32 sfjro Exp $ */
 
19
/*
 
20
 * inode functions
 
21
 *
 
22
 * $Id: inode.c,v 1.42 2008/04/13 23:43:10 sfjro Exp $
 
23
 */
20
24
 
21
25
#include "aufs.h"
22
26
 
24
28
{
25
29
        int err, new_sz, update;
26
30
        struct inode *first;
27
 
        struct aufs_hinode *p, *q, tmp;
 
31
        struct au_hinode *p, *q, tmp;
28
32
        struct super_block *sb;
29
 
        struct aufs_iinfo *iinfo;
 
33
        struct au_iinfo *iinfo;
30
34
        aufs_bindex_t bindex, bend, new_bindex;
31
35
 
32
36
        LKTRTrace("i%lu\n", inode->i_ino);
35
39
        err = -ENOMEM;
36
40
        update = 0;
37
41
        sb = inode->i_sb;
38
 
        bend = sbend(sb);
 
42
        bend = au_sbend(sb);
39
43
        new_sz = sizeof(*iinfo->ii_hinode) * (bend + 1);
40
 
        iinfo = itoii(inode);
 
44
        iinfo = au_ii(inode);
41
45
        p = au_kzrealloc(iinfo->ii_hinode, sizeof(*p) * (iinfo->ii_bend + 1),
42
46
                         new_sz, GFP_KERNEL);
43
47
        //p = NULL;
53
57
                if (!p->hi_inode)
54
58
                        continue;
55
59
 
56
 
                new_bindex = find_brindex(sb, p->hi_id);
 
60
                new_bindex = au_br_index(sb, p->hi_id);
57
61
                if (new_bindex == bindex)
58
62
                        continue;
59
63
                if (new_bindex < 0) {
60
64
                        update++;
61
 
                        aufs_hiput(p);
 
65
                        au_hiput(p);
62
66
                        p->hi_inode = NULL;
63
67
                        continue;
64
68
                }
97
101
{
98
102
        int err, update, isdir;
99
103
        struct inode *first;
100
 
        struct aufs_hinode *p;
 
104
        struct au_hinode *p;
101
105
        struct super_block *sb;
102
 
        struct aufs_iinfo *iinfo;
 
106
        struct au_iinfo *iinfo;
103
107
        aufs_bindex_t bindex, bend;
104
108
        unsigned int flags;
105
109
 
111
115
                goto out;
112
116
 
113
117
        sb = dentry->d_sb;
114
 
        bend = sbend(sb);
115
 
        iinfo = itoii(inode);
 
118
        bend = au_sbend(sb);
 
119
        iinfo = au_ii(inode);
116
120
        update = 0;
117
121
        p = iinfo->ii_hinode + iinfo->ii_bstart;
118
122
        first = p->hi_inode;
119
123
        isdir = S_ISDIR(inode->i_mode);
120
124
        flags = au_hi_flags(inode, isdir);
121
 
        bend = dbend(dentry);
122
 
        for (bindex = dbstart(dentry); bindex <= bend; bindex++) {
 
125
        bend = au_dbend(dentry);
 
126
        for (bindex = au_dbstart(dentry); bindex <= bend; bindex++) {
123
127
                struct inode *hi;
124
128
                struct dentry *hd;
125
129
 
140
144
                        iinfo->ii_bstart = bindex;
141
145
                if (iinfo->ii_bend < bindex)
142
146
                        iinfo->ii_bend = bindex;
143
 
                set_h_iptr(inode, bindex, igrab(hd->d_inode), flags);
 
147
                au_set_h_iptr(inode, bindex, igrab(hd->d_inode), flags);
144
148
                update++;
145
149
        }
146
150
        au_update_brange(inode, /*do_put_zero*/0);
166
170
        struct inode *h_inode;
167
171
        umode_t mode;
168
172
        aufs_bindex_t bindex, bstart, btail;
169
 
        struct aufs_iinfo *iinfo;
 
173
        struct au_iinfo *iinfo;
170
174
        unsigned int flags;
171
175
 
172
176
        LKTRTrace("i%lu, %.*s\n", inode->i_ino, AuDLNPair(dentry));
179
183
 
180
184
        err = 0;
181
185
        isdir = 0;
182
 
        bstart = dbstart(dentry);
 
186
        bstart = au_dbstart(dentry);
183
187
        mode = h_inode->i_mode;
184
188
        switch (mode & S_IFMT) {
185
189
        case S_IFREG:
186
 
                btail = dbtail(dentry);
 
190
                btail = au_dbtail(dentry);
187
191
                break;
188
192
        case S_IFDIR:
189
193
                isdir = 1;
190
 
                btail = dbtaildir(dentry);
 
194
                btail = au_dbtaildir(dentry);
191
195
                inode->i_op = &aufs_dir_iop;
192
196
                inode->i_fop = &aufs_dir_fop;
193
197
                break;
194
198
        case S_IFLNK:
195
 
                btail = dbtail(dentry);
 
199
                btail = au_dbtail(dentry);
196
200
                inode->i_op = &aufs_symlink_iop;
197
201
                break;
198
202
        case S_IFBLK:
199
203
        case S_IFCHR:
200
204
        case S_IFIFO:
201
205
        case S_IFSOCK:
202
 
                btail = dbtail(dentry);
 
206
                btail = au_dbtail(dentry);
203
207
                init_special_inode(inode, mode,
204
208
                                   au_h_rdev(h_inode, /*h_mnt*/NULL, h_dentry));
205
209
                break;
210
214
        }
211
215
 
212
216
        flags = au_hi_flags(inode, isdir);
213
 
        iinfo = itoii(inode);
 
217
        iinfo = au_ii(inode);
214
218
        iinfo->ii_bstart = bstart;
215
219
        iinfo->ii_bend = btail;
216
220
        for (bindex = bstart; bindex <= btail; bindex++) {
218
222
                if (!h_dentry)
219
223
                        continue;
220
224
                AuDebugOn(!h_dentry->d_inode);
221
 
                set_h_iptr(inode, bindex, igrab(h_dentry->d_inode), flags);
 
225
                au_set_h_iptr(inode, bindex, igrab(h_dentry->d_inode), flags);
222
226
        }
223
227
        au_cpup_attr_all(inode);
224
228
 
234
238
        int err;
235
239
        struct inode *h_inode, *h_dinode;
236
240
        aufs_bindex_t bindex, bend;
237
 
        //const int udba = au_flag_test_udba_inotify(inode->i_sb);
 
241
#if 0
 
242
        const int hinotify = au_opt_test(au_mntflags(inode->i_sb),
 
243
                                         UDBA_INOTIFY);
 
244
#endif
238
245
 
239
246
        LKTRTrace("i%lu, %.*s\n", inode->i_ino, AuDLNPair(dentry));
240
247
 
253
260
        h_dinode = au_h_dptr(dentry)->d_inode;
254
261
        vfsub_i_lock_nested(inode, AuLsc_I_CHILD);
255
262
        ii_write_lock_new(inode);
256
 
        bend = ibend(inode);
257
 
        for (bindex = ibstart(inode); bindex <= bend; bindex++) {
 
263
        bend = au_ibend(inode);
 
264
        for (bindex = au_ibstart(inode); bindex <= bend; bindex++) {
258
265
                h_inode = au_h_iptr_i(inode, bindex);
259
266
                if (h_inode && h_inode == h_dinode) {
260
267
                        //&& (ibs != bstart || !au_test_higen(inode, h_inode)));
284
291
        struct super_block *sb;
285
292
        int err, match;
286
293
        aufs_bindex_t bstart;
287
 
        struct xino_entry xinoe;
 
294
        struct au_xino_entry xinoe;
288
295
 
289
296
        LKTRTrace("%.*s\n", AuDLNPair(dentry));
290
297
        sb = dentry->d_sb;
293
300
        h_inode = h_dentry->d_inode;
294
301
        AuDebugOn(!h_inode);
295
302
 
296
 
        bstart = dbstart(dentry);
 
303
        bstart = au_dbstart(dentry);
297
304
        h_ino = h_inode->i_ino;
298
 
        err = xino_read(sb, bstart, h_ino, &xinoe);
 
305
        err = au_xino_read(sb, bstart, h_ino, &xinoe);
299
306
        //err = -1;
300
307
        inode = ERR_PTR(err);
301
308
        if (unlikely(err))
302
309
                goto out;
303
310
 new_ino:
304
311
        if (!xinoe.ino) {
305
 
                xinoe.ino = xino_new_ino(sb);
 
312
                xinoe.ino = au_xino_new_ino(sb);
306
313
                if (!xinoe.ino) {
307
314
                        inode = ERR_PTR(-EIO);
308
315
                        goto out;
364
371
        }
365
372
#endif
366
373
        xinoe.ino = 0;
367
 
        err = xino_write0(sb, bstart, h_ino, 0);
 
374
        err = au_xino_write0(sb, bstart, h_ino, 0);
368
375
        if (!err) {
369
376
                iput(inode);
370
377
                goto new_ino;
378
385
        AuTraceErrPtr(inode);
379
386
        return inode;
380
387
}
 
388
 
 
389
/* ---------------------------------------------------------------------- */
 
390
 
 
391
int au_test_ro(struct super_block *sb, aufs_bindex_t bindex,
 
392
               struct inode *inode)
 
393
{
 
394
        int err;
 
395
 
 
396
        err = au_br_rdonly(au_sbr(sb, bindex));
 
397
 
 
398
        /* pseudo-link after flushed may out of bounds */
 
399
        if (!err
 
400
            && inode
 
401
            && au_ibstart(inode) <= bindex
 
402
            && bindex <= au_ibend(inode)) {
 
403
                /*
 
404
                 * permission check is unnecessary since vfsub routine
 
405
                 * will be called later
 
406
                 */
 
407
                struct inode *hi = au_h_iptr_i(inode, bindex);
 
408
                if (hi)
 
409
                        err = IS_IMMUTABLE(hi) ? -EROFS : 0;
 
410
        }
 
411
 
 
412
        AuTraceErr(err);
 
413
        return err;
 
414
}
 
415
 
 
416
int au_test_h_perm(struct inode *h_inode, int mask, int dlgt)
 
417
{
 
418
        if (!current->fsuid)
 
419
                return 0;
 
420
        //todo: fake nameidata
 
421
        return vfsub_permission(h_inode, mask, NULL, dlgt);
 
422
}
 
423
 
 
424
int au_test_h_perm_sio(struct inode *h_inode, int mask, int dlgt)
 
425
{
 
426
        if (unlikely(au_test_nfs(h_inode->i_sb)
 
427
                     && (mask & MAY_WRITE)
 
428
                     && S_ISDIR(h_inode->i_mode)))
 
429
                mask |= MAY_READ; /* force permission check */
 
430
        return au_test_h_perm(h_inode, mask, dlgt);
 
431
}