URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [include/] [linux/] [sunrpc/] [sched.h] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * linux/include/linux/sunrpc/sched.h
 *
 * Scheduling primitives for kernel Sun RPC.
 *
 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
 */
 
#ifndef _LINUX_SUNRPC_SCHED_H_
#define _LINUX_SUNRPC_SCHED_H_
 
#include <linux/timer.h>
#include <linux/sunrpc/types.h>
#include <linux/rcupdate.h>
#include <linux/spinlock.h>
#include <linux/wait.h>
#include <linux/workqueue.h>
#include <linux/sunrpc/xdr.h>
 
/*
 * This is the actual RPC procedure call info.
 */
struct rpc_procinfo;
struct rpc_message {
        struct rpc_procinfo *   rpc_proc;       /* Procedure information */
        void *                  rpc_argp;       /* Arguments */
        void *                  rpc_resp;       /* Result */
        struct rpc_cred *       rpc_cred;       /* Credentials */
};
 
struct rpc_call_ops;
struct rpc_wait_queue;
struct rpc_wait {
        struct list_head        list;           /* wait queue links */
        struct list_head        links;          /* Links to related tasks */
        struct rpc_wait_queue * rpc_waitq;      /* RPC wait queue we're on */
};
 
/*
 * This is the RPC task struct
 */
struct rpc_task {
#ifdef RPC_DEBUG
        unsigned long           tk_magic;       /* 0xf00baa */
#endif
        atomic_t                tk_count;       /* Reference count */
        struct list_head        tk_task;        /* global list of tasks */
        struct rpc_clnt *       tk_client;      /* RPC client */
        struct rpc_rqst *       tk_rqstp;       /* RPC request */
        int                     tk_status;      /* result of last operation */
 
        /*
         * RPC call state
         */
        struct rpc_message      tk_msg;         /* RPC call info */
        __u8                    tk_garb_retry;
        __u8                    tk_cred_retry;
 
        unsigned long           tk_cookie;      /* Cookie for batching tasks */
 
        /*
         * timeout_fn   to be executed by timer bottom half
         * callback     to be executed after waking up
         * action       next procedure for async tasks
         * tk_ops       caller callbacks
         */
        void                    (*tk_timeout_fn)(struct rpc_task *);
        void                    (*tk_callback)(struct rpc_task *);
        void                    (*tk_action)(struct rpc_task *);
        const struct rpc_call_ops *tk_ops;
        void *                  tk_calldata;
 
        /*
         * tk_timer is used for async processing by the RPC scheduling
         * primitives. You should not access this directly unless
         * you have a pathological interest in kernel oopses.
         */
        struct timer_list       tk_timer;       /* kernel timer */
        unsigned long           tk_timeout;     /* timeout for rpc_sleep() */
        unsigned short          tk_flags;       /* misc flags */
        unsigned char           tk_priority : 2;/* Task priority */
        unsigned long           tk_runstate;    /* Task run status */
        struct workqueue_struct *tk_workqueue;  /* Normally rpciod, but could
                                                 * be any workqueue
                                                 */
        union {
                struct work_struct      tk_work;        /* Async task work queue */
                struct rpc_wait         tk_wait;        /* RPC wait */
                struct rcu_head         tk_rcu;         /* for task deletion */
        } u;
 
        unsigned short          tk_timeouts;    /* maj timeouts */
        size_t                  tk_bytes_sent;  /* total bytes sent */
        unsigned long           tk_start;       /* RPC task init timestamp */
        long                    tk_rtt;         /* round-trip time (jiffies) */
 
#ifdef RPC_DEBUG
        unsigned short          tk_pid;         /* debugging aid */
#endif
};
#define tk_xprt                 tk_client->cl_xprt
 
/* support walking a list of tasks on a wait queue */
#define task_for_each(task, pos, head) \
        list_for_each(pos, head) \
                if ((task=list_entry(pos, struct rpc_task, u.tk_wait.list)),1)
 
#define task_for_first(task, head) \
        if (!list_empty(head) &&  \
            ((task=list_entry((head)->next, struct rpc_task, u.tk_wait.list)),1))
 
typedef void                    (*rpc_action)(struct rpc_task *);
 
struct rpc_call_ops {
        void (*rpc_call_prepare)(struct rpc_task *, void *);
        void (*rpc_call_done)(struct rpc_task *, void *);
        void (*rpc_release)(void *);
};
 
 
/*
 * RPC task flags
 */
#define RPC_TASK_ASYNC          0x0001          /* is an async task */
#define RPC_TASK_SWAPPER        0x0002          /* is swapping in/out */
#define RPC_CALL_MAJORSEEN      0x0020          /* major timeout seen */
#define RPC_TASK_ROOTCREDS      0x0040          /* force root creds */
#define RPC_TASK_DYNAMIC        0x0080          /* task was kmalloc'ed */
#define RPC_TASK_KILLED         0x0100          /* task was killed */
#define RPC_TASK_SOFT           0x0200          /* Use soft timeouts */
#define RPC_TASK_NOINTR         0x0400          /* uninterruptible task */
 
#define RPC_IS_ASYNC(t)         ((t)->tk_flags & RPC_TASK_ASYNC)
#define RPC_IS_SWAPPER(t)       ((t)->tk_flags & RPC_TASK_SWAPPER)
#define RPC_DO_ROOTOVERRIDE(t)  ((t)->tk_flags & RPC_TASK_ROOTCREDS)
#define RPC_ASSASSINATED(t)     ((t)->tk_flags & RPC_TASK_KILLED)
#define RPC_DO_CALLBACK(t)      ((t)->tk_callback != NULL)
#define RPC_IS_SOFT(t)          ((t)->tk_flags & RPC_TASK_SOFT)
#define RPC_TASK_UNINTERRUPTIBLE(t) ((t)->tk_flags & RPC_TASK_NOINTR)
 
#define RPC_TASK_RUNNING        0
#define RPC_TASK_QUEUED         1
#define RPC_TASK_WAKEUP         2
#define RPC_TASK_HAS_TIMER      3
#define RPC_TASK_ACTIVE         4
 
#define RPC_IS_RUNNING(t)       test_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)
#define rpc_set_running(t)      set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)
#define rpc_test_and_set_running(t) \
                                test_and_set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)
#define rpc_clear_running(t)    \
        do { \
                smp_mb__before_clear_bit(); \
                clear_bit(RPC_TASK_RUNNING, &(t)->tk_runstate); \
                smp_mb__after_clear_bit(); \
        } while (0)
 
#define RPC_IS_QUEUED(t)        test_bit(RPC_TASK_QUEUED, &(t)->tk_runstate)
#define rpc_set_queued(t)       set_bit(RPC_TASK_QUEUED, &(t)->tk_runstate)
#define rpc_clear_queued(t)     \
        do { \
                smp_mb__before_clear_bit(); \
                clear_bit(RPC_TASK_QUEUED, &(t)->tk_runstate); \
                smp_mb__after_clear_bit(); \
        } while (0)
 
#define rpc_start_wakeup(t) \
        (test_and_set_bit(RPC_TASK_WAKEUP, &(t)->tk_runstate) == 0)
#define rpc_finish_wakeup(t) \
        do { \
                smp_mb__before_clear_bit(); \
                clear_bit(RPC_TASK_WAKEUP, &(t)->tk_runstate); \
                smp_mb__after_clear_bit(); \
        } while (0)
 
#define RPC_IS_ACTIVATED(t)     test_bit(RPC_TASK_ACTIVE, &(t)->tk_runstate)
 
/*
 * Task priorities.
 * Note: if you change these, you must also change
 * the task initialization definitions below.
 */
#define RPC_PRIORITY_LOW        0
#define RPC_PRIORITY_NORMAL     1
#define RPC_PRIORITY_HIGH       2
#define RPC_NR_PRIORITY         (RPC_PRIORITY_HIGH+1)
 
/*
 * RPC synchronization objects
 */
struct rpc_wait_queue {
        spinlock_t              lock;
        struct list_head        tasks[RPC_NR_PRIORITY]; /* task queue for each priority level */
        unsigned long           cookie;                 /* cookie of last task serviced */
        unsigned char           maxpriority;            /* maximum priority (0 if queue is not a priority queue) */
        unsigned char           priority;               /* current priority */
        unsigned char           count;                  /* # task groups remaining serviced so far */
        unsigned char           nr;                     /* # tasks remaining for cookie */
        unsigned short          qlen;                   /* total # tasks waiting in queue */
#ifdef RPC_DEBUG
        const char *            name;
#endif
};
 
/*
 * This is the # requests to send consecutively
 * from a single cookie.  The aim is to improve
 * performance of NFS operations such as read/write.
 */
#define RPC_BATCH_COUNT                 16
 
#ifndef RPC_DEBUG
# define RPC_WAITQ_INIT(var,qname) { \
                .lock = __SPIN_LOCK_UNLOCKED(var.lock), \
                .tasks = { \
                        [0] = LIST_HEAD_INIT(var.tasks[0]), \
                        [1] = LIST_HEAD_INIT(var.tasks[1]), \
                        [2] = LIST_HEAD_INIT(var.tasks[2]), \
                }, \
        }
#else
# define RPC_WAITQ_INIT(var,qname) { \
                .lock = __SPIN_LOCK_UNLOCKED(var.lock), \
                .tasks = { \
                        [0] = LIST_HEAD_INIT(var.tasks[0]), \
                        [1] = LIST_HEAD_INIT(var.tasks[1]), \
                        [2] = LIST_HEAD_INIT(var.tasks[2]), \
                }, \
                .name = qname, \
        }
#endif
# define RPC_WAITQ(var,qname)      struct rpc_wait_queue var = RPC_WAITQ_INIT(var,qname)
 
#define RPC_IS_PRIORITY(q)              ((q)->maxpriority > 0)
 
/*
 * Function prototypes
 */
struct rpc_task *rpc_new_task(struct rpc_clnt *, int flags,
                                const struct rpc_call_ops *ops, void *data);
struct rpc_task *rpc_run_task(struct rpc_clnt *clnt, int flags,
                                const struct rpc_call_ops *ops, void *data);
void            rpc_init_task(struct rpc_task *task, struct rpc_clnt *clnt,
                                int flags, const struct rpc_call_ops *ops,
                                void *data);
void            rpc_put_task(struct rpc_task *);
void            rpc_exit_task(struct rpc_task *);
void            rpc_release_calldata(const struct rpc_call_ops *, void *);
void            rpc_killall_tasks(struct rpc_clnt *);
void            rpc_execute(struct rpc_task *);
void            rpc_init_priority_wait_queue(struct rpc_wait_queue *, const char *);
void            rpc_init_wait_queue(struct rpc_wait_queue *, const char *);
void            rpc_sleep_on(struct rpc_wait_queue *, struct rpc_task *,
                                        rpc_action action, rpc_action timer);
void            rpc_wake_up_task(struct rpc_task *);
void            rpc_wake_up(struct rpc_wait_queue *);
struct rpc_task *rpc_wake_up_next(struct rpc_wait_queue *);
void            rpc_wake_up_status(struct rpc_wait_queue *, int);
void            rpc_delay(struct rpc_task *, unsigned long);
void *          rpc_malloc(struct rpc_task *, size_t);
void            rpc_free(void *);
int             rpciod_up(void);
void            rpciod_down(void);
int             __rpc_wait_for_completion_task(struct rpc_task *task, int (*)(void *));
#ifdef RPC_DEBUG
void            rpc_show_tasks(void);
#endif
int             rpc_init_mempool(void);
void            rpc_destroy_mempool(void);
extern struct workqueue_struct *rpciod_workqueue;
 
static inline void rpc_exit(struct rpc_task *task, int status)
{
        task->tk_status = status;
        task->tk_action = rpc_exit_task;
}
 
static inline int rpc_wait_for_completion_task(struct rpc_task *task)
{
        return __rpc_wait_for_completion_task(task, NULL);
}
 
#ifdef RPC_DEBUG
static inline const char * rpc_qname(struct rpc_wait_queue *q)
{
        return ((q && q->name) ? q->name : "unknown");
}
#endif
 
#endif /* _LINUX_SUNRPC_SCHED_H_ */

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [include/] [linux/] [sunrpc/] [sched.h] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* linux/include/linux/sunrpc/sched.h`
3			`*`
4			`* Scheduling primitives for kernel Sun RPC.`
5			`*`
6			`* Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>`
7			`*/`
8
9			`#ifndef _LINUX_SUNRPC_SCHED_H_`
10			`#define _LINUX_SUNRPC_SCHED_H_`
11
12			`#include <linux/timer.h>`
13			`#include <linux/sunrpc/types.h>`
14			`#include <linux/rcupdate.h>`
15			`#include <linux/spinlock.h>`
16			`#include <linux/wait.h>`
17			`#include <linux/workqueue.h>`
18			`#include <linux/sunrpc/xdr.h>`
19
20			`/*`
21			`* This is the actual RPC procedure call info.`
22			`*/`
23			`struct rpc_procinfo;`
24			`struct rpc_message {`
25			`struct rpc_procinfo * rpc_proc; /* Procedure information */`
26			`void * rpc_argp; /* Arguments */`
27			`void * rpc_resp; /* Result */`
28			`struct rpc_cred * rpc_cred; /* Credentials */`
29			`};`
30
31			`struct rpc_call_ops;`
32			`struct rpc_wait_queue;`
33			`struct rpc_wait {`
34			`struct list_head list; /* wait queue links */`
35			`struct list_head links; /* Links to related tasks */`
36			`struct rpc_wait_queue * rpc_waitq; /* RPC wait queue we're on */`
37			`};`
38
39			`/*`
40			`* This is the RPC task struct`
41			`*/`
42			`struct rpc_task {`
43			`#ifdef RPC_DEBUG`
44			`unsigned long tk_magic; /* 0xf00baa */`
45			`#endif`
46			`atomic_t tk_count; /* Reference count */`
47			`struct list_head tk_task; /* global list of tasks */`
48			`struct rpc_clnt * tk_client; /* RPC client */`
49			`struct rpc_rqst * tk_rqstp; /* RPC request */`
50			`int tk_status; /* result of last operation */`
51
52			`/*`
53			`* RPC call state`
54			`*/`
55			`struct rpc_message tk_msg; /* RPC call info */`
56			`__u8 tk_garb_retry;`
57			`__u8 tk_cred_retry;`
58
59			`unsigned long tk_cookie; /* Cookie for batching tasks */`
60
61			`/*`
62			`* timeout_fn to be executed by timer bottom half`
63			`* callback to be executed after waking up`
64			`* action next procedure for async tasks`
65			`* tk_ops caller callbacks`
66			`*/`
67			`void (tk_timeout_fn)(struct rpc_task );`
68			`void (tk_callback)(struct rpc_task );`
69			`void (tk_action)(struct rpc_task );`
70			`const struct rpc_call_ops *tk_ops;`
71			`void * tk_calldata;`
72
73			`/*`
74			`* tk_timer is used for async processing by the RPC scheduling`
75			`* primitives. You should not access this directly unless`
76			`* you have a pathological interest in kernel oopses.`
77			`*/`
78			`struct timer_list tk_timer; /* kernel timer */`
79			`unsigned long tk_timeout; /* timeout for rpc_sleep() */`
80			`unsigned short tk_flags; /* misc flags */`
81			`unsigned char tk_priority : 2;/* Task priority */`
82			`unsigned long tk_runstate; /* Task run status */`
83			`struct workqueue_struct tk_workqueue; / Normally rpciod, but could`
84			`* be any workqueue`
85			`*/`
86			`union {`
87			`struct work_struct tk_work; /* Async task work queue */`
88			`struct rpc_wait tk_wait; /* RPC wait */`
89			`struct rcu_head tk_rcu; /* for task deletion */`
90			`} u;`
91
92			`unsigned short tk_timeouts; /* maj timeouts */`
93			`size_t tk_bytes_sent; /* total bytes sent */`
94			`unsigned long tk_start; /* RPC task init timestamp */`
95			`long tk_rtt; /* round-trip time (jiffies) */`
96
97			`#ifdef RPC_DEBUG`
98			`unsigned short tk_pid; /* debugging aid */`
99			`#endif`
100			`};`
101			`#define tk_xprt tk_client->cl_xprt`
102
103			`/* support walking a list of tasks on a wait queue */`
104			`#define task_for_each(task, pos, head) \`
105			`list_for_each(pos, head) \`
106			`if ((task=list_entry(pos, struct rpc_task, u.tk_wait.list)),1)`
107
108			`#define task_for_first(task, head) \`
109			`if (!list_empty(head) && \`
110			`((task=list_entry((head)->next, struct rpc_task, u.tk_wait.list)),1))`
111
112			`typedef void (rpc_action)(struct rpc_task );`
113
114			`struct rpc_call_ops {`
115			`void (rpc_call_prepare)(struct rpc_task , void *);`
116			`void (rpc_call_done)(struct rpc_task , void *);`
117			`void (rpc_release)(void );`
118			`};`
119
120
121			`/*`
122			`* RPC task flags`
123			`*/`
124			`#define RPC_TASK_ASYNC 0x0001 /* is an async task */`
125			`#define RPC_TASK_SWAPPER 0x0002 /* is swapping in/out */`
126			`#define RPC_CALL_MAJORSEEN 0x0020 /* major timeout seen */`
127			`#define RPC_TASK_ROOTCREDS 0x0040 /* force root creds */`
128			`#define RPC_TASK_DYNAMIC 0x0080 /* task was kmalloc'ed */`
129			`#define RPC_TASK_KILLED 0x0100 /* task was killed */`
130			`#define RPC_TASK_SOFT 0x0200 /* Use soft timeouts */`
131			`#define RPC_TASK_NOINTR 0x0400 /* uninterruptible task */`
132
133			`#define RPC_IS_ASYNC(t) ((t)->tk_flags & RPC_TASK_ASYNC)`
134			`#define RPC_IS_SWAPPER(t) ((t)->tk_flags & RPC_TASK_SWAPPER)`
135			`#define RPC_DO_ROOTOVERRIDE(t) ((t)->tk_flags & RPC_TASK_ROOTCREDS)`
136			`#define RPC_ASSASSINATED(t) ((t)->tk_flags & RPC_TASK_KILLED)`
137			`#define RPC_DO_CALLBACK(t) ((t)->tk_callback != NULL)`
138			`#define RPC_IS_SOFT(t) ((t)->tk_flags & RPC_TASK_SOFT)`
139			`#define RPC_TASK_UNINTERRUPTIBLE(t) ((t)->tk_flags & RPC_TASK_NOINTR)`
140
141			`#define RPC_TASK_RUNNING 0`
142			`#define RPC_TASK_QUEUED 1`
143			`#define RPC_TASK_WAKEUP 2`
144			`#define RPC_TASK_HAS_TIMER 3`
145			`#define RPC_TASK_ACTIVE 4`
146
147			`#define RPC_IS_RUNNING(t) test_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)`
148			`#define rpc_set_running(t) set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)`
149			`#define rpc_test_and_set_running(t) \`
150			`test_and_set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)`
151			`#define rpc_clear_running(t) \`
152			`do { \`
153			`smp_mb__before_clear_bit(); \`
154			`clear_bit(RPC_TASK_RUNNING, &(t)->tk_runstate); \`
155			`smp_mb__after_clear_bit(); \`
156			`} while (0)`
157
158			`#define RPC_IS_QUEUED(t) test_bit(RPC_TASK_QUEUED, &(t)->tk_runstate)`
159			`#define rpc_set_queued(t) set_bit(RPC_TASK_QUEUED, &(t)->tk_runstate)`
160			`#define rpc_clear_queued(t) \`
161			`do { \`
162			`smp_mb__before_clear_bit(); \`
163			`clear_bit(RPC_TASK_QUEUED, &(t)->tk_runstate); \`
164			`smp_mb__after_clear_bit(); \`
165			`} while (0)`
166
167			`#define rpc_start_wakeup(t) \`
168			`(test_and_set_bit(RPC_TASK_WAKEUP, &(t)->tk_runstate) == 0)`
169			`#define rpc_finish_wakeup(t) \`
170			`do { \`
171			`smp_mb__before_clear_bit(); \`
172			`clear_bit(RPC_TASK_WAKEUP, &(t)->tk_runstate); \`
173			`smp_mb__after_clear_bit(); \`
174			`} while (0)`
175
176			`#define RPC_IS_ACTIVATED(t) test_bit(RPC_TASK_ACTIVE, &(t)->tk_runstate)`
177
178			`/*`
179			`* Task priorities.`
180			`* Note: if you change these, you must also change`
181			`* the task initialization definitions below.`
182			`*/`
183			`#define RPC_PRIORITY_LOW 0`
184			`#define RPC_PRIORITY_NORMAL 1`
185			`#define RPC_PRIORITY_HIGH 2`
186			`#define RPC_NR_PRIORITY (RPC_PRIORITY_HIGH+1)`
187
188			`/*`
189			`* RPC synchronization objects`
190			`*/`
191			`struct rpc_wait_queue {`
192			`spinlock_t lock;`
193			`struct list_head tasks[RPC_NR_PRIORITY]; /* task queue for each priority level */`
194			`unsigned long cookie; /* cookie of last task serviced */`
195			`unsigned char maxpriority; /* maximum priority (0 if queue is not a priority queue) */`
196			`unsigned char priority; /* current priority */`
197			`unsigned char count; /* # task groups remaining serviced so far */`
198			`unsigned char nr; /* # tasks remaining for cookie */`
199			`unsigned short qlen; /* total # tasks waiting in queue */`
200			`#ifdef RPC_DEBUG`
201			`const char * name;`
202			`#endif`
203			`};`
204
205			`/*`
206			`* This is the # requests to send consecutively`
207			`* from a single cookie. The aim is to improve`
208			`* performance of NFS operations such as read/write.`
209			`*/`
210			`#define RPC_BATCH_COUNT 16`
211
212			`#ifndef RPC_DEBUG`
213			`# define RPC_WAITQ_INIT(var,qname) { \`
214			`.lock = __SPIN_LOCK_UNLOCKED(var.lock), \`
215			`.tasks = { \`
216			`[0] = LIST_HEAD_INIT(var.tasks[0]), \`
217			`[1] = LIST_HEAD_INIT(var.tasks[1]), \`
218			`[2] = LIST_HEAD_INIT(var.tasks[2]), \`
219			`}, \`
220			`}`
221			`#else`
222			`# define RPC_WAITQ_INIT(var,qname) { \`
223			`.lock = __SPIN_LOCK_UNLOCKED(var.lock), \`
224			`.tasks = { \`
225			`[0] = LIST_HEAD_INIT(var.tasks[0]), \`
226			`[1] = LIST_HEAD_INIT(var.tasks[1]), \`
227			`[2] = LIST_HEAD_INIT(var.tasks[2]), \`
228			`}, \`
229			`.name = qname, \`
230			`}`
231			`#endif`
232			`# define RPC_WAITQ(var,qname) struct rpc_wait_queue var = RPC_WAITQ_INIT(var,qname)`
233
234			`#define RPC_IS_PRIORITY(q) ((q)->maxpriority > 0)`
235
236			`/*`
237			`* Function prototypes`
238			`*/`
239			`struct rpc_task rpc_new_task(struct rpc_clnt , int flags,`
240			`const struct rpc_call_ops ops, void data);`
241			`struct rpc_task rpc_run_task(struct rpc_clnt clnt, int flags,`
242			`const struct rpc_call_ops ops, void data);`
243			`void rpc_init_task(struct rpc_task task, struct rpc_clnt clnt,`
244			`int flags, const struct rpc_call_ops *ops,`
245			`void *data);`
246			`void rpc_put_task(struct rpc_task *);`
247			`void rpc_exit_task(struct rpc_task *);`
248			`void rpc_release_calldata(const struct rpc_call_ops , void );`
249			`void rpc_killall_tasks(struct rpc_clnt *);`
250			`void rpc_execute(struct rpc_task *);`
251			`void rpc_init_priority_wait_queue(struct rpc_wait_queue , const char );`
252			`void rpc_init_wait_queue(struct rpc_wait_queue , const char );`
253			`void rpc_sleep_on(struct rpc_wait_queue , struct rpc_task ,`
254			`rpc_action action, rpc_action timer);`
255			`void rpc_wake_up_task(struct rpc_task *);`
256			`void rpc_wake_up(struct rpc_wait_queue *);`
257			`struct rpc_task rpc_wake_up_next(struct rpc_wait_queue );`
258			`void rpc_wake_up_status(struct rpc_wait_queue *, int);`
259			`void rpc_delay(struct rpc_task *, unsigned long);`
260			`void * rpc_malloc(struct rpc_task *, size_t);`
261			`void rpc_free(void *);`
262			`int rpciod_up(void);`
263			`void rpciod_down(void);`
264			`int __rpc_wait_for_completion_task(struct rpc_task task, int ()(void *));`
265			`#ifdef RPC_DEBUG`
266			`void rpc_show_tasks(void);`
267			`#endif`
268			`int rpc_init_mempool(void);`
269			`void rpc_destroy_mempool(void);`
270			`extern struct workqueue_struct *rpciod_workqueue;`
271
272			`static inline void rpc_exit(struct rpc_task *task, int status)`
273			`{`
274			`task->tk_status = status;`
275			`task->tk_action = rpc_exit_task;`
276			`}`
277
278			`static inline int rpc_wait_for_completion_task(struct rpc_task *task)`
279			`{`
280			`return __rpc_wait_for_completion_task(task, NULL);`
281			`}`
282
283			`#ifdef RPC_DEBUG`
284			`static inline const char * rpc_qname(struct rpc_wait_queue *q)`
285			`{`
286			`return ((q && q->name) ? q->name : "unknown");`
287			`}`
288			`#endif`
289
290			`#endif /* _LINUX_SUNRPC_SCHED_H_ */`