liblustre.h

来自「lustre 1.6.5 source code」· C头文件 代码 · 共 907 行 · 第 1/2 页

/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
 * vim:expandtab:shiftwidth=8:tabstop=8:
 *
 *  Copyright (C) 2001 Cluster File Systems, Inc. <[e-mail]>
 *
 *   This file is part of Lustre, http://www.lustre.org.
 *
 *   Lustre is free software; you can redistribute it and/or
 *   modify it under the terms of version 2 of the GNU General Public
 *   License as published by the Free Software Foundation.
 *
 *   Lustre is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with Lustre; if not, write to the Free Software
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * User-space Lustre headers.
 *
 */
#ifndef LIBLUSTRE_H__
#define LIBLUSTRE_H__

#ifdef __KERNEL__
#error Kernel files should not #include <liblustre.h>
#else
/*
 * The userspace implementations of linux/spinlock.h vary; we just
 * include our own for all of them
 */
#define __LINUX_SPINLOCK_H
#endif

#include <sys/mman.h>
#ifdef HAVE_STDINT_H
# include <stdint.h>
#endif
#ifdef HAVE_ASM_PAGE_H
# include <asm/page.h>
#endif
#ifdef HAVE_SYS_USER_H
# include <sys/user.h>
#endif
#ifdef HAVE_SYS_IOCTL_H
# include <sys/ioctl.h>
#endif
#ifndef _IOWR
# include "ioctl.h"
#endif

#include <stdio.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/stat.h>
#ifdef HAVE_SYS_VFS_H
# include <sys/vfs.h>
#endif
#include <unistd.h>
#include <fcntl.h>

#include <libcfs/list.h>
#include <lnet/lnet.h>
#include <libcfs/kp30.h>
#include <libcfs/user-bitops.h>

/* definitions for liblustre */

#ifdef __CYGWIN__

#define CFS_PAGE_SHIFT  12
#define CFS_PAGE_SIZE   (1UL << CFS_PAGE_SHIFT)
#define CFS_PAGE_MASK   (~((__u64)CFS_PAGE_SIZE-1))
#define loff_t long long
#define ERESTART 2001
typedef unsigned short umode_t;

#endif

#ifndef CURRENT_SECONDS
# define CURRENT_SECONDS time(0)
#endif

#ifndef ARRAY_SIZE
#define ARRAY_SIZE(a) ((sizeof (a))/(sizeof ((a)[0])))
#endif

/* This is because lprocfs_status.h gets included here indirectly.  It would
 * be much better to just avoid lprocfs being included into liblustre entirely
 * but that requires more header surgery than I can handle right now.
 */
#ifndef smp_processor_id
#define smp_processor_id() 0
#endif
#ifndef num_online_cpus
#define num_online_cpus() 1
#endif
#ifndef num_possible_cpus
#define num_possible_cpus() 1
#endif

/* always adopt 2.5 definitions */
#define KERNEL_VERSION(a,b,c) ((a)*100+(b)*10+c)
#define LINUX_VERSION_CODE KERNEL_VERSION(2,5,0)

#ifndef page_private
#define page_private(page) ((page)->private)
#define set_page_private(page, v) ((page)->private = (v))
#endif


static inline void inter_module_put(void *a)
{
        return;
}

void *inter_module_get(char *arg);

/* cheats for now */

struct work_struct {
        void (*ws_task)(void *arg);
        void *ws_arg;
};

static inline void prepare_work(struct work_struct *q, void (*t)(void *),
                                void *arg)
{
        q->ws_task = t;
        q->ws_arg = arg;
        return;
}

static inline void schedule_work(struct work_struct *q)
{
        q->ws_task(q->ws_arg);
}


#define strnlen(a,b) strlen(a)
static inline void *kmalloc(int size, int prot)
{
        return malloc(size);
}
#define vmalloc malloc
#define vfree free
#define kfree(a) free(a)
#define GFP_KERNEL 1
#define GFP_HIGHUSER 1
#define GFP_ATOMIC 1
#define GFP_NOFS 1
#define IS_ERR(a) ((unsigned long)(a) > (unsigned long)-1000L)
#define PTR_ERR(a) ((long)(a))
#define ERR_PTR(a) ((void*)((long)(a)))

typedef struct {
        void *cwd;
}mm_segment_t;

typedef int (read_proc_t)(char *page, char **start, off_t off,
                          int count, int *eof, void *data);

struct file; /* forward ref */
typedef int (write_proc_t)(struct file *file, const char *buffer,
                           unsigned long count, void *data);

#define NIPQUAD(addr) \
        ((unsigned char *)&addr)[0], \
        ((unsigned char *)&addr)[1], \
        ((unsigned char *)&addr)[2], \
        ((unsigned char *)&addr)[3]

#if defined(__LITTLE_ENDIAN)
#define HIPQUAD(addr) \
        ((unsigned char *)&addr)[3], \
        ((unsigned char *)&addr)[2], \
        ((unsigned char *)&addr)[1], \
        ((unsigned char *)&addr)[0]
#elif defined(__BIG_ENDIAN)
#define HIPQUAD NIPQUAD
#else
#error "Undefined byteorder??"
#endif /* __LITTLE_ENDIAN */

/* bits ops */

/* a long can be more than 32 bits, so use BITS_PER_LONG
 * to allow the compiler to adjust the bit shifting accordingly
 */

static __inline__ int ext2_set_bit(int nr, void *addr)
{
        return set_bit(nr, addr);
}

static __inline__ int ext2_clear_bit(int nr, void *addr)
{
        return clear_bit(nr, addr);
}

static __inline__ int ext2_test_bit(int nr, void *addr)
{
        return test_bit(nr, addr);
}

/* modules */

struct module {
        int count;
};

static inline void MODULE_AUTHOR(char *name)
{
        printf("%s\n", name);
}
#define MODULE_DESCRIPTION(name) MODULE_AUTHOR(name)
#define MODULE_LICENSE(name) MODULE_AUTHOR(name)

#define THIS_MODULE NULL
#define __init
#define __exit

/* devices */

static inline int misc_register(void *foo)
{
        return 0;
}

static inline int misc_deregister(void *foo)
{
        return 0;
}

static inline int request_module(char *name)
{
        return (-EINVAL);
}

#define __MOD_INC_USE_COUNT(m)  do {} while (0)
#define __MOD_DEC_USE_COUNT(m)  do {} while (0)
#define MOD_INC_USE_COUNT       do {} while (0)
#define MOD_DEC_USE_COUNT       do {} while (0)
static inline void __module_get(struct module *module)
{
}

static inline int try_module_get(struct module *module)
{
        return 1;
}

static inline void module_put(struct module *module)
{
}

/* module initialization */
extern int init_obdclass(void);
extern int ptlrpc_init(void);
extern int ldlm_init(void);
extern int osc_init(void);
extern int lov_init(void);
extern int mdc_init(void);
extern int mgc_init(void);
extern int echo_client_init(void);



/* general stuff */

#define EXPORT_SYMBOL(S)

struct rcu_head { };

typedef struct { } spinlock_t;
typedef __u64 kdev_t;

#define SPIN_LOCK_UNLOCKED (spinlock_t) { }
#define LASSERT_SPIN_LOCKED(lock) do {} while(0)
#define LASSERT_SEM_LOCKED(sem) do {} while(0)

static inline void spin_lock(spinlock_t *l) {return;}
static inline void spin_unlock(spinlock_t *l) {return;}
static inline void spin_lock_init(spinlock_t *l) {return;}
static inline void local_irq_save(unsigned long flag) {return;}
static inline void local_irq_restore(unsigned long flag) {return;}
static inline int spin_is_locked(spinlock_t *l) {return 1;}

static inline void spin_lock_bh(spinlock_t *l) {}
static inline void spin_unlock_bh(spinlock_t *l) {}
static inline void spin_lock_irqsave(spinlock_t *a, unsigned long b) {}
static inline void spin_unlock_irqrestore(spinlock_t *a, unsigned long b) {}

#define min(x,y) ((x)<(y) ? (x) : (y))
#define max(x,y) ((x)>(y) ? (x) : (y))

#ifndef min_t
#define min_t(type,x,y) \
        ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
#endif
#ifndef max_t
#define max_t(type,x,y) \
        ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })
#endif

#define simple_strtol strtol

/* registering symbols */
#ifndef ERESTARTSYS
#define ERESTARTSYS ERESTART
#endif
#define HZ 1

/* random */

void get_random_bytes(void *ptr, int size);

/* memory */

/* memory size: used for some client tunables */
#define num_physpages (256 * 1024) /* 1GB */

static inline int copy_from_user(void *a,void *b, int c)
{
        memcpy(a,b,c);
        return 0;
}

static inline int copy_to_user(void *a,void *b, int c)
{
        memcpy(a,b,c);
        return 0;
}


/* slabs */
typedef struct {
         int size;
} kmem_cache_t;
#define SLAB_HWCACHE_ALIGN 0
static inline kmem_cache_t *
kmem_cache_create(const char *name, size_t objsize, size_t cdum,
                  unsigned long d,
                  void (*e)(void *, kmem_cache_t *, unsigned long),
                  void (*f)(void *, kmem_cache_t *, unsigned long))
{
        kmem_cache_t *c;
        c = malloc(sizeof(*c));
        if (!c)
                return NULL;
        c->size = objsize;
        CDEBUG(D_MALLOC, "alloc slab cache %s at %p, objsize %d\n",
               name, c, (int)objsize);
        return c;
};

static inline int kmem_cache_destroy(kmem_cache_t *a)
{
        CDEBUG(D_MALLOC, "destroy slab cache %p, objsize %u\n", a, a->size);
        free(a);
        return 0;
}

/* struct page decl moved out from here into portals/include/libcfs/user-prim.h */

/* 2.4 defines */
#define PAGE_LIST_ENTRY list
#define PAGE_LIST(page) ((page)->list)

#define kmap(page) (page)->addr
#define kunmap(a) do {} while (0)

static inline cfs_page_t *alloc_pages(int mask, unsigned long order)
{
        cfs_page_t *pg = malloc(sizeof(*pg));

        if (!pg)
                return NULL;
#if 0 //#ifdef MAP_ANONYMOUS
        pg->addr = mmap(0, PAGE_SIZE << order, PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
#else
        pg->addr = malloc(CFS_PAGE_SIZE << order);
#endif

        if (!pg->addr) {
                free(pg);
                return NULL;
        }
        return pg;
}
#define cfs_alloc_pages(mask, order)  alloc_pages((mask), (order))

#define alloc_page(mask)      alloc_pages((mask), 0)
#define cfs_alloc_page(mask)  alloc_page(mask)

static inline void __free_pages(cfs_page_t *pg, int what)
{
#if 0 //#ifdef MAP_ANONYMOUS
        munmap(pg->addr, PAGE_SIZE);
#else
        free(pg->addr);
#endif
        free(pg);
}
#define __cfs_free_pages(pg, order)  __free_pages((pg), (order))

#define __free_page(page) __free_pages((page), 0)
#define free_page(page) __free_page(page)
#define __cfs_free_page(page)  __cfs_free_pages((page), 0)

static inline cfs_page_t* __grab_cache_page(unsigned long index)
{
        cfs_page_t *pg = alloc_pages(0, 0);

        if (pg)
                pg->index = index;
        return pg;
}

#define grab_cache_page(index) __grab_cache_page(index)
#define page_cache_release(page) __free_pages(page, 0)

/* arithmetic */
#define do_div(a,b)                     \
        ({                              \
                unsigned long remainder;\
                remainder = (a) % (b);  \
                (a) = (a) / (b);        \
                (remainder);            \
        })

/* VFS stuff */
#define ATTR_MODE       0x0001
#define ATTR_UID        0x0002
#define ATTR_GID        0x0004
#define ATTR_SIZE       0x0008
#define ATTR_ATIME      0x0010
#define ATTR_MTIME      0x0020
#define ATTR_CTIME      0x0040
#define ATTR_ATIME_SET  0x0080
#define ATTR_MTIME_SET  0x0100
#define ATTR_FORCE      0x0200  /* Not a change, but a change it */
#define ATTR_ATTR_FLAG  0x0400
#define ATTR_RAW        0x0800  /* file system, not vfs will massage attrs */
#define ATTR_FROM_OPEN  0x1000  /* called from open path, ie O_TRUNC */
#define ATTR_CTIME_SET  0x2000
#define ATTR_KILL_SUID  0
#define ATTR_KILL_SGID  0

struct iattr {