lustre/include/linux/lustre_compat25.h

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (c) 2003 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org.
   7  *
   8  *   Lustre is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2 of the GNU General Public
  10  *   License as published by the Free Software Foundation.
  11  *
  12  *   Lustre is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with Lustre; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  */
  22
  23 #ifndef _COMPAT25_H
  24 #define _COMPAT25_H
  25
  26 #ifdef __KERNEL__
  27
  28 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0) && LINUX_VERSION_CODE < KERNEL_VERSION(2,5,69)
  29 #error sorry, lustre requires at least 2.5.69
  30 #endif
  31
  32 #include <libcfs/linux/portals_compat25.h>
  33
  34 /*
  35  * groups_info related staff
  36  */
  37 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,4)
  38
  39 #define NGROUPS_SMALL           NGROUPS
  40 #define NGROUPS_PER_BLOCK       ((int)(EXEC_PAGESIZE / sizeof(gid_t)))
  41 struct group_info {
  42         int        ngroups;
  43         atomic_t   usage;
  44         gid_t      small_block[NGROUPS_SMALL];
  45         int        nblocks;
  46         gid_t     *blocks[0];
  47 };
  48 #define current_ngroups current->ngroups
  49
  50 struct group_info *groups_alloc(int gidsetsize);
  51 void groups_free(struct group_info *ginfo);
  52 int groups_search(struct group_info *ginfo, gid_t grp);
  53
  54 #define get_group_info(group_info)                              \
  55         do {                                                    \
  56                 atomic_inc(&(group_info)->usage);               \
  57         } while (0)
  58
  59 #define put_group_info(group_info)                              \
  60         do {                                                    \
  61                 if (atomic_dec_and_test(&(group_info)->usage))  \
  62                         groups_free(group_info);                \
  63         } while (0)
  64
  65 #define groups_sort(gi) do {} while (0)
  66 #define GROUP_AT(gi, i) ((gi)->small_block[(i)])
  67
  68 static inline int cleanup_group_info(void)
  69 {
  70         /* Get rid of unneeded supplementary groups */
  71         current->ngroups = 0;
  72         memset(current->groups, 0, sizeof(current->groups));
  73         return 0;
  74 }
  75
  76 #else /* >= 2.6.4 */
  77
  78 #define current_ngroups current->group_info->ngroups
  79
  80 void groups_sort(struct group_info *ginfo);
  81 int groups_search(struct group_info *ginfo, gid_t grp);
  82
  83 static inline int cleanup_group_info(void)
  84 {
  85         struct group_info *ginfo;
  86
  87         ginfo = groups_alloc(0);
  88         if (!ginfo)
  89                 return -ENOMEM;
  90
  91         set_current_groups(ginfo);
  92         put_group_info(ginfo);
  93
  94         return 0;
  95 }
  96 #endif /* end of groups_info stuff */
  97
  98 /*
  99  * this define is from the same namespace as other lookup flags in linux, will
 100  * be gone when COBD medium switching will be done more correct manner.
 101  * Currently this is dirty hack and this flag is needed to let MDC layer know
 102  * that it does not have to check if requested id is the same as receviced from
 103  * MDS in mdc_intent_lock() --umka
 104  */
 105 #define LOOKUP_COBD 4096
 106
 107 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
 108
 109 #define LUSTRE_FILTERDATA(inode)        ((inode)->i_pipe)
 110
 111 /* New (actually old) intent naming */
 112 #define lookup_intent open_intent
 113
 114 /* And internals */
 115 #define it_flags flags
 116 #define it_op op
 117 #define it_magic magic
 118 #define it_op_release op_release
 119 #define it_create_mode create_mode
 120
 121 /*
 122  * OBD need working random driver, thus all our
 123  * initialization routines must be called after device
 124  * driver initialization
 125  */
 126 #ifndef MODULE
 127 #undef module_init
 128 #define module_init(a)     late_initcall(a)
 129 #endif
 130
 131 /* XXX our code should be using the 2.6 calls, not the other way around */
 132 #define TryLockPage(page)                TestSetPageLocked(page)
 133 #define Page_Uptodate(page)              PageUptodate(page)
 134
 135 #define KDEVT_INIT(val)                 (val)
 136
 137 #define LTIME_S(time)                   (time.tv_sec)
 138 #define ll_path_lookup                  path_lookup
 139 #define ll_permission(inode,mask,nd)    permission(inode,mask,nd)
 140
 141 #define ll_pgcache_lock(mapping)          spin_lock(&mapping->page_lock)
 142 #define ll_pgcache_unlock(mapping)        spin_unlock(&mapping->page_lock)
 143 #define ll_call_writepage(inode, page)  \
 144                                 (inode)->i_mapping->a_ops->writepage(page, NULL)
 145 #define ll_invalidate_inode_pages(inode) \
 146                                 invalidate_inode_pages((inode)->i_mapping)
 147 #define ll_truncate_complete_page(page) \
 148                                 truncate_complete_page(page->mapping, page)
 149
 150 #define ll_vfs_create(a,b,c,d)              vfs_create(a,b,c,d)
 151
 152 #define ll_dev_t                        dev_t
 153 #define kdev_t                          dev_t
 154 #define to_kdev_t(dev)                  (dev)
 155 #define kdev_t_to_nr(dev)               (dev)
 156 #define val_to_kdev(dev)                (dev)
 157 #define ILOOKUP(sb, ino, test, data)    ilookup5(sb, ino, test, data);
 158
 159 #include <linux/writeback.h>
 160
 161 static inline void lustre_daemonize_helper(void)
 162 {
 163         LASSERT(current->signal != NULL);
 164         current->signal->session = 1;
 165         if (current->group_leader)
 166                 current->group_leader->signal->pgrp = 1;
 167         else
 168                 CERROR("we aren't group leader\n");
 169         current->signal->tty = NULL;
 170 }
 171
 172 #define __set_page_ll_data(page, llap) \
 173         do {       \
 174                 page_cache_get(page); \
 175                 SetPagePrivate(page); \
 176                 page->private = (unsigned long)llap; \
 177         } while (0)
 178 #define __clear_page_ll_data(page) \
 179         do {       \
 180                 ClearPagePrivate(page); \
 181                 page_cache_release(page); \
 182                 page->private = 0; \
 183         } while(0)
 184
 185 #ifndef smp_num_cpus
 186 #define smp_num_cpus    num_online_cpus()
 187 #endif
 188
 189 #define kiobuf bio
 190
 191 #include <linux/proc_fs.h>
 192
 193 #else /* 2.4.. */
 194
 195 #error "first, find storage for filterdata -bzzz"
 196
 197 #define ll_vfs_create(a,b,c,d)              vfs_create(a,b,c)
 198 #define ll_permission(inode,mask,nd)        permission(inode,mask)
 199 #define ILOOKUP(sb, ino, test, data)        ilookup4(sb, ino, test, data);
 200 #define DCACHE_DISCONNECTED                 DCACHE_NFSD_DISCONNECTED
 201 #define ll_dev_t                            int
 202
 203 static inline void clear_page_dirty(struct page *page)
 204 {
 205         if (PageDirty(page))
 206                 ClearPageDirty(page);
 207 }
 208
 209 /* 2.5 uses hlists for some things, like the d_hash.  we'll treat them
 210  * as 2.5 and let macros drop back.. */
 211 #ifndef HLIST_HEAD /* until we get a kernel newer than l28 */
 212 #define hlist_entry                     list_entry
 213 #define hlist_head                      list_head
 214 #define hlist_node                      list_head
 215 #define HLIST_HEAD                      LIST_HEAD
 216 #define INIT_HLIST_HEAD                 INIT_LIST_HEAD
 217 #define hlist_del_init                  list_del_init
 218 #define hlist_add_head                  list_add
 219 #define hlist_for_each_safe             list_for_each_safe
 220 #endif
 221 #define KDEVT_INIT(val)                 (val)
 222 #define ext3_xattr_set_handle           ext3_xattr_set
 223 #define extN_xattr_set_handle           extN_xattr_set
 224 #define try_module_get                  __MOD_INC_USE_COUNT
 225 #define module_put                      __MOD_DEC_USE_COUNT
 226 #define LTIME_S(time)                   (time)
 227 #if !defined(CONFIG_RH_2_4_20) && !defined(cpu_online)
 228 #define cpu_online(cpu)                 (cpu_online_map & (1<<cpu))
 229 #endif
 230
 231 static inline int ll_path_lookup(const char *path, unsigned flags,
 232                                  struct nameidata *nd)
 233 {
 234         int error = 0;
 235         if (path_init(path, flags, nd))
 236                 error = path_walk(path, nd);
 237         return error;
 238 }
 239 #define ll_permission(inode,mask,nd)    permission(inode,mask)
 240 typedef long sector_t;
 241
 242 #define ll_pgcache_lock(mapping)        spin_lock(&pagecache_lock)
 243 #define ll_pgcache_unlock(mapping)      spin_unlock(&pagecache_lock)
 244 #define ll_call_writepage(inode, page)  \
 245                                (inode)->i_mapping->a_ops->writepage(page)
 246 #define filemap_fdatawrite(mapping)      filemap_fdatasync(mapping)
 247 #define ll_invalidate_inode_pages(inode) invalidate_inode_pages(inode)
 248 #define ll_truncate_complete_page(page) truncate_complete_page(page)
 249
 250 static inline void __d_drop(struct dentry *dentry)
 251 {
 252         list_del(&dentry->d_hash);
 253         INIT_LIST_HEAD(&dentry->d_hash);
 254 }
 255
 256 static inline void lustre_daemonize_helper(void)
 257 {
 258         current->session = 1;
 259         current->pgrp = 1;
 260         current->tty = NULL;
 261 }
 262
 263 #ifndef HAVE_COND_RESCHED
 264 static inline void cond_resched(void)
 265 {
 266         if (unlikely(need_resched())) {
 267                 set_current_state(TASK_RUNNING);
 268                 schedule();
 269         }
 270 }
 271 #endif
 272
 273 static inline int mapping_mapped(struct address_space *mapping)
 274 {
 275         if (mapping->i_mmap_shared)
 276                 return 1;
 277         if (mapping->i_mmap)
 278                 return 1;
 279         return 0;
 280 }
 281
 282 /* to find proc_dir_entry from inode. 2.6 has native one -bzzz */
 283 #ifndef HAVE_PDE
 284 #define PDE(ii)         ((ii)->u.generic_ip)
 285 #endif
 286
 287 #define __set_page_ll_data(page, llap) page->private = (unsigned long)llap
 288 #define __clear_page_ll_data(page) page->private = 0
 289 #define PageWriteback(page) 0
 290 #define set_page_writeback(page) do {} while (0)
 291 #define end_page_writeback(page) do {} while (0)
 292
 293 #define end_page_writeback(page)
 294
 295 #ifdef ZAP_PAGE_RANGE_VMA
 296 #define ll_zap_page_range(vma, addr, len)  zap_page_range(vma, addr, len)
 297 #else
 298 #define ll_zap_page_range(vma, addr, len)  zap_page_range(vma->vm_mm, addr, len)
 299 #endif
 300
 301 #endif /* end of 2.4 compat macros */
 302
 303 #ifdef HAVE_PAGE_LIST
 304 static inline int mapping_has_pages(struct address_space *mapping)
 305 {
 306         int rc = 1;
 307
 308         ll_pgcache_lock(mapping);
 309         if (list_empty(&mapping->dirty_pages) &&
 310             list_empty(&mapping->clean_pages) &&
 311             list_empty(&mapping->locked_pages)) {
 312                 rc = 0;
 313         }
 314         ll_pgcache_unlock(mapping);
 315
 316         return rc;
 317 }
 318
 319 static inline int clear_page_dirty_for_io(struct page *page)
 320 {
 321         struct address_space *mapping = page->mapping;
 322
 323         if (page->mapping && PageDirty(page)) {
 324                 ClearPageDirty(page);
 325                 ll_pgcache_lock(mapping);
 326                 list_del(&page->list);
 327                 list_add(&page->list, &mapping->locked_pages);
 328                 ll_pgcache_unlock(mapping);
 329                 return 1;
 330         }
 331         return 0;
 332 }
 333 #else
 334 static inline int mapping_has_pages(struct address_space *mapping)
 335 {
 336         return mapping->nrpages > 0;
 337 }
 338 #endif
 339
 340 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,7))
 341 #define ll_set_dflags(dentry, flags) do { dentry->d_vfs_flags |= flags; } while(0)
 342 #define ll_vfs_symlink(dir, dentry, path, mode) vfs_symlink(dir, dentry, path)
 343 #else
 344 #define ll_set_dflags(dentry, flags) do { \
 345                 spin_lock(&dentry->d_lock); \
 346                 dentry->d_flags |= flags; \
 347                 spin_unlock(&dentry->d_lock); \
 348         } while(0)
 349 #define ll_vfs_symlink(dir, dentry, path, mode) vfs_symlink(dir, dentry, path, mode)
 350 #endif
 351
 352 #ifndef container_of
 353 #define container_of(ptr, type, member) ({                      \
 354                 const typeof( ((type *)0)->member ) *__mptr = (ptr); \
 355                 (type *)( (char *)__mptr - offsetof(type,member) );})
 356 #endif
 357
 358 #ifdef HAVE_I_ALLOC_SEM
 359 #define UP_WRITE_I_ALLOC_SEM(i) do { up_write(&(i)->i_alloc_sem); } while (0)
 360 #define DOWN_WRITE_I_ALLOC_SEM(i) do { down_write(&(i)->i_alloc_sem); } while(0)
 361 #define LASSERT_MDS_ORPHAN_WRITE_LOCKED(i) LASSERT(down_read_trylock(&(i)->i_alloc_sem) == 0)
 362
 363 #define UP_READ_I_ALLOC_SEM(i) do { up_read(&(i)->i_alloc_sem); } while (0)
 364 #define DOWN_READ_I_ALLOC_SEM(i) do { down_read(&(i)->i_alloc_sem); } while (0)
 365 #define LASSERT_MDS_ORPHAN_READ_LOCKED(i) LASSERT(down_write_trylock(&(i)->i_alloc_sem) == 0)
 366 #define MDS_PACK_MD_LOCK 1
 367 #else
 368 #define UP_READ_I_ALLOC_SEM(i) do { up(&(i)->i_sem); } while (0)
 369 #define DOWN_READ_I_ALLOC_SEM(i) do { down(&(i)->i_sem); } while (0)
 370 #define LASSERT_MDS_ORPHAN_READ_LOCKED(i) LASSERT(down_trylock(&(i)->i_sem) != 0)
 371
 372 #define UP_WRITE_I_ALLOC_SEM(i) do { up(&(i)->i_sem); } while (0)
 373 #define DOWN_WRITE_I_ALLOC_SEM(i) do { down(&(i)->i_sem); } while (0)
 374 #define LASSERT_MDS_ORPHAN_WRITE_LOCKED(i) LASSERT(down_trylock(&(i)->i_sem) != 0)
 375 #define MDS_PACK_MD_LOCK 0
 376 #endif
 377
 378 #endif /* __KERNEL__ */
 379 #endif /* _COMPAT25_H */