-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
* GPL HEADER START
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* GPL HEADER END
*/
/*
- * Copyright 2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
+ *
+ * Copyright (c) 2012, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#error Do not #include this file directly. #include <libcfs/libcfs.h> instead
#endif
+#ifndef EXPORT_SYMBOL
+# define EXPORT_SYMBOL(s)
+#endif
+
/*
* libcfs proc device object
*/
#define CFS_SYMBOL_LEN 64
struct cfs_symbol {
- char name[CFS_SYMBOL_LEN];
- void *value;
- int ref;
- struct list_head sym_list;
+ char name[CFS_SYMBOL_LEN];
+ void *value;
+ int ref;
+ cfs_list_t sym_list;
};
extern int cfs_symbol_register(const char *, const void *);
extern void cfs_symbol_clean();
typedef struct file_operations cfs_file_operations_t;
-typedef struct file cfs_file_t;
/*
* Pseudo device register
*/
-typedef struct
-{
+typedef struct miscdevice{
int minor;
const char * name;
cfs_file_operations_t * fops;
-} cfs_psdev_t;
+};
-int cfs_psdev_register(cfs_psdev_t * psdev);
-int cfs_psdev_deregister(cfs_psdev_t * psdev);
+int misc_register(struct miscdevice *psdev);
+int misc_deregister(struct miscdevice *psdev);
/*
/*
* Sysctl register
*/
+typedef int ctl_handler(struct ctl_table *table,
+ int *name, int nlen,
+ void *oldval, size_t *oldlenp,
+ void *newval, size_t newlen,
+ void **context);
-typedef struct ctl_table cfs_sysctl_table_t;
-typedef struct ctl_table_header cfs_sysctl_table_header_t;
-
+typedef int proc_handler (struct ctl_table *ctl,
+ int write, struct file *filp,
+ void *buffer, size_t *lenp);
-typedef int ctl_handler (
- cfs_sysctl_table_t *table,
- int *name, int nlen,
- void *oldval, size_t *oldlenp,
- void *newval, size_t newlen,
- void **context );
-typedef int proc_handler (
- cfs_sysctl_table_t *ctl,
- int write, struct file * filp,
- void *buffer, size_t *lenp );
-
-
-int proc_dointvec(cfs_sysctl_table_t *table, int write, struct file *filp,
+int proc_dointvec(struct ctl_table *table, int write, struct file *filp,
void *buffer, size_t *lenp);
-int proc_dostring(cfs_sysctl_table_t *table, int write, struct file *filp,
+int proc_dostring(struct ctl_table *table, int write, struct file *filp,
void *buffer, size_t *lenp);
-int sysctl_string(cfs_sysctl_table_t *table, int *name, int nlen,
+int sysctl_string(struct ctl_table *table, int *name, int nlen,
void *oldval, size_t *oldlenp,
void *newval, size_t newlen, void **context);
void *data;
int maxlen;
mode_t mode;
- cfs_sysctl_table_t *child;
+ struct ctl_table *child;
proc_handler *proc_handler; /* text formatting callback */
ctl_handler *strategy; /* read / write callback functions */
cfs_proc_entry_t *de; /* proc entry block */
/* the mantaner of the cfs_sysctl_table trees */
struct ctl_table_header
{
- cfs_sysctl_table_t * ctl_table;
- struct list_head ctl_entry;
+ struct ctl_table * ctl_table;
+ cfs_list_t ctl_entry;
};
/* proc root entries, support routines */
#define cfs_free_proc_entry proc_free_entry
#define cfs_remove_proc_entry remove_proc_entry
-struct ctl_table_header *register_sysctl_table(cfs_sysctl_table_t * table,
- int insert_at_head);
-void unregister_sysctl_table(struct ctl_table_header * header);
-
-#define cfs_register_sysctl_table(t, a) register_sysctl_table(t, a)
-#define cfs_unregister_sysctl_table(t) unregister_sysctl_table(t)
+struct ctl_table_header *register_sysctl_table(struct ctl_table *table);
+void unregister_sysctl_table(struct ctl_table_header *header);
/*
* seq device (linux/seq_file.h)
size_t count;
loff_t index;
u32 version;
- mutex_t lock;
+ struct mutex lock;
const struct seq_operations *op;
void *private;
};
* Helpers for iteration over list_head-s in seq_files
*/
-extern struct list_head *seq_list_start(struct list_head *head,
- loff_t pos);
-extern struct list_head *seq_list_start_head(struct list_head *head,
- loff_t pos);
-extern struct list_head *seq_list_next(void *v, struct list_head *head,
- loff_t *ppos);
+extern cfs_list_t *seq_list_start(cfs_list_t *head, loff_t pos);
+extern cfs_list_t *seq_list_start_head(cfs_list_t *head, loff_t pos);
+extern cfs_list_t *seq_list_next(void *v, cfs_list_t *head, loff_t *ppos);
/*
* declaration of proc kernel process routines
*/
-cfs_file_t *
-lustre_open_file(char * filename);
+struct file *lustre_open_file(char *filename);
-int
-lustre_close_file(cfs_file_t * fh);
+int lustre_close_file(struct file *fh);
-int
-lustre_do_ioctl( cfs_file_t * fh,
- unsigned long cmd,
- ulong_ptr_t arg );
+int lustre_do_ioctl(struct file *fh, unsigned long cmd, ulong_ptr_t arg);
-int
-lustre_ioctl_file( cfs_file_t * fh,
- PCFS_PROC_IOCTL devctl);
-
-size_t
-lustre_read_file( cfs_file_t * fh,
- loff_t offl,
- size_t size,
- char * buf
- );
-
-size_t
-lustre_write_file( cfs_file_t * fh,
- loff_t off,
- size_t size,
- char * buf
- );
+int lustre_ioctl_file(struct file *fh, PCFS_PROC_IOCTL devctl);
+
+size_t lustre_read_file(struct file *fh, loff_t offl, size_t size, char *buf);
+
+size_t lustre_write_file(struct file *fh, loff_t off, size_t size, char *buf);
/*
* Wait Queue
*/
-typedef int cfs_task_state_t;
-
-#define CFS_TASK_INTERRUPTIBLE 0x00000001
-#define CFS_TASK_UNINT 0x00000002
-#define CFS_TASK_RUNNING 0x00000003
-#define CFS_TASK_UNINTERRUPTIBLE CFS_TASK_UNINT
+#define TASK_INTERRUPTIBLE 0x00000001
+#define TASK_UNINTERRUPTIBLE 0x00000002
+#define TASK_RUNNING 0x00000003
+#define CFS_TASK_UNINTERRUPTIBLE TASK_UNINTERRUPTIBLE
#define CFS_WAITQ_MAGIC 'CWQM'
#define CFS_WAITLINK_MAGIC 'CWLM'
typedef struct cfs_waitq {
+ unsigned int magic;
+ unsigned int flags;
- unsigned int magic;
- unsigned int flags;
-
- spinlock_t guard;
- struct list_head waiters;
+ spinlock_t guard;
+ cfs_list_t waiters;
-} cfs_waitq_t;
+} wait_queue_head_t;
-typedef struct cfs_waitlink cfs_waitlink_t;
+typedef struct cfs_waitlink wait_queue_t;
#define CFS_WAITQ_CHANNELS (2)
typedef struct cfs_waitlink_channel {
- struct list_head link;
- cfs_waitq_t * waitq;
- cfs_waitlink_t * waitl;
+ cfs_list_t link;
+ wait_queue_head_t * waitq;
+ wait_queue_t * waitl;
} cfs_waitlink_channel_t;
struct cfs_waitlink {
unsigned int magic;
int flags;
event_t * event;
- atomic_t * hits;
+ atomic_t * hits;
cfs_waitlink_channel_t waitq[CFS_WAITQ_CHANNELS];
};
CFS_WAITQ_EXCLUSIVE = 1
};
-#define CFS_DECL_WAITQ(name) cfs_waitq_t name
+#define CFS_DECL_WAITQ(name) wait_queue_head_t name
/* Kernel thread */
void * arg;
} cfs_thread_context_t;
-int cfs_kernel_thread(int (*func)(void *), void *arg, int flag);
-#define kernel_thread cfs_kernel_thread
-
/*
* thread creation flags from Linux, not used in winnt
*/
#define CLONE_SIGNAL (CLONE_SIGHAND | CLONE_THREAD)
-
/*
* group_info: linux/sched.h
*/
#define NGROUPS_SMALL 32
#define NGROUPS_PER_BLOCK ((int)(PAGE_SIZE / sizeof(gid_t)))
struct group_info {
- int ngroups;
- atomic_t usage;
- gid_t small_block[NGROUPS_SMALL];
- int nblocks;
- gid_t *blocks[0];
+ int ngroups;
+ atomic_t usage;
+ gid_t small_block[NGROUPS_SMALL];
+ int nblocks;
+ gid_t *blocks[0];
};
#define get_group_info(group_info) do { \
- atomic_inc(&(group_info)->usage); \
+ atomic_inc(&(group_info)->usage); \
} while (0)
#define put_group_info(group_info) do { \
- if (atomic_dec_and_test(&(group_info)->usage)) \
- groups_free(group_info); \
+ if (atomic_dec_and_test(&(group_info)->usage)) \
+ groups_free(group_info); \
} while (0)
static __inline struct group_info *groups_alloc(int gidsetsize)
{
struct group_info * groupinfo;
KdPrint(("%s(%d): %s NOT implemented.\n", __FILE__, __LINE__, __FUNCTION__));
- groupinfo = (struct group_info *)cfs_alloc(sizeof(struct group_info), 0);
+ groupinfo = kmalloc(sizeof(struct group_info), 0);
+
if (groupinfo) {
- memset(groupinfo, 0, sizeof(struct group_info));
+ memset(groupinfo, 0, sizeof(struct group_info));
}
return groupinfo;
}
+
static __inline void groups_free(struct group_info *group_info)
{
- KdPrint(("%s(%d): %s NOT implemented.\n", __FILE__, __LINE__, __FUNCTION__));
- cfs_free(group_info);
+ KdPrint(("%s(%d): %s NOT implemented.\n", __FILE__, __LINE__,
+ __FUNCTION__));
+ kfree(group_info);
}
-static __inline int set_current_groups(struct group_info *group_info) {
- KdPrint(("%s(%d): %s NOT implemented.\n", __FILE__, __LINE__, __FUNCTION__));
+
+static __inline int
+set_current_groups(struct group_info *group_info)
+{
+ KdPrint(("%s(%d): %s NOT implemented.\n", __FILE__, __LINE__,
+ __FUNCTION__));
return 0;
}
-static __inline int groups_search(struct group_info *group_info, gid_t grp) {
- KdPrint(("%s(%d): %s NOT implemented.\n", __FILE__, __LINE__, __FUNCTION__));
+
+static __inline int groups_search(struct group_info *group_info,
+ gid_t grp) {
+ KdPrint(("%s(%d): %s NOT implemented.\n", __FILE__, __LINE__,
+ __FUNCTION__));
return 0;
}
* capabilities support
*/
-typedef __u32 cfs_kernel_cap_t;
+typedef __u32 kernel_cap_t;
#define cap_raise(c, flag) do {} while(0)
#define cap_lower(c, flag) do {} while(0)
* Task struct
*/
-#define CFS_MAX_SCHEDULE_TIMEOUT ((long_ptr_t)(~0UL>>12))
-#define schedule_timeout(t) cfs_schedule_timeout(0, t)
+#define MAX_SCHEDULE_TIMEOUT ((long_ptr_t)(~0UL>>12))
+#define schedule_timeout(t) schedule_timeout_and_set_state(0, t)
struct vfsmount;
#define NGROUPS 1
#define CFS_CURPROC_COMM_MAX (16)
-typedef struct task_sruct{
- mode_t umask;
- sigset_t blocked;
-
- pid_t pid;
- pid_t pgrp;
-
- uid_t uid,euid,suid,fsuid;
- gid_t gid,egid,sgid,fsgid;
-
- int ngroups;
- int cgroups;
- gid_t groups[NGROUPS];
- struct group_info *group_info;
- cfs_kernel_cap_t cap_effective,
- cap_inheritable,
- cap_permitted;
-
- char comm[CFS_CURPROC_COMM_MAX];
- void *journal_info;
- struct vfsmount *fs;
-} cfs_task_t;
-
-static inline void task_lock(cfs_task_t *t)
+struct task_struct{
+ mode_t umask;
+ sigset_t blocked;
+
+ pid_t pid;
+ pid_t pgrp;
+
+ uid_t uid,euid,suid,fsuid;
+ gid_t gid,egid,sgid,fsgid;
+
+ int ngroups;
+ int cgroups;
+ gid_t groups[NGROUPS];
+ struct group_info *group_info;
+ kernel_cap_t cap_effective,
+ cap_inheritable,
+ cap_permitted;
+
+ char comm[CFS_CURPROC_COMM_MAX];
+ void *journal_info;
+ struct vfsmount *fs;
+};
+
+static inline void task_lock(struct task_struct *t)
{
}
-static inline void task_unlock(cfs_task_t *t)
+static inline void task_unlock(struct task_struct *t)
{
}
#define TASKSLT_MAGIC 'TSLT' /* Task Slot */
typedef struct _TASK_MAN {
+ ULONG Magic; /* Magic and Flags */
+ ULONG Flags;
- ULONG Magic; /* Magic and Flags */
- ULONG Flags;
-
- spinlock_t Lock; /* Protection lock */
-
- cfs_mem_cache_t * slab; /* Memory slab for task slot */
+ spinlock_t Lock; /* Protection lock */
- ULONG NumOfTasks; /* Total tasks (threads) */
- LIST_ENTRY TaskList; /* List of task slots */
+ struct kmem_cache *slab; /* Memory slab for task slot */
+ ULONG NumOfTasks; /* Total tasks (threads) */
+ LIST_ENTRY TaskList; /* List of task slots */
} TASK_MAN, *PTASK_MAN;
typedef struct _TASK_SLOT {
- ULONG Magic; /* Magic and Flags */
- ULONG Flags;
+ ULONG Magic; /* Magic and Flags */
+ ULONG Flags;
- LIST_ENTRY Link; /* To be linked to TaskMan */
+ LIST_ENTRY Link; /* To be linked to TaskMan */
- event_t Event; /* Schedule event */
+ event_t Event; /* Schedule event */
- HANDLE Pid; /* Process id */
- HANDLE Tid; /* Thread id */
- PETHREAD Tet; /* Pointer to ethread */
+ HANDLE Pid; /* Process id */
+ HANDLE Tid; /* Thread id */
+ PETHREAD Tet; /* Pointer to ethread */
atomic_t count; /* refer count */
atomic_t hits; /* times of waken event singaled */
- KIRQL irql; /* irql for rwlock ... */
+ KIRQL irql; /* irql for rwlock ... */
- cfs_task_t task; /* linux task part */
+ struct task_struct task; /* linux task part */
} TASK_SLOT, *PTASK_SLOT;
-#define current cfs_current()
-#define set_current_state(s) do {;} while (0)
-#define cfs_set_current_state(state) set_current_state(state)
+#define set_current_state(s) do {;} while (0)
-#define wait_event(wq, condition) \
+#define wait_event(wq, condition) \
do { \
- cfs_waitlink_t __wait; \
- \
- cfs_waitlink_init(&__wait); \
- while (TRUE) { \
- cfs_waitq_add(&wq, &__wait); \
- if (condition) { \
- break; \
- } \
- cfs_waitq_wait(&__wait, CFS_TASK_INTERRUPTIBLE); \
- cfs_waitq_del(&wq, &__wait); \
- } \
- cfs_waitq_del(&wq, &__wait); \
+ wait_queue_t __wait; \
+ \
+ init_waitqueue_entry_current(&__wait); \
+ while (TRUE) { \
+ add_wait_queue(&wq, &__wait); \
+ if (condition) { \
+ break; \
+ } \
+ waitq_wait(&__wait, TASK_INTERRUPTIBLE); \
+ remove_wait_queue(&wq, &__wait); \
+ } \
+ remove_wait_queue(&wq, &__wait); \
} while(0)
-#define cfs_wait_event_interruptible(wq, condition, __ret) \
-do { \
- cfs_waitlink_t __wait; \
- \
- __ret = 0; \
- cfs_waitlink_init(&__wait); \
- while (TRUE) { \
- cfs_waitq_add(&wq, &__wait); \
- if (condition) { \
- break; \
- } \
- cfs_waitq_wait(&__wait, CFS_TASK_INTERRUPTIBLE); \
- cfs_waitq_del(&wq, &__wait); \
- } \
- cfs_waitq_del(&wq, &__wait); \
-} while(0)
+#define wait_event_interruptible(wq, condition) \
+{ \
+ wait_queue_t __wait; \
+ \
+ __ret = 0; \
+ init_waitqueue_entry_current(&__wait); \
+ while (TRUE) { \
+ add_wait_queue(&wq, &__wait); \
+ if (condition) { \
+ break; \
+ } \
+ waitq_wait(&__wait, TASK_INTERRUPTIBLE);\
+ remove_wait_queue(&wq, &__wait); \
+ } \
+ remove_wait_queue(&wq, &__wait); \
+ __ret; \
+}
-# define cfs_wait_event_interruptible_exclusive(wq, condition, rc) \
- cfs_wait_event_interruptible(wq, condition, rc)
+# define wait_event_interruptible_exclusive(wq, condition) \
+ wait_event_interruptible(wq, condition)
/*
retval == 0; condition met; we're good.
retval > 0; timed out.
*/
-#define cfs_waitq_wait_event_interruptible_timeout( \
- wq, condition, timeout, rc) \
+#define wait_event_interruptible_timeout(wq, condition, timeout)\
do { \
- cfs_waitlink_t __wait; \
- \
- rc = 0; \
- cfs_waitlink_init(&__wait); \
- while (TRUE) { \
- cfs_waitq_add(&wq, &__wait); \
- if (condition) { \
- break; \
- } \
- if (cfs_waitq_timedwait(&__wait, \
- CFS_TASK_INTERRUPTIBLE, timeout) == 0) { \
- rc = TRUE; \
- break; \
- } \
- cfs_waitq_del(&wq, &__wait); \
- } \
- cfs_waitq_del(&wq, &__wait); \
+ wait_queue_t __wait; \
+ \
+ init_waitqueue_entry_current(&__wait); \
+ while (TRUE) { \
+ add_wait_queue(&wq, &__wait); \
+ if (condition) { \
+ break; \
+ } \
+ if (waitq_timedwait(&__wait, \
+ TASK_INTERRUPTIBLE, timeout) == 0) { \
+ break; \
+ } \
+ remove_wait_queue(&wq, &__wait); \
+ } \
+ remove_wait_queue(&wq, &__wait); \
} while(0)
-
-#define cfs_waitq_wait_event_timeout \
- cfs_waitq_wait_event_interruptible_timeout
-
int init_task_manager();
void cleanup_task_manager();
-cfs_task_t * cfs_current();
-int wake_up_process(cfs_task_t * task);
-void sleep_on(cfs_waitq_t *waitq);
+struct task_struct * current;
+int wake_up_process(struct task_struct * task);
+void sleep_on(wait_queue_head_t *waitq);
#define might_sleep() do {} while(0)
-#define CFS_DECL_JOURNAL_DATA
-#define CFS_PUSH_JOURNAL do {;} while(0)
-#define CFS_POP_JOURNAL do {;} while(0)
+#define DECL_JOURNAL_DATA
+#define PUSH_JOURNAL do {;} while(0)
+#define POP_JOURNAL do {;} while(0)
/* module related definitions */
#define __init
#endif
-struct module {
+struct module{
const char *name;
};
extern struct module libcfs_global_module;
#define THIS_MODULE &libcfs_global_module
-#define request_module(x) (0)
-#define EXPORT_SYMBOL(s)
+#define request_module(x, y) (0)
#define MODULE_AUTHOR(s)
#define MODULE_DESCRIPTION(s)
#define MODULE_LICENSE(s)
/* Module interfaces */
#define cfs_module(name, version, init, fini) \
-module_init(init); \
-module_exit(fini)
+ module_init(init); \
+ module_exit(fini)
#define module_refcount(x) (1)
/*
#define GOLDEN_RATIO_PRIME_32 0x9e370001UL
#if 0 /* defined in libcfs/libcfs_hash.h */
-static inline u32 hash_long(u32 val, unsigned int bits)
+static inline u32 cfs_hash_long(u32 val, unsigned int bits)
{
/* On some cpus multiply is faster, on others gcc will do shifts */
u32 hash = val * GOLDEN_RATIO_PRIME_32;
#define CFS_TIMER_FLAG_INITED 0x00000001 // Initialized already
#define CFS_TIMER_FLAG_TIMERED 0x00000002 // KeSetTimer is called
-typedef struct cfs_timer {
+struct timer_list {
KSPIN_LOCK Lock;
void (*proc)(ulong_ptr_t);
void * arg;
-} cfs_timer_t;
+};
/*
* libcfs globals initialization/cleanup
#define SMP_CACHE_BYTES 128
-#define NR_CPUS (32)
+#define NR_CPUS (32)
#define smp_num_cpus ((CCHAR)KeNumberProcessors)
-#define num_possible_cpus() smp_num_cpus
-#define num_online_cpus() smp_num_cpus
-#define smp_processor_id() ((USHORT)KeGetCurrentProcessorNumber())
+#define num_possible_cpus() smp_num_cpus
+#define num_online_cpus() smp_num_cpus
+#define smp_processor_id() ((USHORT)KeGetCurrentProcessorNumber())
#define smp_call_function(f, a, n, w) do {} while(0)
#define smp_rmb() do {} while(0)
* Irp related
*/
-#define NR_IRQS 512
-#define in_interrupt() (0)
-#define cfs_in_interrupt() in_interrupt()
+#define NR_IRQS 512
+#define in_interrupt() (0)
/*
* printk flags
#define unlikely(exp) (exp)
#endif
-#define lock_kernel() do {} while(0)
-#define unlock_kernel() do {} while(0)
-
#define local_irq_save(x)
#define local_irq_restore(x)
-#define THREAD_NAME
-
#define va_copy(_d, _s) (_d = _s)
char *strnchr(const char *s, size_t count, int c);
#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER ((pthread_mutex_t) -2)
#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER ((pthread_mutex_t) -3)
-typedef struct file {
- int foo;
-} cfs_file_t;
+struct file {
+ int foo;
+};
#include "../user-prim.h"
#include "../user-lock.h"
static inline int try_module_get(struct module *module)
{
- return 1;
+ return 1;
}
static inline void module_put(struct module *module)
* sigset_t routines
*/
-typedef sigset_t cfs_sigset_t;
#define sigaddset(what,sig) (*(what) |= (1<<(sig)), 0)
#define sigdelset(what,sig) (*(what) &= ~(1<<(sig)), 0)
#define sigemptyset(what) (*(what) = 0, 0)
#define sigismember(what,sig) (((*(what)) & (1<<(sig))) != 0)
static __inline int
-sigprocmask(int sig, cfs_sigset_t *w1, cfs_sigset_t *w2) {
+sigprocmask(int sig, sigset_t *w1, sigset_t *w2) {
return 0;
}
static __inline int
-sigpending(cfs_sigset_t *what) {
+sigpending(sigset_t *what) {
return 0;
}
/*
- * Linux kernel version definition
- */
-
-#define KERNEL_VERSION(a,b,c) ((a)*100+(b)*10+c)
-
-/*
* linux ioctl coding definitions
*/
int setenv(const char *envname, const char *envval, int overwrite);
-struct utsname {
+typedef struct utsname {
char sysname[64];
char nodename[64];
char release[128];
git://git.whamcloud.com / fs / lustre-release.git / blobdiff