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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [sunrpc/] [auth.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 * linux/fs/nfs/rpcauth.c
 *
 * Generic RPC authentication API.
 *
 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
 */
 
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/socket.h>
#include <linux/sunrpc/clnt.h>
#include <linux/spinlock.h>
 
#ifdef RPC_DEBUG
# define RPCDBG_FACILITY        RPCDBG_AUTH
#endif
 
#define RPC_MAXFLAVOR   8
 
static struct rpc_authops *     auth_flavors[RPC_MAXFLAVOR] = {
        &authnull_ops,          /* AUTH_NULL */
        &authunix_ops,          /* AUTH_UNIX */
        NULL,                   /* others can be loadable modules */
};
 
int
rpcauth_register(struct rpc_authops *ops)
{
        unsigned int    flavor;
 
        if ((flavor = ops->au_flavor) >= RPC_MAXFLAVOR)
                return -EINVAL;
        if (auth_flavors[flavor] != NULL)
                return -EPERM;          /* what else? */
        auth_flavors[flavor] = ops;
        return 0;
}
 
int
rpcauth_unregister(struct rpc_authops *ops)
{
        unsigned int    flavor;
 
        if ((flavor = ops->au_flavor) >= RPC_MAXFLAVOR)
                return -EINVAL;
        if (auth_flavors[flavor] != ops)
                return -EPERM;          /* what else? */
        auth_flavors[flavor] = NULL;
        return 0;
}
 
struct rpc_auth *
rpcauth_create(unsigned int flavor, struct rpc_clnt *clnt)
{
        struct rpc_authops      *ops;
 
        if (flavor >= RPC_MAXFLAVOR || !(ops = auth_flavors[flavor]))
                return NULL;
        clnt->cl_auth = ops->create(clnt);
        return clnt->cl_auth;
}
 
void
rpcauth_destroy(struct rpc_auth *auth)
{
        auth->au_ops->destroy(auth);
}
 
static spinlock_t rpc_credcache_lock = SPIN_LOCK_UNLOCKED;
 
/*
 * Initialize RPC credential cache
 */
void
rpcauth_init_credcache(struct rpc_auth *auth)
{
        memset(auth->au_credcache, 0, sizeof(auth->au_credcache));
        auth->au_nextgc = jiffies + (auth->au_expire >> 1);
}
 
/*
 * Destroy an unreferenced credential
 */
static inline void
rpcauth_crdestroy(struct rpc_cred *cred)
{
#ifdef RPC_DEBUG
        if (cred->cr_magic != RPCAUTH_CRED_MAGIC)
                BUG();
        cred->cr_magic = 0;
        if (atomic_read(&cred->cr_count) || cred->cr_auth)
                BUG();
#endif
        cred->cr_ops->crdestroy(cred);
}
 
/*
 * Destroy a list of credentials
 */
static inline
void rpcauth_destroy_credlist(struct rpc_cred *head)
{
        struct rpc_cred *cred;
 
        while ((cred = head) != NULL) {
                head = cred->cr_next;
                rpcauth_crdestroy(cred);
        }
}
 
/*
 * Clear the RPC credential cache, and delete those credentials
 * that are not referenced.
 */
void
rpcauth_free_credcache(struct rpc_auth *auth)
{
        struct rpc_cred **q, *cred, *free = NULL;
        int             i;
 
        spin_lock(&rpc_credcache_lock);
        for (i = 0; i < RPC_CREDCACHE_NR; i++) {
                q = &auth->au_credcache[i];
                while ((cred = *q) != NULL) {
                        *q = cred->cr_next;
                        cred->cr_auth = NULL;
                        if (atomic_read(&cred->cr_count) == 0) {
                                cred->cr_next = free;
                                free = cred;
                        } else
                                cred->cr_next = NULL;
                }
        }
        spin_unlock(&rpc_credcache_lock);
        rpcauth_destroy_credlist(free);
}
 
/*
 * Remove stale credentials. Avoid sleeping inside the loop.
 */
static void
rpcauth_gc_credcache(struct rpc_auth *auth)
{
        struct rpc_cred **q, *cred, *free = NULL;
        int             i;
 
        dprintk("RPC: gc'ing RPC credentials for auth %p\n", auth);
        spin_lock(&rpc_credcache_lock);
        for (i = 0; i < RPC_CREDCACHE_NR; i++) {
                q = &auth->au_credcache[i];
                while ((cred = *q) != NULL) {
                        if (!atomic_read(&cred->cr_count) &&
                            time_before(cred->cr_expire, jiffies)) {
                                *q = cred->cr_next;
                                cred->cr_auth = NULL;
                                cred->cr_next = free;
                                free = cred;
                                continue;
                        }
                        q = &cred->cr_next;
                }
        }
        spin_unlock(&rpc_credcache_lock);
        rpcauth_destroy_credlist(free);
        auth->au_nextgc = jiffies + auth->au_expire;
}
 
/*
 * Insert credential into cache
 */
void
rpcauth_insert_credcache(struct rpc_auth *auth, struct rpc_cred *cred)
{
        int             nr;
 
        nr = (cred->cr_uid & RPC_CREDCACHE_MASK);
        spin_lock(&rpc_credcache_lock);
        cred->cr_next = auth->au_credcache[nr];
        auth->au_credcache[nr] = cred;
        cred->cr_auth = auth;
        get_rpccred(cred);
        spin_unlock(&rpc_credcache_lock);
}
 
/*
 * Look up a process' credentials in the authentication cache
 */
static struct rpc_cred *
rpcauth_lookup_credcache(struct rpc_auth *auth, int taskflags)
{
        struct rpc_cred **q, *cred = NULL;
        int             nr = 0;
 
        if (!(taskflags & RPC_TASK_ROOTCREDS))
                nr = current->uid & RPC_CREDCACHE_MASK;
 
        if (time_before(auth->au_nextgc, jiffies))
                rpcauth_gc_credcache(auth);
 
        spin_lock(&rpc_credcache_lock);
        q = &auth->au_credcache[nr];
        while ((cred = *q) != NULL) {
                if (!(cred->cr_flags & RPCAUTH_CRED_DEAD) &&
                    cred->cr_ops->crmatch(cred, taskflags)) {
                        *q = cred->cr_next;
                        break;
                }
                q = &cred->cr_next;
        }
        spin_unlock(&rpc_credcache_lock);
 
        if (!cred) {
                cred = auth->au_ops->crcreate(taskflags);
#ifdef RPC_DEBUG
                if (cred)
                        cred->cr_magic = RPCAUTH_CRED_MAGIC;
#endif
        }
 
        if (cred)
                rpcauth_insert_credcache(auth, cred);
 
        return (struct rpc_cred *) cred;
}
 
/*
 * Remove cred handle from cache
 */
static void
rpcauth_remove_credcache(struct rpc_cred *cred)
{
        struct rpc_auth *auth = cred->cr_auth;
        struct rpc_cred **q, *cr;
        int             nr;
 
        nr = (cred->cr_uid & RPC_CREDCACHE_MASK);
        q = &auth->au_credcache[nr];
        while ((cr = *q) != NULL) {
                if (cred == cr) {
                        *q = cred->cr_next;
                        cred->cr_next = NULL;
                        cred->cr_auth = NULL;
                        break;
                }
                q = &cred->cr_next;
        }
}
 
struct rpc_cred *
rpcauth_lookupcred(struct rpc_auth *auth, int taskflags)
{
        dprintk("RPC:     looking up %s cred\n",
                auth->au_ops->au_name);
        return rpcauth_lookup_credcache(auth, taskflags);
}
 
struct rpc_cred *
rpcauth_bindcred(struct rpc_task *task)
{
        struct rpc_auth *auth = task->tk_auth;
 
        dprintk("RPC: %4d looking up %s cred\n",
                task->tk_pid, task->tk_auth->au_ops->au_name);
        task->tk_msg.rpc_cred = rpcauth_lookup_credcache(auth, task->tk_flags);
        if (task->tk_msg.rpc_cred == 0)
                task->tk_status = -ENOMEM;
        return task->tk_msg.rpc_cred;
}
 
int
rpcauth_matchcred(struct rpc_auth *auth, struct rpc_cred *cred, int taskflags)
{
        dprintk("RPC:     matching %s cred %d\n",
                auth->au_ops->au_name, taskflags);
        return cred->cr_ops->crmatch(cred, taskflags);
}
 
void
rpcauth_holdcred(struct rpc_task *task)
{
        dprintk("RPC: %4d holding %s cred %p\n",
                task->tk_pid, task->tk_auth->au_ops->au_name, task->tk_msg.rpc_cred);
        if (task->tk_msg.rpc_cred)
                get_rpccred(task->tk_msg.rpc_cred);
}
 
void
put_rpccred(struct rpc_cred *cred)
{
        if (!atomic_dec_and_lock(&cred->cr_count, &rpc_credcache_lock))
                return;
 
        if (cred->cr_auth && cred->cr_flags & RPCAUTH_CRED_DEAD)
                rpcauth_remove_credcache(cred);
 
        if (!cred->cr_auth) {
                spin_unlock(&rpc_credcache_lock);
                rpcauth_crdestroy(cred);
                return;
        }
        cred->cr_expire = jiffies + cred->cr_auth->au_expire;
        spin_unlock(&rpc_credcache_lock);
}
 
void
rpcauth_unbindcred(struct rpc_task *task)
{
        struct rpc_auth *auth = task->tk_auth;
        struct rpc_cred *cred = task->tk_msg.rpc_cred;
 
        dprintk("RPC: %4d releasing %s cred %p\n",
                task->tk_pid, auth->au_ops->au_name, cred);
 
        put_rpccred(cred);
        task->tk_msg.rpc_cred = NULL;
}
 
u32 *
rpcauth_marshcred(struct rpc_task *task, u32 *p)
{
        struct rpc_auth *auth = task->tk_auth;
        struct rpc_cred *cred = task->tk_msg.rpc_cred;
 
        dprintk("RPC: %4d marshaling %s cred %p\n",
                task->tk_pid, auth->au_ops->au_name, cred);
        return cred->cr_ops->crmarshal(task, p,
                                task->tk_flags & RPC_CALL_REALUID);
}
 
u32 *
rpcauth_checkverf(struct rpc_task *task, u32 *p)
{
        struct rpc_auth *auth = task->tk_auth;
        struct rpc_cred *cred = task->tk_msg.rpc_cred;
 
        dprintk("RPC: %4d validating %s cred %p\n",
                task->tk_pid, auth->au_ops->au_name, cred);
        return cred->cr_ops->crvalidate(task, p);
}
 
int
rpcauth_refreshcred(struct rpc_task *task)
{
        struct rpc_auth *auth = task->tk_auth;
        struct rpc_cred *cred = task->tk_msg.rpc_cred;
 
        dprintk("RPC: %4d refreshing %s cred %p\n",
                task->tk_pid, auth->au_ops->au_name, cred);
        task->tk_status = cred->cr_ops->crrefresh(task);
        return task->tk_status;
}
 
void
rpcauth_invalcred(struct rpc_task *task)
{
        dprintk("RPC: %4d invalidating %s cred %p\n",
                task->tk_pid, task->tk_auth->au_ops->au_name, task->tk_msg.rpc_cred);
        spin_lock(&rpc_credcache_lock);
        if (task->tk_msg.rpc_cred)
                task->tk_msg.rpc_cred->cr_flags &= ~RPCAUTH_CRED_UPTODATE;
        spin_unlock(&rpc_credcache_lock);
}
 
int
rpcauth_uptodatecred(struct rpc_task *task)
{
        int retval;
        spin_lock(&rpc_credcache_lock);
        retval = !(task->tk_msg.rpc_cred) ||
                (task->tk_msg.rpc_cred->cr_flags & RPCAUTH_CRED_UPTODATE);
        spin_unlock(&rpc_credcache_lock);
        return retval;
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [sunrpc/] [auth.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* linux/fs/nfs/rpcauth.c`
3			`*`
4			`* Generic RPC authentication API.`
5			`*`
6			`* Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>`
7			`*/`
8
9			`#include <linux/types.h>`
10			`#include <linux/sched.h>`
11			`#include <linux/slab.h>`
12			`#include <linux/errno.h>`
13			`#include <linux/socket.h>`
14			`#include <linux/sunrpc/clnt.h>`
15			`#include <linux/spinlock.h>`
16
17			`#ifdef RPC_DEBUG`
18			`# define RPCDBG_FACILITY RPCDBG_AUTH`
19			`#endif`
20
21			`#define RPC_MAXFLAVOR 8`
22
23			`static struct rpc_authops * auth_flavors[RPC_MAXFLAVOR] = {`
24			`&authnull_ops, /* AUTH_NULL */`
25			`&authunix_ops, /* AUTH_UNIX */`
26			`NULL, /* others can be loadable modules */`
27			`};`
28
29			`int`
30			`rpcauth_register(struct rpc_authops *ops)`
31			`{`
32			`unsigned int flavor;`
33
34			`if ((flavor = ops->au_flavor) >= RPC_MAXFLAVOR)`
35			`return -EINVAL;`
36			`if (auth_flavors[flavor] != NULL)`
37			`return -EPERM; /* what else? */`
38			`auth_flavors[flavor] = ops;`
39			`return 0;`
40			`}`
41
42			`int`
43			`rpcauth_unregister(struct rpc_authops *ops)`
44			`{`
45			`unsigned int flavor;`
46
47			`if ((flavor = ops->au_flavor) >= RPC_MAXFLAVOR)`
48			`return -EINVAL;`
49			`if (auth_flavors[flavor] != ops)`
50			`return -EPERM; /* what else? */`
51			`auth_flavors[flavor] = NULL;`
52			`return 0;`
53			`}`
54
55			`struct rpc_auth *`
56			`rpcauth_create(unsigned int flavor, struct rpc_clnt *clnt)`
57			`{`
58			`struct rpc_authops *ops;`
59
60			`if (flavor >= RPC_MAXFLAVOR \|\| !(ops = auth_flavors[flavor]))`
61			`return NULL;`
62			`clnt->cl_auth = ops->create(clnt);`
63			`return clnt->cl_auth;`
64			`}`
65
66			`void`
67			`rpcauth_destroy(struct rpc_auth *auth)`
68			`{`
69			`auth->au_ops->destroy(auth);`
70			`}`
71
72			`static spinlock_t rpc_credcache_lock = SPIN_LOCK_UNLOCKED;`
73
74			`/*`
75			`* Initialize RPC credential cache`
76			`*/`
77			`void`
78			`rpcauth_init_credcache(struct rpc_auth *auth)`
79			`{`
80			`memset(auth->au_credcache, 0, sizeof(auth->au_credcache));`
81			`auth->au_nextgc = jiffies + (auth->au_expire >> 1);`
82			`}`
83
84			`/*`
85			`* Destroy an unreferenced credential`
86			`*/`
87			`static inline void`
88			`rpcauth_crdestroy(struct rpc_cred *cred)`
89			`{`
90			`#ifdef RPC_DEBUG`
91			`if (cred->cr_magic != RPCAUTH_CRED_MAGIC)`
92			`BUG();`
93			`cred->cr_magic = 0;`
94			`if (atomic_read(&cred->cr_count) \|\| cred->cr_auth)`
95			`BUG();`
96			`#endif`
97			`cred->cr_ops->crdestroy(cred);`
98			`}`
99
100			`/*`
101			`* Destroy a list of credentials`
102			`*/`
103			`static inline`
104			`void rpcauth_destroy_credlist(struct rpc_cred *head)`
105			`{`
106			`struct rpc_cred *cred;`
107
108			`while ((cred = head) != NULL) {`
109			`head = cred->cr_next;`
110			`rpcauth_crdestroy(cred);`
111			`}`
112			`}`
113
114			`/*`
115			`* Clear the RPC credential cache, and delete those credentials`
116			`* that are not referenced.`
117			`*/`
118			`void`
119			`rpcauth_free_credcache(struct rpc_auth *auth)`
120			`{`
121			`struct rpc_cred *q, cred, *free = NULL;`
122			`int i;`
123
124			`spin_lock(&rpc_credcache_lock);`
125			`for (i = 0; i < RPC_CREDCACHE_NR; i++) {`
126			`q = &auth->au_credcache[i];`
127			`while ((cred = *q) != NULL) {`
128			`*q = cred->cr_next;`
129			`cred->cr_auth = NULL;`
130			`if (atomic_read(&cred->cr_count) == 0) {`
131			`cred->cr_next = free;`
132			`free = cred;`
133			`} else`
134			`cred->cr_next = NULL;`
135			`}`
136			`}`
137			`spin_unlock(&rpc_credcache_lock);`
138			`rpcauth_destroy_credlist(free);`
139			`}`
140
141			`/*`
142			`* Remove stale credentials. Avoid sleeping inside the loop.`
143			`*/`
144			`static void`
145			`rpcauth_gc_credcache(struct rpc_auth *auth)`
146			`{`
147			`struct rpc_cred *q, cred, *free = NULL;`
148			`int i;`
149
150			`dprintk("RPC: gc'ing RPC credentials for auth %p\n", auth);`
151			`spin_lock(&rpc_credcache_lock);`
152			`for (i = 0; i < RPC_CREDCACHE_NR; i++) {`
153			`q = &auth->au_credcache[i];`
154			`while ((cred = *q) != NULL) {`
155			`if (!atomic_read(&cred->cr_count) &&`
156			`time_before(cred->cr_expire, jiffies)) {`
157			`*q = cred->cr_next;`
158			`cred->cr_auth = NULL;`
159			`cred->cr_next = free;`
160			`free = cred;`
161			`continue;`
162			`}`
163			`q = &cred->cr_next;`
164			`}`
165			`}`
166			`spin_unlock(&rpc_credcache_lock);`
167			`rpcauth_destroy_credlist(free);`
168			`auth->au_nextgc = jiffies + auth->au_expire;`
169			`}`
170
171			`/*`
172			`* Insert credential into cache`
173			`*/`
174			`void`
175			`rpcauth_insert_credcache(struct rpc_auth auth, struct rpc_cred cred)`
176			`{`
177			`int nr;`
178
179			`nr = (cred->cr_uid & RPC_CREDCACHE_MASK);`
180			`spin_lock(&rpc_credcache_lock);`
181			`cred->cr_next = auth->au_credcache[nr];`
182			`auth->au_credcache[nr] = cred;`
183			`cred->cr_auth = auth;`
184			`get_rpccred(cred);`
185			`spin_unlock(&rpc_credcache_lock);`
186			`}`
187
188			`/*`
189			`* Look up a process' credentials in the authentication cache`
190			`*/`
191			`static struct rpc_cred *`
192			`rpcauth_lookup_credcache(struct rpc_auth *auth, int taskflags)`
193			`{`
194			`struct rpc_cred *q, cred = NULL;`
195			`int nr = 0;`
196
197			`if (!(taskflags & RPC_TASK_ROOTCREDS))`
198			`nr = current->uid & RPC_CREDCACHE_MASK;`
199
200			`if (time_before(auth->au_nextgc, jiffies))`
201			`rpcauth_gc_credcache(auth);`
202
203			`spin_lock(&rpc_credcache_lock);`
204			`q = &auth->au_credcache[nr];`
205			`while ((cred = *q) != NULL) {`
206			`if (!(cred->cr_flags & RPCAUTH_CRED_DEAD) &&`
207			`cred->cr_ops->crmatch(cred, taskflags)) {`
208			`*q = cred->cr_next;`
209			`break;`
210			`}`
211			`q = &cred->cr_next;`
212			`}`
213			`spin_unlock(&rpc_credcache_lock);`
214
215			`if (!cred) {`
216			`cred = auth->au_ops->crcreate(taskflags);`
217			`#ifdef RPC_DEBUG`
218			`if (cred)`
219			`cred->cr_magic = RPCAUTH_CRED_MAGIC;`
220			`#endif`
221			`}`
222
223			`if (cred)`
224			`rpcauth_insert_credcache(auth, cred);`
225
226			`return (struct rpc_cred *) cred;`
227			`}`
228
229			`/*`
230			`* Remove cred handle from cache`
231			`*/`
232			`static void`
233			`rpcauth_remove_credcache(struct rpc_cred *cred)`
234			`{`
235			`struct rpc_auth *auth = cred->cr_auth;`
236			`struct rpc_cred *q, cr;`
237			`int nr;`
238
239			`nr = (cred->cr_uid & RPC_CREDCACHE_MASK);`
240			`q = &auth->au_credcache[nr];`
241			`while ((cr = *q) != NULL) {`
242			`if (cred == cr) {`
243			`*q = cred->cr_next;`
244			`cred->cr_next = NULL;`
245			`cred->cr_auth = NULL;`
246			`break;`
247			`}`
248			`q = &cred->cr_next;`
249			`}`
250			`}`
251
252			`struct rpc_cred *`
253			`rpcauth_lookupcred(struct rpc_auth *auth, int taskflags)`
254			`{`
255			`dprintk("RPC: looking up %s cred\n",`
256			`auth->au_ops->au_name);`
257			`return rpcauth_lookup_credcache(auth, taskflags);`
258			`}`
259
260			`struct rpc_cred *`
261			`rpcauth_bindcred(struct rpc_task *task)`
262			`{`
263			`struct rpc_auth *auth = task->tk_auth;`
264
265			`dprintk("RPC: %4d looking up %s cred\n",`
266			`task->tk_pid, task->tk_auth->au_ops->au_name);`
267			`task->tk_msg.rpc_cred = rpcauth_lookup_credcache(auth, task->tk_flags);`
268			`if (task->tk_msg.rpc_cred == 0)`
269			`task->tk_status = -ENOMEM;`
270			`return task->tk_msg.rpc_cred;`
271			`}`
272
273			`int`
274			`rpcauth_matchcred(struct rpc_auth auth, struct rpc_cred cred, int taskflags)`
275			`{`
276			`dprintk("RPC: matching %s cred %d\n",`
277			`auth->au_ops->au_name, taskflags);`
278			`return cred->cr_ops->crmatch(cred, taskflags);`
279			`}`
280
281			`void`
282			`rpcauth_holdcred(struct rpc_task *task)`
283			`{`
284			`dprintk("RPC: %4d holding %s cred %p\n",`
285			`task->tk_pid, task->tk_auth->au_ops->au_name, task->tk_msg.rpc_cred);`
286			`if (task->tk_msg.rpc_cred)`
287			`get_rpccred(task->tk_msg.rpc_cred);`
288			`}`
289
290			`void`
291			`put_rpccred(struct rpc_cred *cred)`
292			`{`
293			`if (!atomic_dec_and_lock(&cred->cr_count, &rpc_credcache_lock))`
294			`return;`
295
296			`if (cred->cr_auth && cred->cr_flags & RPCAUTH_CRED_DEAD)`
297			`rpcauth_remove_credcache(cred);`
298
299			`if (!cred->cr_auth) {`
300			`spin_unlock(&rpc_credcache_lock);`
301			`rpcauth_crdestroy(cred);`
302			`return;`
303			`}`
304			`cred->cr_expire = jiffies + cred->cr_auth->au_expire;`
305			`spin_unlock(&rpc_credcache_lock);`
306			`}`
307
308			`void`
309			`rpcauth_unbindcred(struct rpc_task *task)`
310			`{`
311			`struct rpc_auth *auth = task->tk_auth;`
312			`struct rpc_cred *cred = task->tk_msg.rpc_cred;`
313
314			`dprintk("RPC: %4d releasing %s cred %p\n",`
315			`task->tk_pid, auth->au_ops->au_name, cred);`
316
317			`put_rpccred(cred);`
318			`task->tk_msg.rpc_cred = NULL;`
319			`}`
320
321			`u32 *`
322			`rpcauth_marshcred(struct rpc_task task, u32 p)`
323			`{`
324			`struct rpc_auth *auth = task->tk_auth;`
325			`struct rpc_cred *cred = task->tk_msg.rpc_cred;`
326
327			`dprintk("RPC: %4d marshaling %s cred %p\n",`
328			`task->tk_pid, auth->au_ops->au_name, cred);`
329			`return cred->cr_ops->crmarshal(task, p,`
330			`task->tk_flags & RPC_CALL_REALUID);`
331			`}`
332
333			`u32 *`
334			`rpcauth_checkverf(struct rpc_task task, u32 p)`
335			`{`
336			`struct rpc_auth *auth = task->tk_auth;`
337			`struct rpc_cred *cred = task->tk_msg.rpc_cred;`
338
339			`dprintk("RPC: %4d validating %s cred %p\n",`
340			`task->tk_pid, auth->au_ops->au_name, cred);`
341			`return cred->cr_ops->crvalidate(task, p);`
342			`}`
343
344			`int`
345			`rpcauth_refreshcred(struct rpc_task *task)`
346			`{`
347			`struct rpc_auth *auth = task->tk_auth;`
348			`struct rpc_cred *cred = task->tk_msg.rpc_cred;`
349
350			`dprintk("RPC: %4d refreshing %s cred %p\n",`
351			`task->tk_pid, auth->au_ops->au_name, cred);`
352			`task->tk_status = cred->cr_ops->crrefresh(task);`
353			`return task->tk_status;`
354			`}`
355
356			`void`
357			`rpcauth_invalcred(struct rpc_task *task)`
358			`{`
359			`dprintk("RPC: %4d invalidating %s cred %p\n",`
360			`task->tk_pid, task->tk_auth->au_ops->au_name, task->tk_msg.rpc_cred);`
361			`spin_lock(&rpc_credcache_lock);`
362			`if (task->tk_msg.rpc_cred)`
363			`task->tk_msg.rpc_cred->cr_flags &= ~RPCAUTH_CRED_UPTODATE;`
364			`spin_unlock(&rpc_credcache_lock);`
365			`}`
366
367			`int`
368			`rpcauth_uptodatecred(struct rpc_task *task)`
369			`{`
370			`int retval;`
371			`spin_lock(&rpc_credcache_lock);`
372			`retval = !(task->tk_msg.rpc_cred) \|\|`
373			`(task->tk_msg.rpc_cred->cr_flags & RPCAUTH_CRED_UPTODATE);`
374			`spin_unlock(&rpc_credcache_lock);`
375			`return retval;`
376			`}`