Fix typo in afs_linux_cred_is_current
[openafs.git] / src / afs / LINUX / osi_compat.h
1 /* Kernel compatibility routines
2  *
3  * This file contains definitions to provide compatibility between different
4  * versions of the Linux kernel. It is an ifdef maze, but the idea is that
5  * by concentrating the horror here, the rest of the tree may remaing a
6  * little cleaner...
7  */
8
9 #ifndef AFS_LINUX_OSI_COMPAT_H
10 #define AFS_LINUX_OSI_COMPAT_H
11
12 #ifndef DO_SYNC_READ
13 static inline int
14 do_sync_read(struct file *fp, char *buf, size_t count, loff_t *offp) {
15     return generic_file_read(fp, buf, count, offp);
16 }
17
18 static inline int
19 do_sync_write(struct file *fp, char *buf, size_t count, loff_t *offp) {
20     return generic_file_write(fp, buf, count, offp);
21 }
22
23 #endif /* DO_SYNC_READ */
24
25 static inline int
26 afs_posix_lock_file(struct file *fp, struct file_lock *flp) {
27 #ifdef POSIX_LOCK_FILE_WAIT_ARG
28     return posix_lock_file(fp, flp, NULL);
29 #else
30     flp->fl_flags &=~ FL_SLEEP;
31     return posix_lock_file(fp, flp);
32 #endif
33 }
34
35 static inline void
36 afs_posix_test_lock(struct file *fp, struct file_lock *flp) {
37 #if defined(POSIX_TEST_LOCK_CONFLICT_ARG)
38     struct file_lock conflict;
39     if (posix_test_lock(fp, flp, &conflict)) {
40         locks_copy_lock(flp, &conflict);
41         flp->fl_type = F_UNLCK;
42     }
43 #elif defined(POSIX_TEST_LOCK_RETURNS_CONFLICT)
44     struct file_lock *conflict;
45     if (conflict = posix_test_lock(fp, flp)) {
46         locks_copy_lock(flp, conflict);
47         flp->fl_type = F_UNLCK;
48     }
49 #else
50     posix_test_lock(fp, flp);
51 #endif
52 }
53
54 #ifdef DCACHE_NFSFS_RENAMED
55 static inline void
56 afs_linux_clear_nfsfs_renamed(struct dentry *dp) {
57     spin_lock(&dp->d_lock);
58     dp->d_flags &= ~DCACHE_NFSFS_RENAMED;
59     spin_unlock(&dp->d_lock);
60 }
61
62 static inline void
63 afs_linux_set_nfsfs_renamed(struct dentry *dp) {
64     spin_lock(&dp->d_lock);
65     dp->d_flags |= DCACHE_NFSFS_RENAMED;
66     spin_unlock(&dp->d_lock);
67 }
68 #else
69 static inline void afs_linux_clear_nfsfs_renamed(void) { return; }
70 static inline void afs_linux_set_nfsfs_renamed(void) { return; }
71 #endif
72
73 #ifndef HAVE_KERNEL_HLIST_UNHASHED
74 static void
75 hlist_unhashed(const struct hlist_node *h) {
76     return (!h->pprev == NULL);
77 }
78 #endif
79
80 #if defined(WRITEPAGE_ACTIVATE)
81 #define AOP_WRITEPAGE_ACTIVATE WRITEPAGE_ACTIVATE
82 #endif
83
84 #if defined(HAVE_WRITE_BEGIN) && !defined(HAVE_GRAB_CACHE_PAGE_WRITE_BEGIN)
85 static inline struct page *
86 grab_cache_page_write_begin(struct address_space *mapping, pgoff_t index,
87                             unsigned int flags) {
88     return __grab_cache_page(mapping, index);
89 }
90 #endif
91
92 #if defined(HAVE_KMEM_CACHE_T)
93 #define afs_kmem_cache_t kmem_cache_t
94 #else
95 #define afs_kmem_cache_t struct kmem_cache
96 #endif
97
98 extern void init_once(void *);
99 #if defined(HAVE_KMEM_CACHE_T)
100 static inline void
101 init_once_func(void * foo, kmem_cache_t * cachep, unsigned long flags) {
102 #if defined(SLAB_CTOR_VERIFY)
103     if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
104         SLAB_CTOR_CONSTRUCTOR)
105 #endif
106     init_once(foo);
107 }
108 #elif defined(KMEM_CACHE_INIT)
109 static inline void
110 init_once_func(struct kmem_cache * cachep, void * foo) {
111     init_once(foo);
112 }
113 #elif !defined(KMEM_CACHE_CTOR_TAKES_VOID)
114 static inline void
115 init_once_func(void * foo, struct kmem_cache * cachep, unsigned long flags) {
116 #if defined(SLAB_CTOR_VERIFY)
117     if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
118         SLAB_CTOR_CONSTRUCTOR)
119 #endif
120     init_once(foo);
121 }
122 #else
123 static inline void
124 init_once_func(void * foo) {
125     init_once(foo);
126 }
127 #endif
128
129 #ifndef SLAB_RECLAIM_ACCOUNT
130 #define SLAB_RECLAIM_ACCOUNT 0
131 #endif
132
133 #if defined(SLAB_KERNEL)
134 #define KALLOC_TYPE SLAB_KERNEL
135 #else
136 #define KALLOC_TYPE GFP_KERNEL
137 #endif
138
139 static inline struct key *
140 afs_linux_key_alloc(struct key_type *type, const char *desc, uid_t uid,
141                     gid_t gid, key_perm_t perm, unsigned long flags)
142 {
143 #if defined(KEY_ALLOC_NEEDS_STRUCT_TASK)
144     return key_alloc(type, desc, uid, gid, current, perm, flags);
145 #elif defined(KEY_ALLOC_NEEDS_CRED)
146     return key_alloc(type, desc, uid, gid, current_cred(), perm, flags);
147 #else
148     return key_alloc(type, desc, uid, gid, perm, flags);
149 #endif
150 }
151
152 #if defined(STRUCT_TASK_HAS_CRED)
153 static inline struct key*
154 afs_linux_search_keyring(afs_ucred_t *cred, struct key_type *type)
155 {
156     key_ref_t key_ref;
157
158     if (cred->tgcred->session_keyring) {
159         key_ref = keyring_search(
160                       make_key_ref(cred->tgcred->session_keyring, 1),
161                       type, "_pag");
162         if (IS_ERR(key_ref))
163             return ERR_CAST(key_ref);
164
165         return key_ref_to_ptr(key_ref);
166     }
167
168     return ERR_PTR(-ENOKEY);
169 }
170
171 static inline int
172 afs_linux_cred_is_current(afs_ucred_t *cred)
173 {
174     return (cred == current_cred());
175 }
176
177 #else
178 static inline struct key*
179 afs_linux_search_keyring(afs_ucred_t *cred, struct key_type *type)
180 {
181     return request_key(type, "_pag", NULL);
182 }
183
184 static inline int
185 afs_linux_cred_is_current(afs_ucred_t *cred)
186 {
187     return 1;
188 }
189 #endif
190
191 #endif