← Back to branch summary

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

« back to all changes in this revision

Viewing changes to fs/aufs/misc.h

  • 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/misc.h
17
17
 */
18
18
 
19
19
/*
20
 
 * $Id: misc.h,v 1.42 2008/03/31 07:45:32 sfjro Exp $
 
20
 * $Id: misc.h,v 1.44 2008/04/13 23:43:36 sfjro Exp $
21
21
 */
22
22
 
23
23
#ifndef __AUFS_MISC_H__
48
48
 
49
49
/* ---------------------------------------------------------------------- */
50
50
 
51
 
struct aufs_rwsem {
 
51
struct au_rwsem {
52
52
        struct rw_semaphore     rwsem;
53
53
#ifdef CONFIG_AUFS_DEBUG
54
54
        atomic_t                rcnt;
56
56
};
57
57
 
58
58
#ifdef CONFIG_AUFS_DEBUG
59
 
#define DbgRcntInit(rw) do { \
 
59
#define AuDbgRcntInit(rw) do { \
60
60
        atomic_set(&(rw)->rcnt, 0); \
61
61
        smp_mb(); \
62
62
} while (0)
63
63
 
64
 
#define DbgRcntInc(rw)          atomic_inc_return(&(rw)->rcnt)
65
 
#define DbgRcntDec(rw)          WARN_ON(atomic_dec_return(&(rw)->rcnt) < 0)
 
64
#define AuDbgRcntInc(rw)        atomic_inc_return(&(rw)->rcnt)
 
65
#define AuDbgRcntDec(rw)        WARN_ON(atomic_dec_return(&(rw)->rcnt) < 0)
66
66
#else
67
 
#define DbgRcntInit(rw)         do {} while (0)
68
 
#define DbgRcntInc(rw)          do {} while (0)
69
 
#define DbgRcntDec(rw)          do {} while (0)
 
67
#define AuDbgRcntInit(rw)       do {} while (0)
 
68
#define AuDbgRcntInc(rw)        do {} while (0)
 
69
#define AuDbgRcntDec(rw)        do {} while (0)
70
70
#endif /* CONFIG_AUFS_DEBUG */
71
71
 
72
 
static inline void rw_init_nolock(struct aufs_rwsem *rw)
 
72
static inline void au_rw_init_nolock(struct au_rwsem *rw)
73
73
{
74
 
        DbgRcntInit(rw);
 
74
        AuDbgRcntInit(rw);
75
75
        init_rwsem(&rw->rwsem);
76
76
}
77
77
 
78
 
static inline void rw_init_wlock(struct aufs_rwsem *rw)
 
78
static inline void au_rw_init_wlock(struct au_rwsem *rw)
79
79
{
80
 
        rw_init_nolock(rw);
 
80
        au_rw_init_nolock(rw);
81
81
        down_write(&rw->rwsem);
82
82
}
83
83
 
84
 
static inline void rw_init_wlock_nested(struct aufs_rwsem *rw, unsigned int lsc)
 
84
static inline void au_rw_init_wlock_nested(struct au_rwsem *rw,
 
85
                                           unsigned int lsc)
85
86
{
86
 
        rw_init_nolock(rw);
 
87
        au_rw_init_nolock(rw);
87
88
        down_write_nested(&rw->rwsem, lsc);
88
89
}
89
90
 
90
 
static inline void rw_read_lock(struct aufs_rwsem *rw)
 
91
static inline void au_rw_read_lock(struct au_rwsem *rw)
91
92
{
92
93
        down_read(&rw->rwsem);
93
 
        DbgRcntInc(rw);
 
94
        AuDbgRcntInc(rw);
94
95
}
95
96
 
96
 
static inline void rw_read_lock_nested(struct aufs_rwsem *rw, unsigned int lsc)
 
97
static inline void au_rw_read_lock_nested(struct au_rwsem *rw, unsigned int lsc)
97
98
{
98
99
        down_read_nested(&rw->rwsem, lsc);
99
 
        DbgRcntInc(rw);
 
100
        AuDbgRcntInc(rw);
100
101
}
101
102
 
102
 
static inline void rw_read_unlock(struct aufs_rwsem *rw)
 
103
static inline void au_rw_read_unlock(struct au_rwsem *rw)
103
104
{
104
 
        DbgRcntDec(rw);
 
105
        AuDbgRcntDec(rw);
105
106
        up_read(&rw->rwsem);
106
107
}
107
108
 
108
 
static inline void rw_dgrade_lock(struct aufs_rwsem *rw)
 
109
static inline void au_rw_dgrade_lock(struct au_rwsem *rw)
109
110
{
110
 
        DbgRcntInc(rw);
 
111
        AuDbgRcntInc(rw);
111
112
        downgrade_write(&rw->rwsem);
112
113
}
113
114
 
114
 
static inline void rw_write_lock(struct aufs_rwsem *rw)
 
115
static inline void au_rw_write_lock(struct au_rwsem *rw)
115
116
{
116
117
        down_write(&rw->rwsem);
117
118
}
118
119
 
119
 
static inline void rw_write_lock_nested(struct aufs_rwsem *rw, unsigned int lsc)
 
120
static inline void au_rw_write_lock_nested(struct au_rwsem *rw,
 
121
                                           unsigned int lsc)
120
122
{
121
123
        down_write_nested(&rw->rwsem, lsc);
122
124
}
123
125
 
124
 
static inline void rw_write_unlock(struct aufs_rwsem *rw)
 
126
static inline void au_rw_write_unlock(struct au_rwsem *rw)
125
127
{
126
128
        up_write(&rw->rwsem);
127
129
}
128
130
 
129
131
/* why is not _nested version defined */
130
 
static inline int rw_read_trylock(struct aufs_rwsem *rw)
 
132
static inline int au_rw_read_trylock(struct au_rwsem *rw)
131
133
{
132
134
        int ret = down_read_trylock(&rw->rwsem);
133
135
        if (ret)
134
 
                DbgRcntInc(rw);
 
136
                AuDbgRcntInc(rw);
135
137
        return ret;
136
138
}
137
139
 
138
 
static inline int rw_write_trylock(struct aufs_rwsem *rw)
 
140
static inline int au_rw_write_trylock(struct au_rwsem *rw)
139
141
{
140
142
        return down_write_trylock(&rw->rwsem);
141
143
}
142
144
 
143
 
#undef DbgRcntInit
144
 
#undef DbgRcntInc
145
 
#undef DbgRcntDec
 
145
#undef AuDbgRcntInit
 
146
#undef AuDbgRcntInc
 
147
#undef AuDbgRcntDec
146
148
 
147
149
/* to debug easier, do not make them inlined functions */
148
 
#define RwMustNoWaiters(rw)     AuDebugOn(!list_empty(&(rw)->rwsem.wait_list))
149
 
#define RwMustAnyLock(rw)       AuDebugOn(down_write_trylock(&(rw)->rwsem))
 
150
#define AuRwMustNoWaiters(rw)   AuDebugOn(!list_empty(&(rw)->rwsem.wait_list))
 
151
#define AuRwMustAnyLock(rw)     AuDebugOn(down_write_trylock(&(rw)->rwsem))
150
152
#ifdef CONFIG_AUFS_DEBUG
151
 
#define RwMustReadLock(rw) do { \
152
 
        RwMustAnyLock(rw); \
 
153
#define AuRwMustReadLock(rw) do { \
 
154
        AuRwMustAnyLock(rw); \
153
155
        AuDebugOn(!atomic_read(&(rw)->rcnt)); \
154
156
} while (0)
155
157
 
156
 
#define RwMustWriteLock(rw) do { \
157
 
        RwMustAnyLock(rw); \
 
158
#define AuRwMustWriteLock(rw) do { \
 
159
        AuRwMustAnyLock(rw); \
158
160
        AuDebugOn(atomic_read(&(rw)->rcnt)); \
159
161
} while (0)
160
162
#else
161
 
#define RwMustReadLock(rw)      RwMustAnyLock(rw)
162
 
#define RwMustWriteLock(rw)     RwMustAnyLock(rw)
 
163
#define AuRwMustReadLock(rw)    AuRwMustAnyLock(rw)
 
164
#define AuRwMustWriteLock(rw)   AuRwMustAnyLock(rw)
163
165
#endif /* CONFIG_AUFS_DEBUG */
164
166
 
165
 
#define SimpleLockRwsemFuncs(prefix, param, rwsem) \
 
167
#define AuSimpleLockRwsemFuncs(prefix, param, rwsem) \
166
168
static inline void prefix##_read_lock(param) \
167
 
{ rw_read_lock(&(rwsem)); } \
 
169
{ au_rw_read_lock(&(rwsem)); } \
168
170
static inline void prefix##_write_lock(param) \
169
 
{ rw_write_lock(&(rwsem)); } \
 
171
{ au_rw_write_lock(&(rwsem)); } \
170
172
static inline int prefix##_read_trylock(param) \
171
 
{ return rw_read_trylock(&(rwsem)); } \
 
173
{ return au_rw_read_trylock(&(rwsem)); } \
172
174
static inline int prefix##_write_trylock(param) \
173
 
{ return rw_write_trylock(&(rwsem)); }
 
175
{ return au_rw_write_trylock(&(rwsem)); }
174
176
//static inline void prefix##_read_trylock_nested(param, lsc)
175
 
//{rw_read_trylock_nested(&(rwsem, lsc));}
 
177
//{au_rw_read_trylock_nested(&(rwsem, lsc));}
176
178
//static inline void prefix##_write_trylock_nestd(param, lsc)
177
 
//{rw_write_trylock_nested(&(rwsem), nested);}
 
179
//{au_rw_write_trylock_nested(&(rwsem), nested);}
178
180
 
179
 
#define SimpleUnlockRwsemFuncs(prefix, param, rwsem) \
 
181
#define AuSimpleUnlockRwsemFuncs(prefix, param, rwsem) \
180
182
static inline void prefix##_read_unlock(param) \
181
 
{ rw_read_unlock(&(rwsem)); } \
 
183
{ au_rw_read_unlock(&(rwsem)); } \
182
184
static inline void prefix##_write_unlock(param) \
183
 
{ rw_write_unlock(&(rwsem)); } \
 
185
{ au_rw_write_unlock(&(rwsem)); } \
184
186
static inline void prefix##_downgrade_lock(param) \
185
 
{ rw_dgrade_lock(&(rwsem)); }
 
187
{ au_rw_dgrade_lock(&(rwsem)); }
186
188
 
187
 
#define SimpleRwsemFuncs(prefix, param, rwsem) \
188
 
        SimpleLockRwsemFuncs(prefix, param, rwsem) \
189
 
        SimpleUnlockRwsemFuncs(prefix, param, rwsem)
 
189
#define AuSimpleRwsemFuncs(prefix, param, rwsem) \
 
190
        AuSimpleLockRwsemFuncs(prefix, param, rwsem) \
 
191
        AuSimpleUnlockRwsemFuncs(prefix, param, rwsem)
190
192
 
191
193
/* ---------------------------------------------------------------------- */
192
194
 
193
195
void *au_kzrealloc(void *p, unsigned int nused, unsigned int new_sz, gfp_t gfp);
194
196
 
195
 
struct aufs_sbinfo;
196
 
struct nameidata *au_dup_nd(struct aufs_sbinfo *sbinfo, struct nameidata *dst,
 
197
struct au_sbinfo;
 
198
struct nameidata *au_dup_nd(struct au_sbinfo *sbinfo, struct nameidata *dst,
197
199
                            struct nameidata *src);
 
200
 
198
201
struct nameidata *au_fake_dm(struct nameidata *fake_nd, struct nameidata *nd,
199
202
                             struct super_block *sb, aufs_bindex_t bindex);
200
203
void au_fake_dm_release(struct nameidata *fake_nd);
203
206
 
204
207
int au_copy_file(struct file *dst, struct file *src, loff_t len,
205
208
                 struct super_block *sb);
206
 
int au_test_ro(struct super_block *sb, aufs_bindex_t bindex,
207
 
               struct inode *inode);
208
 
int au_test_perm(struct inode *h_inode, int mask, int dlgt);
209
 
int au_test_perm_sio(struct inode *h_inode, int mask, int dlgt);
210
209
 
211
210
#endif /* __KERNEL__ */
212
211
#endif /* __AUFS_MISC_H__ */