← Back to branch summary

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

« back to all changes in this revision

Viewing changes to fs/aufs/vfsub.h

  • 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/vfsub.h
16
16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
17
 */
18
18
 
19
 
/* $Id: vfsub.h,v 1.9 2007/05/27 23:05:41 sfjro Exp $ */
 
19
/* $Id: vfsub.h,v 1.25 2007/11/12 01:43:10 sfjro Exp $ */
20
20
 
21
21
#ifndef __AUFS_VFSUB_H__
22
22
#define __AUFS_VFSUB_H__
24
24
#ifdef __KERNEL__
25
25
 
26
26
#include <linux/fs.h>
27
 
#include <asm/uaccess.h>
28
 
#include "wkq.h"
29
 
 
30
 
/* ---------------------------------------------------------------------- */
 
27
#include <linux/version.h>
 
28
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 23) \
 
29
        && defined(CONFIG_AUFS_SPLICE_PATCH)
 
30
#include <linux/splice.h>
 
31
#endif
 
32
#ifdef CONFIG_AUFS_HINOTIFY
 
33
#include <linux/inotify.h>
 
34
#endif
 
35
 
 
36
/* ---------------------------------------------------------------------- */
 
37
 
 
38
struct aufs_hin_ignore;
 
39
struct vfsub_args {
 
40
#ifdef CONFIG_AUFS_HINOTIFY
 
41
        /* inotify events to be ignored */
 
42
        int                     nignore;
 
43
        struct aufs_hin_ignore  *ignore;
 
44
#endif
 
45
 
 
46
        /* operation with delegation */
 
47
        unsigned int            dlgt:1;
 
48
 
 
49
        /* force unlinking */
 
50
        unsigned int            force_unlink:1;
 
51
};
 
52
 
 
53
struct aufs_hinode;
 
54
#ifdef CONFIG_AUFS_HINOTIFY
 
55
static inline
 
56
void do_vfsub_args_reinit(struct vfsub_args *vargs, struct aufs_hin_ignore *ign)
 
57
{
 
58
        vargs->nignore = 0;
 
59
        vargs->ignore = ign;
 
60
}
 
61
 
 
62
static inline
 
63
void vfsub_args_reinit(struct vfsub_args *vargs)
 
64
{
 
65
        vargs->nignore = 0;
 
66
}
 
67
 
 
68
__u32 vfsub_events_notify_change(struct iattr *ia);
 
69
void vfsub_ign_hinode(struct vfsub_args *vargs, __u32 events,
 
70
                      struct aufs_hinode *hinode);
 
71
void vfsub_ign_inode(struct vfsub_args *vargs, __u32 events,
 
72
                     struct inode *inode, struct inode *h_inode);
 
73
 
 
74
void vfsub_ignore(struct vfsub_args *vargs);
 
75
void vfsub_unignore(struct vfsub_args *vargs);
 
76
#else
 
77
static inline
 
78
void do_vfsub_args_reinit(struct vfsub_args *vargs, struct aufs_hin_ignore *ign)
 
79
{
 
80
        /* empty */
 
81
}
 
82
 
 
83
static inline
 
84
void vfsub_args_reinit(struct vfsub_args *vargs)
 
85
{
 
86
        /* empty */
 
87
}
 
88
 
 
89
static inline __u32 vfsub_events_notify_change(struct iattr *ia)
 
90
{
 
91
        return 0;
 
92
}
 
93
 
 
94
static inline
 
95
void vfsub_ign_hinode(struct vfsub_args *vargs, __u32 events,
 
96
                      struct aufs_hinode *hinode)
 
97
{
 
98
        /* empty */
 
99
}
 
100
 
 
101
static inline
 
102
void vfsub_ign_inode(struct vfsub_args *vargs, __u32 events,
 
103
                     struct inode *inode, struct inode *h_inode)
 
104
{
 
105
        /* empty */
 
106
}
 
107
 
 
108
static inline void vfsub_ignore(struct vfsub_args *vargs)
 
109
{
 
110
        /* empty */
 
111
}
 
112
 
 
113
static inline void vfsub_unignore(struct vfsub_args *vargs)
 
114
{
 
115
        /* empty */
 
116
}
 
117
#endif /* CONFIG_AUFS_HINOTIFY */
 
118
 
 
119
static inline
 
120
void vfsub_args_init(struct vfsub_args *vargs, struct aufs_hin_ignore *ign,
 
121
                     int dlgt, int force_unlink)
 
122
{
 
123
        do_vfsub_args_reinit(vargs, ign);
 
124
        vargs->dlgt = !!dlgt;
 
125
        vargs->force_unlink = !!force_unlink;
 
126
}
 
127
 
 
128
/* ---------------------------------------------------------------------- */
 
129
 
 
130
/* lock subclass for hidden inode */
 
131
/* default MAX_LOCKDEP_SUBCLASSES(8) is not enough */
 
132
// todo: reduce it
 
133
enum {
 
134
        AuLsc_I_Begin = I_MUTEX_QUOTA, /* 4 */
 
135
        AuLsc_I_PARENT,         /* hidden inode, parent first */
 
136
        AuLsc_I_CHILD,
 
137
        AuLsc_I_PARENT2,        /* copyup dirs */
 
138
        AuLsc_I_CHILD2,
 
139
        AuLsc_I_End
 
140
};
 
141
 
 
142
/* simple abstraction */
 
143
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
 
144
static inline void vfsub_i_lock(struct inode *i)
 
145
{
 
146
        down(&i->i_sem);
 
147
}
 
148
 
 
149
static inline void vfsub_i_lock_nested(struct inode *i, unsigned lsc)
 
150
{
 
151
        vfsub_i_lock(i);
 
152
}
 
153
 
 
154
static inline void vfsub_i_unlock(struct inode *i)
 
155
{
 
156
        up(&i->i_sem);
 
157
}
 
158
 
 
159
static inline int vfsub_i_trylock(struct inode *i)
 
160
{
 
161
        return down_trylock(&i->i_sem);
 
162
}
 
163
 
 
164
#define IMustLock(i)    AuDebugOn(!down_trylock(&(i)->i_sem))
 
165
#else
 
166
static inline void vfsub_i_lock(struct inode *i)
 
167
{
 
168
        mutex_lock(&i->i_mutex);
 
169
}
 
170
 
 
171
static inline void vfsub_i_lock_nested(struct inode *i, unsigned lsc)
 
172
{
 
173
        mutex_lock_nested(&i->i_mutex, lsc);
 
174
}
 
175
 
 
176
static inline void vfsub_i_unlock(struct inode *i)
 
177
{
 
178
        mutex_unlock(&i->i_mutex);
 
179
}
 
180
 
 
181
static inline int vfsub_i_trylock(struct inode *i)
 
182
{
 
183
        return mutex_trylock(&i->i_mutex);
 
184
}
 
185
 
 
186
#define IMustLock(i)    MtxMustLock(&(i)->i_mutex)
 
187
#endif /* LINUX_VERSION_CODE */
 
188
 
 
189
static inline
 
190
struct dentry *vfsub_lock_rename(struct dentry *d1, struct dentry *d2)
 
191
{
 
192
        struct dentry *d;
 
193
 
 
194
        lockdep_off();
 
195
        d = lock_rename(d1, d2);
 
196
        lockdep_on();
 
197
        return d;
 
198
}
 
199
 
 
200
static inline void vfsub_unlock_rename(struct dentry *d1, struct dentry *d2)
 
201
{
 
202
        lockdep_off();
 
203
        unlock_rename(d1, d2);
 
204
        lockdep_on();
 
205
}
 
206
 
 
207
/* ---------------------------------------------------------------------- */
 
208
 
 
209
#ifdef CONFIG_AUFS_WORKAROUND_FUSE
 
210
int au_update_fuse_h_inode(struct vfsmount *h_mnt, struct dentry *h_dentry);
 
211
#else
 
212
static inline
 
213
int au_update_fuse_h_inode(struct vfsmount *h_mnt, struct dentry *h_dentry)
 
214
{
 
215
        return 0;
 
216
}
 
217
#endif
31
218
 
32
219
/* simple abstractions, for future use */
33
220
static inline
34
221
int do_vfsub_permission(struct inode *inode, int mask, struct nameidata *nd)
35
222
{
36
 
        LKTRTrace("i%lu, mask 0x%x, nd %p\n", inode->i_ino, mask, nd);
37
 
#if 0
38
 
#else
 
223
        LKTRTrace("i%lu, mask 0x%x, nd %d\n", inode->i_ino, mask, !!nd);
 
224
        IMustLock(inode);
39
225
        return permission(inode, mask, nd);
40
 
#endif
41
226
}
42
227
 
43
228
static inline
50
235
        lockdep_off();
51
236
        err = filp_open(path, oflags, mode);
52
237
        lockdep_on();
 
238
        if (!IS_ERR(err))
 
239
                au_update_fuse_h_inode(err->f_vfsmnt, err->f_dentry); /*ignore*/
53
240
        return err;
54
241
}
55
242
 
61
248
 
62
249
        LKTRTrace("%s\n", name);
63
250
 
64
 
        //lockdep_off();
 
251
        /* lockdep_off(); */
65
252
        err = path_lookup(name, flags, nd);
66
 
        //lockdep_on();
67
 
        return err;
68
 
}
 
253
        /* lockdep_on(); */
 
254
        if (!err)
 
255
                au_update_fuse_h_inode(nd->mnt, nd->dentry); /*ignore*/
 
256
        return err;
 
257
}
 
258
 
 
259
static inline
 
260
struct dentry *vfsub_lookup_one_len(const char *name, struct dentry *parent,
 
261
                                    int len)
 
262
{
 
263
        struct dentry *d;
 
264
 
 
265
        LKTRTrace("%.*s/%.*s\n", AuDLNPair(parent), len, name);
 
266
        IMustLock(parent->d_inode);
 
267
 
 
268
        d = lookup_one_len(name, parent, len);
 
269
        if (!IS_ERR(d))
 
270
                au_update_fuse_h_inode(NULL, d); /*ignore*/
 
271
        return d;
 
272
}
 
273
 
 
274
#ifdef CONFIG_AUFS_LHASH_PATCH
 
275
static inline
 
276
struct dentry *vfsub__lookup_hash(struct qstr *name, struct dentry *parent,
 
277
                                  struct nameidata *nd)
 
278
{
 
279
        struct dentry *d;
 
280
 
 
281
        LKTRTrace("%.*s/%.*s, nd %d\n",
 
282
                  AuDLNPair(parent), AuLNPair(name), !!nd);
 
283
        IMustLock(parent->d_inode);
 
284
 
 
285
        d = __lookup_hash(name, parent, nd);
 
286
        if (!IS_ERR(d))
 
287
                au_update_fuse_h_inode(NULL, d); /*ignore*/
 
288
        return d;
 
289
}
 
290
#endif
 
291
 
 
292
/* because of the internal lock, never use vfs_path_lookup() */
 
293
#if 0 //LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 23)
 
294
static inline
 
295
int vfsub_vfs_path_lookup(struct dentry *parent, struct vfsmount *mnt,
 
296
                          char *name, unsigned int flags, struct nameidata *nd)
 
297
{
 
298
        int err;
 
299
 
 
300
        LKTRTrace("%.*s/%s, 0x%x, nd{}\n", AuDLNPair(parent), name, flags);
 
301
 
 
302
        /* vfs_path_lookup() will lock the parent inode */
 
303
        lockdep_off();
 
304
        err = vfs_path_lookup(parent, mnt, name, flags, nd);
 
305
        lockdep_on();
 
306
        if (!err)
 
307
                au_update_fuse_h_inode(mnt, nd->dentry); /*ignore*/
 
308
 
 
309
        AuTraceErr(err);
 
310
        return err;
 
311
}
 
312
#endif
69
313
 
70
314
/* ---------------------------------------------------------------------- */
71
315
 
73
317
int do_vfsub_create(struct inode *dir, struct dentry *dentry, int mode,
74
318
                    struct nameidata *nd)
75
319
{
76
 
        LKTRTrace("i%lu, %.*s, 0x%x\n", dir->i_ino, DLNPair(dentry), mode);
77
 
#if 0
78
 
#else
79
 
        return vfs_create(dir, dentry, mode, nd);
80
 
#endif
 
320
        int err;
 
321
        struct vfsmount *mnt;
 
322
 
 
323
        LKTRTrace("i%lu, %.*s, 0x%x\n", dir->i_ino, AuDLNPair(dentry), mode);
 
324
        IMustLock(dir);
 
325
 
 
326
        err = vfs_create(dir, dentry, mode, nd);
 
327
        if (!err) {
 
328
                mnt = NULL;
 
329
                if (nd)
 
330
                        mnt = nd->mnt;
 
331
                /* dir inode is locked */
 
332
                au_update_fuse_h_inode(mnt, dentry->d_parent); /*ignore*/
 
333
                au_update_fuse_h_inode(mnt, dentry); /*ignore*/
 
334
        }
 
335
        return err;
81
336
}
82
337
 
83
338
static inline
84
339
int do_vfsub_symlink(struct inode *dir, struct dentry *dentry,
85
340
                     const char *symname, int mode)
86
341
{
 
342
        int err;
 
343
 
87
344
        LKTRTrace("i%lu, %.*s, %s, 0x%x\n",
88
 
                  dir->i_ino, DLNPair(dentry), symname, mode);
89
 
#if 0//def CONFIG_VSERVER
90
 
        return vfs_symlink(dir, dentry, symname, mode, NULL);
91
 
#else
92
 
        return vfs_symlink(dir, dentry, NULL, symname, mode);
93
 
#endif
 
345
                  dir->i_ino, AuDLNPair(dentry), symname, mode);
 
346
        IMustLock(dir);
 
347
 
 
348
        err = vfs_symlink(dir, dentry, symname, mode);
 
349
        if (!err) {
 
350
                /* dir inode is locked */
 
351
                au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/
 
352
                au_update_fuse_h_inode(NULL, dentry); /*ignore*/
 
353
        }
 
354
        return err;
94
355
}
95
356
 
96
357
static inline
97
358
int do_vfsub_mknod(struct inode *dir, struct dentry *dentry, int mode,
98
359
                   dev_t dev)
99
360
{
100
 
        LKTRTrace("i%lu, %.*s, 0x%x\n", dir->i_ino, DLNPair(dentry), mode);
101
 
#if 0//def CONFIG_VSERVER
102
 
        return vfs_mknod(dir, dentry, mode, dev, NULL);
103
 
#else
104
 
        return vfs_mknod(dir, dentry, NULL, mode, dev);
105
 
#endif
 
361
        int err;
 
362
 
 
363
        LKTRTrace("i%lu, %.*s, 0x%x\n", dir->i_ino, AuDLNPair(dentry), mode);
 
364
        IMustLock(dir);
 
365
 
 
366
        err = vfs_mknod(dir, dentry, mode, dev);
 
367
        if (!err) {
 
368
                /* dir inode is locked */
 
369
                au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/
 
370
                au_update_fuse_h_inode(NULL, dentry); /*ignore*/
 
371
        }
 
372
        return err;
106
373
}
107
374
 
108
375
static inline
112
379
        int err;
113
380
 
114
381
        LKTRTrace("%.*s, i%lu, %.*s\n",
115
 
                  DLNPair(src_dentry), dir->i_ino, DLNPair(dentry));
 
382
                  AuDLNPair(src_dentry), dir->i_ino, AuDLNPair(dentry));
 
383
        IMustLock(dir);
116
384
 
117
385
        lockdep_off();
118
 
#if 0//def CONFIG_VSERVER
119
 
        err = vfs_link(src_dentry, dir, dentry, NULL);
120
 
#else
121
 
        err = vfs_link(src_dentry, NULL, dir, dentry, NULL);
122
 
#endif
 
386
        err = vfs_link(src_dentry, dir, dentry);
123
387
        lockdep_on();
 
388
        if (!err) {
 
389
                LKTRTrace("src_i %p, dst_i %p\n",
 
390
                          src_dentry->d_inode, dentry->d_inode);
 
391
                /* fuse has different memory inode for the same inumber */
 
392
                au_update_fuse_h_inode(NULL, src_dentry); /*ignore*/
 
393
                /* dir inode is locked */
 
394
                au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/
 
395
                au_update_fuse_h_inode(NULL, dentry); /*ignore*/
 
396
        }
124
397
        return err;
125
398
}
126
399
 
131
404
        int err;
132
405
 
133
406
        LKTRTrace("i%lu, %.*s, i%lu, %.*s\n",
134
 
                  src_dir->i_ino, DLNPair(src_dentry),
135
 
                  dir->i_ino, DLNPair(dentry));
 
407
                  src_dir->i_ino, AuDLNPair(src_dentry),
 
408
                  dir->i_ino, AuDLNPair(dentry));
 
409
        IMustLock(dir);
 
410
        IMustLock(src_dir);
136
411
 
137
412
        lockdep_off();
138
 
#if 0
139
 
#else
140
 
        err = vfs_rename(src_dir, src_dentry, NULL, dir, dentry, NULL);
141
 
#endif
 
413
        err = vfs_rename(src_dir, src_dentry, dir, dentry);
142
414
        lockdep_on();
 
415
        if (!err) {
 
416
                /* dir inode is locked */
 
417
                au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/
 
418
                au_update_fuse_h_inode(NULL, src_dentry->d_parent); /*ignore*/
 
419
                au_update_fuse_h_inode(NULL, src_dentry); /*ignore*/
 
420
        }
143
421
        return err;
144
422
}
145
423
 
146
424
static inline
147
425
int do_vfsub_mkdir(struct inode *dir, struct dentry *dentry, int mode)
148
426
{
149
 
        LKTRTrace("i%lu, %.*s, 0x%x\n", dir->i_ino, DLNPair(dentry), mode);
150
 
#if 0//def CONFIG_VSERVER
151
 
        return vfs_mkdir(dir, dentry, mode, NULL);
152
 
#else
153
 
        return vfs_mkdir(dir, dentry, NULL, mode);
154
 
#endif
 
427
        int err;
 
428
 
 
429
        LKTRTrace("i%lu, %.*s, 0x%x\n", dir->i_ino, AuDLNPair(dentry), mode);
 
430
        IMustLock(dir);
 
431
 
 
432
        err = vfs_mkdir(dir, dentry, mode);
 
433
        if (!err) {
 
434
                /* dir inode is locked */
 
435
                au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/
 
436
                au_update_fuse_h_inode(NULL, dentry); /*ignore*/
 
437
        }
 
438
        return err;
155
439
}
156
440
 
157
441
static inline int do_vfsub_rmdir(struct inode *dir, struct dentry *dentry)
158
442
{
159
443
        int err;
160
444
 
161
 
        LKTRTrace("i%lu, %.*s\n", dir->i_ino, DLNPair(dentry));
 
445
        LKTRTrace("i%lu, %.*s\n", dir->i_ino, AuDLNPair(dentry));
 
446
        IMustLock(dir);
162
447
 
163
448
        lockdep_off();
164
 
#if 0//def CONFIG_VSERVER
165
 
        err = vfs_rmdir(dir, dentry, NULL);
166
 
#else
167
 
        err = vfs_rmdir(dir, dentry, NULL);
168
 
#endif
 
449
        err = vfs_rmdir(dir, dentry);
169
450
        lockdep_on();
 
451
        /* dir inode is locked */
 
452
        if (!err)
 
453
                au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/
170
454
        return err;
171
455
}
172
456
 
174
458
{
175
459
        int err;
176
460
 
177
 
        LKTRTrace("i%lu, %.*s\n", dir->i_ino, DLNPair(dentry));
 
461
        LKTRTrace("i%lu, %.*s\n", dir->i_ino, AuDLNPair(dentry));
 
462
        IMustLock(dir);
178
463
 
 
464
        /* vfs_unlink() locks inode */
179
465
        lockdep_off();
180
 
#if 0//def CONFIG_VSERVER
181
 
        err = vfs_unlink(dir, dentry, NULL);
182
 
#else
183
 
        err = vfs_unlink(dir, dentry, NULL);
184
 
#endif
 
466
        err = vfs_unlink(dir, dentry);
185
467
        lockdep_on();
 
468
        /* dir inode is locked */
 
469
        if (!err)
 
470
                au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/
186
471
        return err;
187
472
}
188
473
 
195
480
        ssize_t err;
196
481
 
197
482
        LKTRTrace("%.*s, cnt %lu, pos %Ld\n",
198
 
                  DLNPair(file->f_dentry), (unsigned long)count, *ppos);
 
483
                  AuDLNPair(file->f_dentry), (unsigned long)count, *ppos);
199
484
 
200
 
        /* nfs uses some locks */
201
 
        lockdep_off();
202
 
#if 0
203
 
#else
204
 
        err = vfs_read(file, ubuf, count, ppos);
205
 
#endif
206
 
        lockdep_on();
 
485
        if (0 /*!au_test_nfs(file->f_vfsmnt->mnt_sb)*/)
 
486
                err = vfs_read(file, ubuf, count, ppos);
 
487
        else {
 
488
                lockdep_off();
 
489
                err = vfs_read(file, ubuf, count, ppos);
 
490
                lockdep_on();
 
491
        }
 
492
        if (err >= 0)
 
493
                au_update_fuse_h_inode(file->f_vfsmnt, file->f_dentry);
 
494
        /*ignore*/
207
495
        return err;
208
496
}
209
497
 
217
505
 
218
506
        oldfs = get_fs();
219
507
        set_fs(KERNEL_DS);
220
 
        err = do_vfsub_read_u(file, (char __user*)kbuf, count, ppos);
 
508
        err = do_vfsub_read_u(file, (char __user *)kbuf, count, ppos);
221
509
        set_fs(oldfs);
222
510
        return err;
223
511
}
229
517
        ssize_t err;
230
518
 
231
519
        LKTRTrace("%.*s, cnt %lu, pos %Ld\n",
232
 
                  DLNPair(file->f_dentry), (unsigned long)count, *ppos);
 
520
                  AuDLNPair(file->f_dentry), (unsigned long)count, *ppos);
233
521
 
234
522
        lockdep_off();
235
 
#if 0
236
 
#else
237
523
        err = vfs_write(file, ubuf, count, ppos);
238
 
#endif
239
524
        lockdep_on();
 
525
        if (err >= 0)
 
526
                au_update_fuse_h_inode(file->f_vfsmnt, file->f_dentry);
 
527
        /*ignore*/
240
528
        return err;
241
529
}
242
530
 
249
537
 
250
538
        oldfs = get_fs();
251
539
        set_fs(KERNEL_DS);
252
 
        err = do_vfsub_write_u(file, (const char __user*)kbuf, count, ppos);
 
540
        err = do_vfsub_write_u(file, (const char __user *)kbuf, count, ppos);
253
541
        set_fs(oldfs);
254
542
        return err;
255
543
}
259
547
{
260
548
        int err;
261
549
 
262
 
        LKTRTrace("%.*s\n", DLNPair(file->f_dentry));
 
550
        LKTRTrace("%.*s\n", AuDLNPair(file->f_dentry));
263
551
 
264
552
        lockdep_off();
265
 
#if 0
266
 
#else
267
553
        err = vfs_readdir(file, filldir, arg);
268
 
#endif
269
 
        lockdep_on();
270
 
        return err;
271
 
}
 
554
        lockdep_on();
 
555
        if (err >= 0)
 
556
                au_update_fuse_h_inode(file->f_vfsmnt, file->f_dentry);
 
557
        /*ignore*/
 
558
        return err;
 
559
}
 
560
 
 
561
/* ---------------------------------------------------------------------- */
 
562
 
 
563
#ifdef CONFIG_AUFS_SPLICE_PATCH
 
564
static inline
 
565
long do_vfsub_splice_to(struct file *in, loff_t *ppos,
 
566
                        struct pipe_inode_info *pipe, size_t len,
 
567
                        unsigned int flags)
 
568
{
 
569
        long err;
 
570
 
 
571
        LKTRTrace("%.*s, pos %Ld, len %lu, 0x%x\n",
 
572
                  AuDLNPair(in->f_dentry), *ppos, (unsigned long)len, flags);
 
573
 
 
574
        lockdep_off();
 
575
        err = do_splice_to(in, ppos, pipe, len, flags);
 
576
        lockdep_on();
 
577
        if (err >= 0)
 
578
                au_update_fuse_h_inode(in->f_vfsmnt, in->f_dentry); /*ignore*/
 
579
        return err;
 
580
}
 
581
 
 
582
static inline
 
583
long do_vfsub_splice_from(struct pipe_inode_info *pipe, struct file *out,
 
584
                          loff_t *ppos, size_t len, unsigned int flags)
 
585
{
 
586
        long err;
 
587
 
 
588
        LKTRTrace("%.*s, pos %Ld, len %lu, 0x%x\n",
 
589
                  AuDLNPair(out->f_dentry), *ppos, (unsigned long)len, flags);
 
590
 
 
591
        lockdep_off();
 
592
        err = do_splice_from(pipe, out, ppos, len, flags);
 
593
        lockdep_on();
 
594
        if (err >= 0)
 
595
                au_update_fuse_h_inode(out->f_vfsmnt, out->f_dentry); /*ignore*/
 
596
        return err;
 
597
}
 
598
#else
 
599
static inline
 
600
long do_vfsub_splice_to(struct file *in, loff_t *ppos,
 
601
                        struct pipe_inode_info *pipe, size_t len,
 
602
                        unsigned int flags)
 
603
{
 
604
        return -ENOSYS;
 
605
}
 
606
 
 
607
static inline
 
608
long do_vfsub_splice_from(struct pipe_inode_info *pipe, struct file *out,
 
609
                          loff_t *ppos, size_t len, unsigned int flags)
 
610
{
 
611
        return -ENOSYS;
 
612
}
 
613
#endif /* CONFIG_AUFS_SPLICE_PATCH */
272
614
 
273
615
/* ---------------------------------------------------------------------- */
274
616
 
276
618
{
277
619
        loff_t err;
278
620
 
279
 
        LKTRTrace("%.*s\n", DLNPair(file->f_dentry));
 
621
        LKTRTrace("%.*s\n", AuDLNPair(file->f_dentry));
280
622
 
281
623
        lockdep_off();
282
 
#if 0
283
 
#else
284
624
        err = vfs_llseek(file, offset, origin);
285
 
#endif
286
625
        lockdep_on();
287
626
        return err;
288
627
}
289
628
 
 
629
static inline int do_vfsub_getattr(struct vfsmount *mnt, struct dentry *dentry,
 
630
                                   struct kstat *st)
 
631
{
 
632
        LKTRTrace("%.*s\n", AuDLNPair(dentry));
 
633
        return vfs_getattr(mnt, dentry, st);
 
634
}
 
635
 
290
636
/* ---------------------------------------------------------------------- */
291
637
 
292
 
#ifdef CONFIG_AUFS_DLGT
293
 
static inline int need_dlgt(struct super_block *sb)
294
 
{
295
 
        return (au_flag_test(sb, AuFlag_DLGT) && !is_au_wkq(current));
296
 
}
297
 
 
 
638
#if defined(CONFIG_AUFS_DLGT) || defined(CONFIG_AUFS_HINOTIFY)
298
639
int vfsub_permission(struct inode *inode, int mask, struct nameidata *nd,
299
640
                     int dlgt);
300
641
 
307
648
int vfsub_link(struct dentry *src_dentry, struct inode *dir,
308
649
               struct dentry *dentry, int dlgt);
309
650
int vfsub_rename(struct inode *src_dir, struct dentry *src_dentry,
310
 
                 struct inode *dir, struct dentry *dentry, int dlgt);
 
651
                 struct inode *dir, struct dentry *dentry,
 
652
                 struct vfsub_args *vargs);
311
653
int vfsub_mkdir(struct inode *dir, struct dentry *dentry, int mode, int dlgt);
312
 
int vfsub_rmdir(struct inode *dir, struct dentry *dentry, int dlgt);
 
654
int vfsub_rmdir(struct inode *dir, struct dentry *dentry,
 
655
                struct vfsub_args *vargs);
313
656
 
314
657
ssize_t vfsub_read_u(struct file *file, char __user *ubuf, size_t count,
315
658
                     loff_t *ppos, int dlgt);
316
659
ssize_t vfsub_read_k(struct file *file, void *kbuf, size_t count, loff_t *ppos,
317
660
                     int dlgt);
318
661
ssize_t vfsub_write_u(struct file *file, const char __user *ubuf, size_t count,
319
 
                      loff_t *ppos, int dlgt);
 
662
                      loff_t *ppos, struct vfsub_args *vargs);
320
663
ssize_t vfsub_write_k(struct file *file, void *kbuf, size_t count, loff_t *ppos,
321
 
                      int dlgt);
 
664
                      struct vfsub_args *vargs);
322
665
int vfsub_readdir(struct file *file, filldir_t filldir, void *arg, int dlgt);
 
666
long vfsub_splice_to(struct file *in, loff_t *ppos,
 
667
                     struct pipe_inode_info *pipe, size_t len,
 
668
                     unsigned int flags, int dlgt);
 
669
long vfsub_splice_from(struct pipe_inode_info *pipe, struct file *out,
 
670
                       loff_t *ppos, size_t len, unsigned int flags,
 
671
                       struct vfsub_args *vargs);
323
672
 
 
673
int vfsub_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *st,
 
674
                  int dlgt);
324
675
#else
325
676
 
326
 
static inline int need_dlgt(struct super_block *sb)
327
 
{
328
 
        return 0;
329
 
}
330
 
 
331
677
static inline
332
678
int vfsub_permission(struct inode *inode, int mask, struct nameidata *nd,
333
679
                     int dlgt)
365
711
 
366
712
static inline
367
713
int vfsub_rename(struct inode *src_dir, struct dentry *src_dentry,
368
 
                 struct inode *dir, struct dentry *dentry, int dlgt)
 
714
                 struct inode *dir, struct dentry *dentry,
 
715
                 struct vfsub_args *vargs)
369
716
{
370
 
        return do_vfsub_rename(src_dir, src_dentry, dir, dentry);
 
717
        int err;
 
718
 
 
719
        vfsub_ignore(vargs);
 
720
        err = do_vfsub_rename(src_dir, src_dentry, dir, dentry);
 
721
        if (unlikely(err))
 
722
                vfsub_unignore(vargs);
 
723
        return err;
371
724
}
372
725
 
373
726
static inline
374
 
int vfsub_mkdir(struct inode *dir, struct dentry *dentry, int mode,
375
 
                int dlgt)
 
727
int vfsub_mkdir(struct inode *dir, struct dentry *dentry, int mode, int dlgt)
376
728
{
377
729
        return do_vfsub_mkdir(dir, dentry, mode);
378
730
}
379
731
 
380
732
static inline
381
 
int vfsub_rmdir(struct inode *dir, struct dentry *dentry, int dlgt)
 
733
int vfsub_rmdir(struct inode *dir, struct dentry *dentry,
 
734
                struct vfsub_args *vargs)
382
735
{
383
 
        return do_vfsub_rmdir(dir, dentry);
 
736
        int err;
 
737
 
 
738
        vfsub_ignore(vargs);
 
739
        err = do_vfsub_rmdir(dir, dentry);
 
740
        if (unlikely(err))
 
741
                vfsub_unignore(vargs);
 
742
        return err;
384
743
}
385
744
 
386
745
static inline
399
758
 
400
759
static inline
401
760
ssize_t vfsub_write_u(struct file *file, const char __user *ubuf, size_t count,
402
 
                      loff_t *ppos, int dlgt)
 
761
                      loff_t *ppos, struct vfsub_args *vargs)
403
762
{
404
 
        return do_vfsub_write_u(file, ubuf, count, ppos);
 
763
        int err;
 
764
 
 
765
        vfsub_ignore(vargs);
 
766
        err = do_vfsub_write_u(file, ubuf, count, ppos);
 
767
        if (unlikely(err < 0))
 
768
                vfsub_unignore(vargs);
 
769
        return err;
405
770
}
406
771
 
407
772
static inline
408
773
ssize_t vfsub_write_k(struct file *file, void *kbuf, size_t count, loff_t *ppos,
409
 
                      int dlgt)
 
774
                      struct vfsub_args *vargs)
410
775
{
411
 
        return do_vfsub_write_k(file, kbuf, count, ppos);
 
776
        int err;
 
777
 
 
778
        vfsub_ignore(vargs);
 
779
        err = do_vfsub_write_k(file, kbuf, count, ppos);
 
780
        if (unlikely(err < 0))
 
781
                vfsub_unignore(vargs);
 
782
        return err;
412
783
}
413
784
 
414
785
static inline
416
787
{
417
788
        return do_vfsub_readdir(file, filldir, arg);
418
789
}
419
 
#endif /* CONFIG_AUFS_DLGT */
420
 
 
421
 
/* ---------------------------------------------------------------------- */
422
 
 
423
 
static inline
424
 
struct dentry *vfsub_lock_rename(struct dentry *d1, struct dentry *d2)
425
 
{
426
 
        struct dentry *d;
427
 
 
428
 
        lockdep_off();
429
 
        d = lock_rename(d1, d2);
430
 
        lockdep_on();
431
 
        return d;
432
 
}
433
 
 
434
 
static inline void vfsub_unlock_rename(struct dentry *d1, struct dentry *d2)
435
 
{
436
 
        lockdep_off();
437
 
        unlock_rename(d1, d2);
438
 
        lockdep_on();
439
 
}
440
 
 
441
 
/* ---------------------------------------------------------------------- */
442
 
 
443
 
int vfsub_notify_change(struct dentry *dentry, struct iattr *ia, int dlgt);
444
 
int vfsub_unlink(struct inode *dir, struct dentry *dentry, int dlgt);
 
790
 
 
791
static inline
 
792
long vfsub_splice_to(struct file *in, loff_t *ppos,
 
793
                     struct pipe_inode_info *pipe, size_t len,
 
794
                     unsigned int flags, int dlgt)
 
795
{
 
796
        return do_vfsub_splice_to(in, ppos, pipe, len, flags);
 
797
}
 
798
 
 
799
static inline
 
800
long vfsub_splice_from(struct pipe_inode_info *pipe, struct file *out,
 
801
                       loff_t *ppos, size_t len, unsigned int flags,
 
802
                       struct vfsub_args *vargs)
 
803
{
 
804
        long err;
 
805
 
 
806
        vfsub_ignore(vargs);
 
807
        err = do_vfsub_splice_from(pipe, out, ppos, len, flags);
 
808
        if (unlikely(err < 0))
 
809
                vfsub_unignore(vargs);
 
810
        return err;
 
811
}
 
812
 
 
813
static inline int vfsub_getattr(struct vfsmount *mnt, struct dentry *dentry,
 
814
                                struct kstat *st, int dlgt)
 
815
{
 
816
        return do_vfsub_getattr(mnt, dentry, st);
 
817
}
 
818
#endif /* CONFIG_AUFS_DLGT || CONFIG_AUFS_HINOTIFY */
 
819
 
 
820
/* ---------------------------------------------------------------------- */
 
821
 
 
822
int vfsub_sio_mkdir(struct inode *dir, struct dentry *dentry, int mode,
 
823
                    int dlgt);
 
824
int vfsub_sio_rmdir(struct inode *dir, struct dentry *dentry, int dlgt);
 
825
 
 
826
/* ---------------------------------------------------------------------- */
 
827
 
 
828
int vfsub_notify_change(struct dentry *dentry, struct iattr *ia,
 
829
                        struct vfsub_args *vargs);
 
830
int vfsub_unlink(struct inode *dir, struct dentry *dentry,
 
831
                 struct vfsub_args *vargs);
445
832
int vfsub_statfs(void *arg, struct kstatfs *buf, int dlgt);
446
833
 
447
834
#endif /* __KERNEL__ */