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, cred)
 186 {
 187     return 1;
 188 }
 189 #endif
 190
 191 #endif