Whamcloud - gitweb
305d4c5b524616b74e11827ac8c9b33741a9ec9e
[fs/lustre-release.git] / lustre / ptlrpc / gss / gss_keyring.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * Copyright (C) 2007 Cluster File Systems, Inc.
5  *   Author: Eric Mei <ericm@clusterfs.com>
6  *
7  *   This file is part of Lustre, http://www.lustre.org.
8  *
9  *   Lustre is free software; you can redistribute it and/or
10  *   modify it under the terms of version 2 of the GNU General Public
11  *   License as published by the Free Software Foundation.
12  *
13  *   Lustre is distributed in the hope that it will be useful,
14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *   GNU General Public License for more details.
17  *
18  *   You should have received a copy of the GNU General Public License
19  *   along with Lustre; if not, write to the Free Software
20  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  */
22
23 #ifndef EXPORT_SYMTAB
24 # define EXPORT_SYMTAB
25 #endif
26 #define DEBUG_SUBSYSTEM S_SEC
27 #ifdef __KERNEL__
28 #include <linux/init.h>
29 #include <linux/module.h>
30 #include <linux/slab.h>
31 #include <linux/dcache.h>
32 #include <linux/fs.h>
33 #include <linux/random.h>
34 #include <linux/crypto.h>
35 #include <linux/key.h>
36 #include <linux/keyctl.h>
37 #include <linux/mutex.h>
38 #include <asm/atomic.h>
39 #else
40 #include <liblustre.h>
41 #endif
42
43 #include <obd.h>
44 #include <obd_class.h>
45 #include <obd_support.h>
46 #include <lustre/lustre_idl.h>
47 #include <lustre_sec.h>
48 #include <lustre_net.h>
49 #include <lustre_import.h>
50
51 #include "gss_err.h"
52 #include "gss_internal.h"
53 #include "gss_api.h"
54
55 static struct ptlrpc_sec_policy gss_policy_keyring;
56 static struct ptlrpc_ctx_ops gss_keyring_ctxops;
57 static struct key_type gss_key_type;
58
59 static int sec_install_rctx_kr(struct ptlrpc_sec *sec,
60                                struct ptlrpc_svc_ctx *svc_ctx);
61
62 /*
63  * the timeout is only for the case that upcall child process die abnormally.
64  * in any other cases it should finally update kernel key. so we set this
65  * timeout value excessive long.
66  */
67 #define KEYRING_UPCALL_TIMEOUT  (obd_timeout + obd_timeout)
68
69 /****************************************
70  * internal helpers                     *
71  ****************************************/
72
73 #define DUMP_PROCESS_KEYRINGS(tsk)                                      \
74 {                                                                       \
75         CWARN("DUMP PK: %s[%u,%u/%u](<-%s[%u,%u/%u]): "                 \
76               "a %d, t %d, p %d, s %d, u %d, us %d, df %d\n",           \
77               tsk->comm, tsk->pid, tsk->uid, tsk->fsuid,                \
78               tsk->parent->comm, tsk->parent->pid,                      \
79               tsk->parent->uid, tsk->parent->fsuid,                     \
80               task_aux(tsk)->request_key_auth ?                         \
81               task_aux(tsk)->request_key_auth->serial : 0,              \
82               task_aux(tsk)->thread_keyring ?                           \
83               task_aux(tsk)->thread_keyring->serial : 0,                \
84               tsk->signal->process_keyring ?                            \
85               tsk->signal->process_keyring->serial : 0,                 \
86               tsk->signal->session_keyring ?                            \
87               tsk->signal->session_keyring->serial : 0,                 \
88               tsk->user->uid_keyring ?                                  \
89               tsk->user->uid_keyring->serial : 0,                       \
90               tsk->user->session_keyring ?                              \
91               tsk->user->session_keyring->serial : 0,                   \
92               task_aux(tsk)->jit_keyring                                \
93              );                                                         \
94 }
95
96 #define DUMP_KEY(key)                                                   \
97 {                                                                       \
98         CWARN("DUMP KEY: %p(%d) ref %d u%u/g%u desc %s\n",              \
99               key, key->serial, atomic_read(&key->usage),               \
100               key->uid, key->gid,                                       \
101               key->description ? key->description : "n/a"               \
102              );                                                         \
103 }
104
105
106 static inline void keyring_upcall_lock(struct gss_sec_keyring *gsec_kr)
107 {
108 #ifdef HAVE_KEYRING_UPCALL_SERIALIZED
109         mutex_lock(&gsec_kr->gsk_uc_lock);
110 #endif
111 }
112
113 static inline void keyring_upcall_unlock(struct gss_sec_keyring *gsec_kr)
114 {
115 #ifdef HAVE_KEYRING_UPCALL_SERIALIZED
116         mutex_unlock(&gsec_kr->gsk_uc_lock);
117 #endif
118 }
119
120 static inline void key_revoke_locked(struct key *key)
121 {
122         set_bit(KEY_FLAG_REVOKED, &key->flags);
123 }
124
125 static void ctx_upcall_timeout_kr(unsigned long data)
126 {
127         struct ptlrpc_cli_ctx *ctx = (struct ptlrpc_cli_ctx *) data;
128         struct key            *key = ctx2gctx_keyring(ctx)->gck_key;
129
130         CWARN("ctx %p, key %p\n", ctx, key);
131
132         LASSERT(key);
133
134         cli_ctx_expire(ctx);
135         key_revoke_locked(key);
136         sptlrpc_cli_ctx_wakeup(ctx);
137 }
138
139 static
140 void ctx_start_timer_kr(struct ptlrpc_cli_ctx *ctx, long timeout)
141 {
142         struct gss_cli_ctx_keyring *gctx_kr = ctx2gctx_keyring(ctx);
143         struct timer_list          *timer = gctx_kr->gck_timer;
144
145         LASSERT(timer);
146
147         CWARN("ctx %p: start timer %lds\n", ctx, timeout);
148         timeout = timeout * HZ + cfs_time_current();
149
150         init_timer(timer);
151         timer->expires = timeout;
152         timer->data = (unsigned long ) ctx;
153         timer->function = ctx_upcall_timeout_kr;
154
155         add_timer(timer);
156 }
157
158 static
159 void ctx_clear_timer_kr(struct ptlrpc_cli_ctx *ctx)
160 {
161         struct gss_cli_ctx_keyring *gctx_kr = ctx2gctx_keyring(ctx);
162         struct timer_list          *timer = gctx_kr->gck_timer;
163
164         CWARN("ctx %p, key %p\n", ctx, gctx_kr->gck_key);
165         if (timer == NULL)
166                 return;
167
168         gctx_kr->gck_timer = NULL;
169
170         del_singleshot_timer_sync(timer);
171
172         OBD_FREE_PTR(timer);
173 }
174
175 static
176 struct ptlrpc_cli_ctx *ctx_create_kr(struct ptlrpc_sec *sec,
177                                      struct vfs_cred *vcred)
178 {
179         struct ptlrpc_cli_ctx      *ctx;
180         struct gss_cli_ctx_keyring *gctx_kr;
181
182         OBD_ALLOC_PTR(gctx_kr);
183         if (gctx_kr == NULL)
184                 return NULL;
185
186         OBD_ALLOC_PTR(gctx_kr->gck_timer);
187         if (gctx_kr->gck_timer == NULL) {
188                 OBD_FREE_PTR(gctx_kr);
189                 return NULL;
190         }
191         init_timer(gctx_kr->gck_timer);
192
193         ctx = &gctx_kr->gck_base.gc_base;
194
195         if (gss_cli_ctx_init_common(sec, ctx, &gss_keyring_ctxops, vcred)) {
196                 OBD_FREE_PTR(gctx_kr->gck_timer);
197                 OBD_FREE_PTR(gctx_kr);
198                 return NULL;
199         }
200
201         ctx->cc_expire = cfs_time_current_sec() + KEYRING_UPCALL_TIMEOUT;
202         clear_bit(PTLRPC_CTX_NEW_BIT, &ctx->cc_flags);
203         atomic_inc(&ctx->cc_refcount); /* for the caller */
204
205         return ctx;
206 }
207
208 static void ctx_destroy_kr(struct ptlrpc_cli_ctx *ctx)
209 {
210         struct ptlrpc_sec          *sec = ctx->cc_sec;
211         struct gss_cli_ctx_keyring *gctx_kr = ctx2gctx_keyring(ctx);
212         int                         rc;
213
214         CWARN("destroying ctx %p\n", ctx);
215
216         /* at this time the association with key has been broken. */
217         LASSERT(sec);
218         LASSERT(test_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags) == 0);
219         LASSERT(gctx_kr->gck_key == NULL);
220
221         ctx_clear_timer_kr(ctx);
222         LASSERT(gctx_kr->gck_timer == NULL);
223
224         rc = gss_cli_ctx_fini_common(sec, ctx);
225
226         OBD_FREE_PTR(gctx_kr);
227
228         if (rc) {
229                 CWARN("released the last ctx, proceed to destroy sec %s@%p\n",
230                       sec->ps_policy->sp_name, sec);
231                 sptlrpc_sec_destroy(sec);
232         }
233 }
234
235 static void ctx_put_kr(struct ptlrpc_cli_ctx *ctx)
236 {
237         LASSERT(atomic_read(&ctx->cc_refcount) > 0);
238
239         if (atomic_dec_and_test(&ctx->cc_refcount))
240                 ctx_destroy_kr(ctx);
241 }
242
243 /*
244  * key <-> ctx association and rules:
245  * - ctx might not bind with any key
246  * - key/ctx binding is protected by key semaphore (if the key present)
247  * - key and ctx each take a reference of the other
248  * - ctx enlist/unlist is protected by ctx spinlock
249  * - never enlist a ctx after it's been unlisted
250  * - whoever do enlist should also do bind, lock key before enlist:
251  *   - lock key -> lock ctx -> enlist -> unlock ctx -> bind -> unlock key
252  * - whoever do unlist should also do unbind:
253  *   - lock key -> lock ctx -> unlist -> unlock ctx -> unbind -> unlock key
254  *   - lock ctx -> unlist -> unlock ctx -> lock key -> unbind -> unlock key
255  */
256
257 static inline void spin_lock_if(spinlock_t *lock, int condition)
258 {
259         if (condition)
260                 spin_lock(lock);
261 }
262
263 static inline void spin_unlock_if(spinlock_t *lock, int condition)
264 {
265         if (condition)
266                 spin_unlock(lock);
267 }
268
269 static
270 void ctx_enlist_kr(struct ptlrpc_cli_ctx *ctx, int is_root, int locked)
271 {
272         struct ptlrpc_sec      *sec = ctx->cc_sec;
273         struct gss_sec_keyring *gsec_kr = sec2gsec_keyring(sec);
274
275         LASSERT(!test_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags));
276         LASSERT(atomic_read(&ctx->cc_refcount) > 0);
277
278         spin_lock_if(&sec->ps_lock, !locked);
279
280         atomic_inc(&ctx->cc_refcount);
281         set_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags);
282         hlist_add_head(&ctx->cc_hash, &gsec_kr->gsk_clist);
283         if (is_root)
284                 gsec_kr->gsk_root_ctx = ctx;
285
286         spin_unlock_if(&sec->ps_lock, !locked);
287 }
288
289 /*
290  * Note after this get called, caller should not access ctx again because
291  * it might have been freed, unless caller hold at least one refcount of
292  * the ctx.
293  *
294  * return non-zero if we indeed unlist this ctx.
295  */
296 static
297 int ctx_unlist_kr(struct ptlrpc_cli_ctx *ctx, int locked)
298 {
299         struct ptlrpc_sec       *sec = ctx->cc_sec;
300         struct gss_sec_keyring  *gsec_kr = sec2gsec_keyring(sec);
301
302         /*
303          * if hashed bit has gone, leave the job to somebody who is doing it
304          */
305         if (test_and_clear_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags) == 0)
306                 return 0;
307
308         CWARN("ctx %p(%d) unlist\n", ctx, atomic_read(&ctx->cc_refcount));
309
310         /*
311          * drop ref inside spin lock to prevent race with other operations
312          */
313         spin_lock_if(&sec->ps_lock, !locked);
314
315         if (gsec_kr->gsk_root_ctx == ctx)
316                 gsec_kr->gsk_root_ctx = NULL;
317         hlist_del_init(&ctx->cc_hash);
318         atomic_dec(&ctx->cc_refcount);
319
320         spin_unlock_if(&sec->ps_lock, !locked);
321
322         return 1;
323 }
324
325 /*
326  * bind a key with a ctx together.
327  * caller must hold write lock of the key, as well as ref on key & ctx.
328  */
329 static
330 void bind_key_ctx(struct key *key, struct ptlrpc_cli_ctx *ctx)
331 {
332         LASSERT(atomic_read(&ctx->cc_refcount) > 0);
333         LASSERT(atomic_read(&key->usage) > 0);
334         LASSERT(ctx2gctx_keyring(ctx)->gck_key == NULL);
335         LASSERT(key->payload.data == NULL);
336         /*
337          * at this time context may or may not in list.
338          */
339         key_get(key);
340         atomic_inc(&ctx->cc_refcount);
341         ctx2gctx_keyring(ctx)->gck_key = key;
342         key->payload.data = ctx;
343 }
344
345 /*
346  * unbind a key and a ctx.
347  * caller must hold write lock, as well as a ref of the key.
348  */
349 static
350 void unbind_key_ctx(struct key *key, struct ptlrpc_cli_ctx *ctx)
351 {
352         LASSERT(key->payload.data == ctx);
353         LASSERT(test_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags) == 0);
354
355         /* must revoke the key, or others may treat it as newly created */
356         key_revoke_locked(key);
357
358         key->payload.data = NULL;
359         ctx2gctx_keyring(ctx)->gck_key = NULL;
360
361         /* once ctx get split from key, the timer is meaningless */
362         ctx_clear_timer_kr(ctx);
363
364         ctx_put_kr(ctx);
365         key_put(key);
366 }
367
368 /*
369  * given a ctx, unbind with its coupled key, if any.
370  * unbind could only be called once, so we don't worry the key be released
371  * by someone else.
372  */
373 static void unbind_ctx_kr(struct ptlrpc_cli_ctx *ctx)
374 {
375         struct key      *key = ctx2gctx_keyring(ctx)->gck_key;
376
377         if (key) {
378                 LASSERT(key->payload.data == ctx);
379
380                 key_get(key);
381                 down_write(&key->sem);
382                 unbind_key_ctx(key, ctx);
383                 up_write(&key->sem);
384                 key_put(key);
385         }
386 }
387
388 /*
389  * given a key, unbind with its coupled ctx, if any.
390  * caller must hold write lock, as well as a ref of the key.
391  */
392 static void unbind_key_locked(struct key *key)
393 {
394         struct ptlrpc_cli_ctx   *ctx = key->payload.data;
395
396         if (ctx)
397                 unbind_key_ctx(key, ctx);
398 }
399
400 /*
401  * unlist a ctx, and unbind from coupled key
402  */
403 static void kill_ctx_kr(struct ptlrpc_cli_ctx *ctx)
404 {
405         if (ctx_unlist_kr(ctx, 0))
406                 unbind_ctx_kr(ctx);
407 }
408
409 /*
410  * given a key, unlist and unbind with the coupled ctx (if any).
411  * caller must hold write lock, as well as a ref of the key.
412  */
413 static void kill_key_locked(struct key *key)
414 {
415         struct ptlrpc_cli_ctx *ctx = key->payload.data;
416
417         if (ctx && ctx_unlist_kr(ctx, 0))
418                 unbind_key_locked(key);
419 }
420
421 /*
422  * since this called, nobody else could touch the ctx in @freelist
423  */
424 static void dispose_ctx_list_kr(struct hlist_head *freelist)
425 {
426         struct hlist_node      *pos, *next;
427         struct ptlrpc_cli_ctx  *ctx;
428
429         hlist_for_each_entry_safe(ctx, pos, next, freelist, cc_hash) {
430                 hlist_del_init(&ctx->cc_hash);
431
432                 atomic_inc(&ctx->cc_refcount);
433                 unbind_ctx_kr(ctx);
434                 ctx_put_kr(ctx);
435         }
436 }
437
438 /*
439  * lookup a root context directly in a sec, return root ctx with a
440  * reference taken or NULL.
441  */
442 static
443 struct ptlrpc_cli_ctx * sec_lookup_root_ctx_kr(struct ptlrpc_sec *sec)
444 {
445         struct gss_sec_keyring  *gsec_kr = sec2gsec_keyring(sec);
446         struct ptlrpc_cli_ctx   *ctx = NULL;
447
448         spin_lock(&sec->ps_lock);
449
450         ctx = gsec_kr->gsk_root_ctx;
451         if (ctx) {
452                 LASSERT(atomic_read(&ctx->cc_refcount) > 0);
453                 LASSERT(!hlist_empty(&gsec_kr->gsk_clist));
454                 atomic_inc(&ctx->cc_refcount);
455         }
456
457         spin_unlock(&sec->ps_lock);
458
459         return ctx;
460 }
461
462 static void sec_replace_root_ctx_kr(struct ptlrpc_sec *sec,
463                                     struct ptlrpc_cli_ctx *new_ctx,
464                                     struct key *key)
465 {
466         struct gss_sec_keyring *gsec_kr = sec2gsec_keyring(sec);
467         struct ptlrpc_cli_ctx  *root_ctx;
468         struct hlist_head       freelist = HLIST_HEAD_INIT;
469         ENTRY;
470
471         spin_lock(&sec->ps_lock);
472
473         if (gsec_kr->gsk_root_ctx) {
474                 root_ctx = gsec_kr->gsk_root_ctx;
475
476                 set_bit(PTLRPC_CTX_DEAD_BIT, &root_ctx->cc_flags);
477
478                 if (ctx_unlist_kr(root_ctx, 1))
479                         hlist_add_head(&root_ctx->cc_hash, &freelist);
480         }
481
482         /*
483          * at this time, we can't guarantee the gsk_root_ctx is NULL, because
484          * another thread might clear the HASHED flag of root ctx earlier,
485          * and waiting for spinlock which is held by us. But anyway we just
486          * install the new root ctx.
487          */
488         ctx_enlist_kr(new_ctx, 1, 1);
489
490         if (key)
491                 bind_key_ctx(key, new_ctx);
492
493         spin_unlock(&sec->ps_lock);
494
495         dispose_ctx_list_kr(&freelist);
496 }
497
498 static void construct_key_desc(void *buf, int bufsize,
499                                struct ptlrpc_sec *sec, uid_t uid)
500 {
501         snprintf(buf, bufsize, "%d@%x", uid, sec2gsec_keyring(sec)->gsk_id);
502         ((char *)buf)[bufsize - 1] = '\0';
503 }
504
505 /****************************************
506  * sec apis                             *
507  ****************************************/
508
509 static atomic_t gss_sec_id_kr = ATOMIC_INIT(0);
510
511 static
512 struct ptlrpc_sec * gss_sec_create_kr(struct obd_import *imp,
513                                       struct ptlrpc_svc_ctx *ctx,
514                                       __u32 flavor,
515                                       unsigned long flags)
516 {
517         struct gss_sec_keyring  *gsec_kr;
518         ENTRY;
519
520         OBD_ALLOC(gsec_kr, sizeof(*gsec_kr));
521         if (gsec_kr == NULL)
522                 RETURN(NULL);
523
524         gsec_kr->gsk_id = atomic_inc_return(&gss_sec_id_kr);
525         INIT_HLIST_HEAD(&gsec_kr->gsk_clist);
526         gsec_kr->gsk_root_ctx = NULL;
527         mutex_init(&gsec_kr->gsk_root_uc_lock);
528 #ifdef HAVE_KEYRING_UPCALL_SERIALIZED
529         mutex_init(&gsec_kr->gsk_uc_lock);
530 #endif
531
532         if (gss_sec_create_common(&gsec_kr->gsk_base, &gss_policy_keyring,
533                                   imp, ctx, flavor, flags))
534                 goto err_free;
535
536         if (ctx != NULL) {
537                 if (sec_install_rctx_kr(&gsec_kr->gsk_base.gs_base, ctx)) {
538                         gss_sec_destroy_common(&gsec_kr->gsk_base);
539                         goto err_free;
540                 }
541         }
542
543         RETURN(&gsec_kr->gsk_base.gs_base);
544
545 err_free:
546         OBD_FREE(gsec_kr, sizeof(*gsec_kr));
547         RETURN(NULL);
548 }
549
550 static
551 void gss_sec_destroy_kr(struct ptlrpc_sec *sec)
552 {
553         struct gss_sec          *gsec = sec2gsec(sec);
554         struct gss_sec_keyring  *gsec_kr = sec2gsec_keyring(sec);
555
556         CWARN("destroy %s@%p\n", sec->ps_policy->sp_name, sec);
557
558         LASSERT(hlist_empty(&gsec_kr->gsk_clist));
559         LASSERT(gsec_kr->gsk_root_ctx == NULL);
560
561         gss_sec_destroy_common(gsec);
562
563         OBD_FREE(gsec_kr, sizeof(*gsec_kr));
564 }
565
566 static
567 int user_is_root(struct ptlrpc_sec *sec, struct vfs_cred *vcred)
568 {
569         if (sec->ps_flags & PTLRPC_SEC_FL_ROOTONLY)
570                 return 1;
571
572         /* FIXME
573          * more precisely deal with setuid. maybe add more infomation
574          * into vfs_cred ??
575          */
576         return (vcred->vc_uid == 0);
577 }
578
579 /*
580  * unlink request key from it's ring, which is linked during request_key().
581  * sadly, we have to 'guess' which keyring it's linked to.
582  *
583  * FIXME this code is fragile, depend on how request_key_link() is implemented.
584  */
585 static void request_key_unlink(struct key *key)
586 {
587         struct task_struct *tsk = current;
588         struct key *ring;
589
590         switch (task_aux(tsk)->jit_keyring) {
591         case KEY_REQKEY_DEFL_DEFAULT:
592         case KEY_REQKEY_DEFL_THREAD_KEYRING:
593                 ring = key_get(task_aux(tsk)->thread_keyring);
594                 if (ring)
595                         break;
596         case KEY_REQKEY_DEFL_PROCESS_KEYRING:
597                 ring = key_get(tsk->signal->process_keyring);
598                 if (ring)
599                         break;
600         case KEY_REQKEY_DEFL_SESSION_KEYRING:
601                 rcu_read_lock();
602                 ring = key_get(rcu_dereference(tsk->signal->session_keyring));
603                 rcu_read_unlock();
604                 if (ring)
605                         break;
606         case KEY_REQKEY_DEFL_USER_SESSION_KEYRING:
607                 ring = key_get(tsk->user->session_keyring);
608                 break;
609         case KEY_REQKEY_DEFL_USER_KEYRING:
610                 ring = key_get(tsk->user->uid_keyring);
611                 break;
612         case KEY_REQKEY_DEFL_GROUP_KEYRING:
613         default:
614                 LBUG();
615         }
616
617         LASSERT(ring);
618         key_unlink(ring, key);
619         key_put(ring);
620 }
621
622 static
623 struct ptlrpc_cli_ctx * gss_sec_lookup_ctx_kr(struct ptlrpc_sec *sec,
624                                               struct vfs_cred *vcred,
625                                               int create, int remove_dead)
626 {
627         struct obd_import       *imp = sec->ps_import;
628         struct gss_sec_keyring  *gsec_kr = sec2gsec_keyring(sec);
629         struct ptlrpc_cli_ctx   *ctx = NULL;
630         unsigned int             is_root = 0, create_new = 0;
631         struct key              *key;
632         char                     desc[24];
633         char                    *coinfo;
634         const int                coinfo_size = sizeof(struct obd_uuid) + 64;
635         char                    *co_flags = "";
636         ENTRY;
637
638         LASSERT(imp != NULL);
639
640         is_root = user_is_root(sec, vcred);
641
642         /*
643          * a little bit optimization for root context
644          */
645         if (is_root) {
646                 ctx = sec_lookup_root_ctx_kr(sec);
647                 /*
648                  * Only lookup directly for REVERSE sec, which should
649                  * always succeed.
650                  */
651                 if (ctx || (sec->ps_flags & PTLRPC_SEC_FL_REVERSE))
652                         RETURN(ctx);
653         }
654
655         LASSERT(create != 0);
656
657         /*
658          * for root context, obtain lock and check again, this time hold
659          * the root upcall lock, make sure nobody else populated new root
660          * context after last check.
661          */
662         if (is_root) {
663                 mutex_lock(&gsec_kr->gsk_root_uc_lock);
664
665                 ctx = sec_lookup_root_ctx_kr(sec);
666                 if (ctx)
667                         goto out;
668
669                 /* update reverse handle for root user */
670                 sec2gsec(sec)->gs_rvs_hdl = gss_get_next_ctx_index();
671
672                 co_flags = "r";
673         }
674
675         construct_key_desc(desc, sizeof(desc), sec, vcred->vc_uid);
676
677         /*
678          * callout info: mech:flags:svc_type:peer_nid:target_uuid
679          */
680         OBD_ALLOC(coinfo, coinfo_size);
681         if (coinfo == NULL)
682                 goto out;
683
684         snprintf(coinfo, coinfo_size, "%s:%s:%d:"LPX64":%s",
685                  sec2gsec(sec)->gs_mech->gm_name,
686                  co_flags, import_to_gss_svc(imp),
687                  imp->imp_connection->c_peer.nid, imp->imp_obd->obd_name);
688
689         keyring_upcall_lock(gsec_kr);
690         key = request_key(&gss_key_type, desc, coinfo);
691         keyring_upcall_unlock(gsec_kr);
692
693         OBD_FREE(coinfo, coinfo_size);
694
695         if (IS_ERR(key)) {
696                 CERROR("failed request key: %ld\n", PTR_ERR(key));
697                 goto out;
698         }
699
700         /*
701          * once payload.data was pointed to a ctx, it never changes until
702          * we de-associate them; but parallel request_key() may return
703          * a key with payload.data == NULL at the same time. so we still
704          * need wirtelock of key->sem to serialize them.
705          */
706         down_write(&key->sem);
707
708         if (likely(key->payload.data != NULL)) {
709                 ctx = key->payload.data;
710
711                 LASSERT(atomic_read(&ctx->cc_refcount) >= 1);
712                 LASSERT(ctx2gctx_keyring(ctx)->gck_key == key);
713                 LASSERT(atomic_read(&key->usage) >= 2);
714
715                 /* simply take a ref and return. it's upper layer's
716                  * responsibility to detect & replace dead ctx.
717                  */
718                 atomic_inc(&ctx->cc_refcount);
719         } else {
720                 /* pre initialization with a cli_ctx. this can't be done in
721                  * key_instantiate() because we'v no enough information there.
722                  */
723                 ctx = ctx_create_kr(sec, vcred);
724                 if (ctx != NULL) {
725                         ctx_enlist_kr(ctx, is_root, 0);
726                         bind_key_ctx(key, ctx);
727
728                         ctx_start_timer_kr(ctx, KEYRING_UPCALL_TIMEOUT);
729
730                         CWARN("installed key %p <-> ctx %p (sec %p)\n",
731                               key, ctx, sec);
732                 } else {
733                         /*
734                          * we'd prefer to call key_revoke(), but we more like
735                          * to revoke it within this key->sem locked period.
736                          */
737                         key_revoke_locked(key);
738                 }
739
740                 create_new = 1;
741         }
742
743         up_write(&key->sem);
744
745         if (is_root && create_new)
746                 request_key_unlink(key);
747
748         key_put(key);
749 out:
750         if (is_root)
751                 mutex_unlock(&gsec_kr->gsk_root_uc_lock);
752         RETURN(ctx);
753 }
754
755 static
756 void gss_sec_release_ctx_kr(struct ptlrpc_sec *sec,
757                             struct ptlrpc_cli_ctx *ctx,
758                             int sync)
759 {
760         CWARN("ctx %p\n", ctx);
761         ctx_destroy_kr(ctx);
762 }
763
764 /*
765  * flush context of normal user, we must resort to keyring itself to find out
766  * contexts which belong to me.
767  *
768  * Note here we suppose only to flush _my_ context, the "uid" will
769  * be ignored in the search.
770  */
771 static
772 void flush_user_ctx_cache_kr(struct ptlrpc_sec *sec,
773                              uid_t uid,
774                              int grace, int force)
775 {
776         struct key              *key;
777         char                     desc[24];
778
779         /* nothing to do for reverse or rootonly sec */
780         if (sec->ps_flags & (PTLRPC_SEC_FL_REVERSE | PTLRPC_SEC_FL_ROOTONLY))
781                 return;
782
783         construct_key_desc(desc, sizeof(desc), sec, uid);
784
785         /* there should be only one valid key, but we put it in the
786          * loop in case of any weird cases
787          */
788         for (;;) {
789                 key = request_key(&gss_key_type, desc, NULL);
790                 if (IS_ERR(key)) {
791                         CWARN("No more key found for current user\n");
792                         break;
793                 }
794
795                 down_write(&key->sem);
796
797                 CWARN("invalidating key %p - ctx %p\n", key, key->payload.data);
798                 kill_key_locked(key);
799
800                 /* kill_key_locked() should usually revoke the key, but we
801                  * revoke it again to make sure, e.g. some case the key may
802                  * not well coupled with a context.
803                  */
804                 key_revoke_locked(key);
805
806                 up_write(&key->sem);
807
808                 key_put(key);
809         }
810 }
811
812 /*
813  * flush context of root or all, we iterate through the list.
814  */
815 static
816 void flush_spec_ctx_cache_kr(struct ptlrpc_sec *sec,
817                              uid_t uid,
818                              int grace, int force)
819 {
820         struct gss_sec_keyring *gsec_kr;
821         struct hlist_head       freelist = HLIST_HEAD_INIT;
822         struct hlist_node      *pos, *next;
823         struct ptlrpc_cli_ctx  *ctx;
824         ENTRY;
825
826         gsec_kr = sec2gsec_keyring(sec);
827
828         spin_lock(&sec->ps_lock);
829         hlist_for_each_entry_safe(ctx, pos, next,
830                                   &gsec_kr->gsk_clist, cc_hash) {
831                 LASSERT(atomic_read(&ctx->cc_refcount) > 0);
832
833                 if (uid != -1 && uid != ctx->cc_vcred.vc_uid)
834                         continue;
835
836                 /* at this moment there's at least 2 base reference:
837                  * key association and in-list.
838                  */
839                 if (atomic_read(&ctx->cc_refcount) > 2) {
840                         if (!force)
841                                 continue;
842                         CWARN("flush busy ctx %p(%u->%s, extra ref %d)\n",
843                               ctx, ctx->cc_vcred.vc_uid,
844                               sec2target_str(ctx->cc_sec),
845                               atomic_read(&ctx->cc_refcount) - 2);
846                 }
847
848                 set_bit(PTLRPC_CTX_DEAD_BIT, &ctx->cc_flags);
849                 if (!grace)
850                         clear_bit(PTLRPC_CTX_UPTODATE_BIT, &ctx->cc_flags);
851
852                 if (ctx_unlist_kr(ctx, 1)) {
853                         hlist_add_head(&ctx->cc_hash, &freelist);
854                         CWARN("unlisted ctx %p\n", ctx);
855                 } else
856                         CWARN("ctx %p: unlist return 0, let it go\n", ctx);
857
858         }
859         spin_unlock(&sec->ps_lock);
860
861         dispose_ctx_list_kr(&freelist);
862         EXIT;
863 }
864
865 static
866 int gss_sec_flush_ctx_cache_kr(struct ptlrpc_sec *sec,
867                                uid_t uid,
868                                int grace, int force)
869 {
870         ENTRY;
871
872         CWARN("sec %p(%d, busy %d), uid %d, grace %d, force %d\n",
873               sec, atomic_read(&sec->ps_refcount), atomic_read(&sec->ps_busy),
874               uid, grace, force);
875
876         if (uid != -1 && uid != 0)
877                 flush_user_ctx_cache_kr(sec, uid, grace, force);
878         else
879                 flush_spec_ctx_cache_kr(sec, uid, grace, force);
880
881         RETURN(0);
882 }
883
884 static
885 void gss_sec_gc_ctx_kr(struct ptlrpc_sec *sec)
886 {
887         struct gss_sec_keyring *gsec_kr = sec2gsec_keyring(sec);
888         struct hlist_head       freelist = HLIST_HEAD_INIT;
889         struct hlist_node      *pos, *next;
890         struct ptlrpc_cli_ctx  *ctx;
891         ENTRY;
892
893         CWARN("running gc\n");
894
895         spin_lock(&sec->ps_lock);
896         hlist_for_each_entry_safe(ctx, pos, next,
897                                   &gsec_kr->gsk_clist, cc_hash) {
898                 LASSERT(atomic_read(&ctx->cc_refcount) > 0);
899
900                 if (cli_ctx_check_death(ctx) && ctx_unlist_kr(ctx, 1)) {
901                         hlist_add_head(&ctx->cc_hash, &freelist);
902                         CWARN("unhashed ctx %p\n", ctx);
903                 }
904         }
905         spin_unlock(&sec->ps_lock);
906
907         dispose_ctx_list_kr(&freelist);
908         EXIT;
909         return;
910 }
911
912 static
913 int gss_sec_display_kr(struct ptlrpc_sec *sec, char *buf, int bufsize)
914 {
915         struct gss_sec_keyring *gsec_kr = sec2gsec_keyring(sec);
916         struct hlist_node      *pos, *next;
917         struct ptlrpc_cli_ctx  *ctx;
918         int                     written = 0;
919         ENTRY;
920
921         written = snprintf(buf, bufsize, "context list ===>\n");
922         bufsize -= written;
923         buf += written;
924
925         spin_lock(&sec->ps_lock);
926         hlist_for_each_entry_safe(ctx, pos, next,
927                                   &gsec_kr->gsk_clist, cc_hash) {
928                 struct key *key;
929                 int         len;
930
931                 key = ctx2gctx_keyring(ctx)->gck_key;
932
933                 len = snprintf(buf, bufsize, "%p(%d): expire %ld(%ld), "
934                                "uid %u, flags 0x%lx, key %08x(%d)\n",
935                                ctx, atomic_read(&ctx->cc_refcount),
936                                ctx->cc_expire,
937                                ctx->cc_expire - cfs_time_current_sec(),
938                                ctx->cc_vcred.vc_uid,
939                                ctx->cc_flags,
940                                key ? key->serial : 0,
941                                key ? atomic_read(&key->usage) : 0);
942
943                 written += len;
944                 buf += len;
945                 bufsize -= len;
946
947                 if (bufsize < len)
948                         break;
949         }
950         spin_unlock(&sec->ps_lock);
951
952         RETURN(written);
953 }
954
955 /****************************************
956  * cli_ctx apis                         *
957  ****************************************/
958
959 static
960 int gss_cli_ctx_refresh_kr(struct ptlrpc_cli_ctx *ctx)
961 {
962         /* upcall is already on the way */
963         return 0;
964 }
965
966 static
967 int gss_cli_ctx_validate_kr(struct ptlrpc_cli_ctx *ctx)
968 {
969         LASSERT(atomic_read(&ctx->cc_refcount) > 0);
970         LASSERT(ctx->cc_sec);
971
972         if (cli_ctx_check_death(ctx)) {
973                 kill_ctx_kr(ctx);
974                 return 1;
975         }
976
977         if (cli_ctx_is_uptodate(ctx))
978                 return 0;
979         return 1;
980 }
981
982 static
983 void gss_cli_ctx_die_kr(struct ptlrpc_cli_ctx *ctx, int grace)
984 {
985         LASSERT(atomic_read(&ctx->cc_refcount) > 0);
986         LASSERT(ctx->cc_sec);
987
988         CWARN("ctx %p(%d)\n", ctx, atomic_read(&ctx->cc_refcount));
989         cli_ctx_expire(ctx);
990         kill_ctx_kr(ctx);
991 }
992
993 /****************************************
994  * (reverse) service                    *
995  ****************************************/
996
997 /*
998  * reverse context could have nothing to do with keyrings. here we still keep
999  * the version which bind to a key, for future reference.
1000  */
1001 #define HAVE_REVERSE_CTX_NOKEY
1002
1003 #ifdef HAVE_REVERSE_CTX_NOKEY
1004
1005 static
1006 int sec_install_rctx_kr(struct ptlrpc_sec *sec,
1007                         struct ptlrpc_svc_ctx *svc_ctx)
1008 {
1009         struct ptlrpc_cli_ctx   *cli_ctx;
1010         struct vfs_cred          vcred = { 0, 0 };
1011         int                      rc;
1012
1013         LASSERT(sec);
1014         LASSERT(svc_ctx);
1015
1016         cli_ctx = ctx_create_kr(sec, &vcred);
1017         if (cli_ctx == NULL)
1018                 return -ENOMEM;
1019
1020         rc = gss_copy_rvc_cli_ctx(cli_ctx, svc_ctx);
1021         if (rc) {
1022                 CERROR("failed copy reverse cli ctx: %d\n", rc);
1023
1024                 ctx_put_kr(cli_ctx);
1025                 return rc;
1026         }
1027
1028         sec_replace_root_ctx_kr(sec, cli_ctx, NULL);
1029
1030         ctx_put_kr(cli_ctx);
1031
1032         return 0;
1033 }
1034
1035 #else /* ! HAVE_REVERSE_CTX_NOKEY */
1036
1037 static
1038 int sec_install_rctx_kr(struct ptlrpc_sec *sec,
1039                         struct ptlrpc_svc_ctx *svc_ctx)
1040 {
1041         struct ptlrpc_cli_ctx   *cli_ctx = NULL;
1042         struct key              *key;
1043         struct vfs_cred          vcred = { 0, 0 };
1044         char                     desc[64];
1045         int                      rc;
1046
1047         LASSERT(sec);
1048         LASSERT(svc_ctx);
1049         CWARN("called\n");
1050
1051         construct_key_desc(desc, sizeof(desc), sec, 0);
1052
1053         key = key_alloc(&gss_key_type, desc, 0, 0,
1054                         KEY_POS_ALL | KEY_USR_ALL, 1);
1055         if (IS_ERR(key)) {
1056                 CERROR("failed to alloc key: %ld\n", PTR_ERR(key));
1057                 return PTR_ERR(key);
1058         }
1059
1060         rc = key_instantiate_and_link(key, NULL, 0, NULL, NULL);
1061         if (rc) {
1062                 CERROR("failed to instantiate key: %d\n", rc);
1063                 goto err_revoke;
1064         }
1065
1066         down_write(&key->sem);
1067
1068         LASSERT(key->payload.data == NULL);
1069
1070         cli_ctx = ctx_create_kr(sec, &vcred);
1071         if (cli_ctx == NULL) {
1072                 rc = -ENOMEM;
1073                 goto err_up;
1074         }
1075
1076         rc = gss_copy_rvc_cli_ctx(cli_ctx, svc_ctx);
1077         if (rc) {
1078                 CERROR("failed copy reverse cli ctx: %d\n", rc);
1079                 goto err_put;
1080         }
1081
1082         sec_replace_root_ctx_kr(sec, cli_ctx, key);
1083
1084         ctx_put_kr(cli_ctx);
1085         up_write(&key->sem);
1086
1087         rc = 0;
1088         CWARN("ok!\n");
1089 out:
1090         key_put(key);
1091         return rc;
1092
1093 err_put:
1094         ctx_put_kr(cli_ctx);
1095 err_up:
1096         up_write(&key->sem);
1097 err_revoke:
1098         key_revoke(key);
1099         goto out;
1100 }
1101
1102 #endif /* HAVE_REVERSE_CTX_NOKEY */
1103
1104 /****************************************
1105  * service apis                         *
1106  ****************************************/
1107
1108 static
1109 int gss_svc_accept_kr(struct ptlrpc_request *req)
1110 {
1111         return gss_svc_accept(&gss_policy_keyring, req);
1112 }
1113
1114 static
1115 int gss_svc_install_rctx_kr(struct obd_import *imp,
1116                             struct ptlrpc_svc_ctx *svc_ctx)
1117 {
1118         LASSERT(imp->imp_sec);
1119
1120         return sec_install_rctx_kr(imp->imp_sec, svc_ctx);
1121 }
1122
1123 /****************************************
1124  * key apis                             *
1125  ****************************************/
1126
1127 static
1128 int gss_kt_instantiate(struct key *key, const void *data, size_t datalen)
1129 {
1130         ENTRY;
1131
1132         if (data != NULL || datalen != 0) {
1133                 CERROR("invalid: data %p, len %d\n", data, datalen);
1134                 RETURN(-EINVAL);
1135         }
1136
1137         if (key->payload.data != 0) {
1138                 CERROR("key already have payload\n");
1139                 RETURN(-EINVAL);
1140         }
1141
1142         /* XXX */
1143         key->perm |= KEY_POS_ALL | KEY_USR_ALL;
1144         CWARN("key %p instantiated, ctx %p\n", key, key->payload.data);
1145         RETURN(0);
1146 }
1147
1148 /*
1149  * called with key semaphore write locked. it means we can operate
1150  * on the context without fear of loosing refcount.
1151  */
1152 static
1153 int gss_kt_update(struct key *key, const void *data, size_t datalen)
1154 {
1155         struct ptlrpc_cli_ctx   *ctx = key->payload.data;
1156         struct gss_cli_ctx      *gctx;
1157         rawobj_t                 tmpobj = RAWOBJ_EMPTY;
1158         int                      rc;
1159         ENTRY;
1160
1161         if (data == NULL || datalen == 0) {
1162                 CWARN("invalid: data %p, len %d\n", data, datalen);
1163                 RETURN(-EINVAL);
1164         }
1165
1166         /*
1167          * there's a race between userspace parent - child processes. if
1168          * child finish negotiation too fast and call kt_update(), the ctx
1169          * might be still NULL. but the key will finally be associate
1170          * with a context, or be revoked. if key status is fine, return
1171          * -EAGAIN to allow userspace sleep a while and call again.
1172          */
1173         if (ctx == NULL) {
1174                 CWARN("race in userspace. key %p(%x) flags %lx\n",
1175                       key, key->serial, key->flags);
1176
1177                 rc = key_validate(key);
1178                 if (rc == 0)
1179                         RETURN(-EAGAIN);
1180                 else
1181                         RETURN(rc);
1182         }
1183
1184         LASSERT(atomic_read(&ctx->cc_refcount) > 0);
1185         LASSERT(ctx->cc_sec);
1186
1187         ctx_clear_timer_kr(ctx);
1188
1189         /* don't proceed if already refreshed */
1190         if (cli_ctx_is_refreshed(ctx)) {
1191                 CWARN("ctx already done refresh\n");
1192                 sptlrpc_cli_ctx_wakeup(ctx);
1193                 RETURN(0);
1194         }
1195
1196         sptlrpc_cli_ctx_get(ctx);
1197         gctx = ctx2gctx(ctx);
1198         rc = -EFAULT;
1199
1200         if (buffer_extract_bytes(&data, &datalen,
1201                                  &gctx->gc_win, sizeof(gctx->gc_win))) {
1202                 CERROR("failed extract seq_win\n");
1203                 goto out;
1204         }
1205
1206         CWARN("secwin is %d\n", gctx->gc_win);
1207         if (gctx->gc_win == 0) {
1208                 __u32   nego_rpc_err, nego_gss_err;
1209
1210                 if (buffer_extract_bytes(&data, &datalen,
1211                                          &nego_rpc_err, sizeof(nego_rpc_err))) {
1212                         CERROR("failed to extrace rpc rc\n");
1213                         goto out;
1214                 }
1215
1216                 if (buffer_extract_bytes(&data, &datalen,
1217                                          &nego_gss_err, sizeof(nego_gss_err))) {
1218                         CERROR("failed to extrace gss rc\n");
1219                         goto out;
1220                 }
1221
1222                 CERROR("negotiation: rpc err %d, gss err %x\n",
1223                        nego_rpc_err, nego_gss_err);
1224
1225                 if (nego_rpc_err)
1226                         rc = nego_rpc_err;
1227         } else {
1228                 if (rawobj_extract_local_alloc(&gctx->gc_handle,
1229                                                (__u32 **)&data, &datalen)) {
1230                         CERROR("failed extract handle\n");
1231                         goto out;
1232                 }
1233
1234                 if (rawobj_extract_local(&tmpobj, (__u32 **)&data, &datalen)) {
1235                         CERROR("failed extract mech\n");
1236                         goto out;
1237                 }
1238
1239                 if (lgss_import_sec_context(&tmpobj,
1240                                             sec2gsec(ctx->cc_sec)->gs_mech,
1241                                             &gctx->gc_mechctx) !=
1242                     GSS_S_COMPLETE) {
1243                         CERROR("failed import context\n");
1244                         goto out;
1245                 }
1246
1247                 rc = 0;
1248         }
1249 out:
1250         /* we don't care what current status of this ctx, even someone else
1251          * is operating on the ctx at the same time. we just add up our own
1252          * opinions here.
1253          */
1254         if (rc == 0) {
1255                 gss_cli_ctx_uptodate(gctx);
1256         } else {
1257                 cli_ctx_expire(ctx);
1258
1259                 if (rc != -ERESTART)
1260                         set_bit(PTLRPC_CTX_ERROR_BIT, &ctx->cc_flags);
1261
1262                 /* this will also revoke the key. has to be done before
1263                  * wakeup waiters otherwise they can find the stale key
1264                  */
1265                 kill_key_locked(key);
1266         }
1267
1268         sptlrpc_cli_ctx_wakeup(ctx);
1269
1270         /* let user space think it's a success */
1271         sptlrpc_cli_ctx_put(ctx, 1);
1272         RETURN(0);
1273 }
1274
1275 static
1276 int gss_kt_match(const struct key *key, const void *desc)
1277 {
1278         return (strcmp(key->description, (const char *) desc) == 0);
1279 }
1280
1281 static
1282 void gss_kt_destroy(struct key *key)
1283 {
1284         ENTRY;
1285         LASSERT(key->payload.data == NULL);
1286         CWARN("destroy key %p\n", key);
1287         EXIT;
1288 }
1289
1290 static
1291 void gss_kt_describe(const struct key *key, struct seq_file *s)
1292 {
1293         if (key->description == NULL)
1294                 seq_puts(s, "[null]");
1295         else
1296                 seq_puts(s, key->description);
1297 }
1298
1299 static struct key_type gss_key_type =
1300 {
1301         .name           = "lgssc",
1302         .def_datalen    = 0,
1303         .instantiate    = gss_kt_instantiate,
1304         .update         = gss_kt_update,
1305         .match          = gss_kt_match,
1306         .destroy        = gss_kt_destroy,
1307         .describe       = gss_kt_describe,
1308 };
1309
1310 /****************************************
1311  * lustre gss keyring policy            *
1312  ****************************************/
1313
1314 static struct ptlrpc_ctx_ops gss_keyring_ctxops = {
1315         .match                  = gss_cli_ctx_match,
1316         .refresh                = gss_cli_ctx_refresh_kr,
1317         .validate               = gss_cli_ctx_validate_kr,
1318         .die                    = gss_cli_ctx_die_kr,
1319         .display                = gss_cli_ctx_display,
1320         .sign                   = gss_cli_ctx_sign,
1321         .verify                 = gss_cli_ctx_verify,
1322         .seal                   = gss_cli_ctx_seal,
1323         .unseal                 = gss_cli_ctx_unseal,
1324         .wrap_bulk              = gss_cli_ctx_wrap_bulk,
1325         .unwrap_bulk            = gss_cli_ctx_unwrap_bulk,
1326 };
1327
1328 static struct ptlrpc_sec_cops gss_sec_keyring_cops = {
1329         .create_sec             = gss_sec_create_kr,
1330         .destroy_sec            = gss_sec_destroy_kr,
1331         .lookup_ctx             = gss_sec_lookup_ctx_kr,
1332         .release_ctx            = gss_sec_release_ctx_kr,
1333         .flush_ctx_cache        = gss_sec_flush_ctx_cache_kr,
1334         .gc_ctx                 = gss_sec_gc_ctx_kr,
1335         .install_rctx           = gss_sec_install_rctx,
1336         .alloc_reqbuf           = gss_alloc_reqbuf,
1337         .free_reqbuf            = gss_free_reqbuf,
1338         .alloc_repbuf           = gss_alloc_repbuf,
1339         .free_repbuf            = gss_free_repbuf,
1340         .enlarge_reqbuf         = gss_enlarge_reqbuf,
1341         .display                = gss_sec_display_kr,
1342 };
1343
1344 static struct ptlrpc_sec_sops gss_sec_keyring_sops = {
1345         .accept                 = gss_svc_accept_kr,
1346         .invalidate_ctx         = gss_svc_invalidate_ctx,
1347         .alloc_rs               = gss_svc_alloc_rs,
1348         .authorize              = gss_svc_authorize,
1349         .free_rs                = gss_svc_free_rs,
1350         .free_ctx               = gss_svc_free_ctx,
1351         .unwrap_bulk            = gss_svc_unwrap_bulk,
1352         .wrap_bulk              = gss_svc_wrap_bulk,
1353         .install_rctx           = gss_svc_install_rctx_kr,
1354 };
1355
1356 static struct ptlrpc_sec_policy gss_policy_keyring = {
1357         .sp_owner               = THIS_MODULE,
1358         .sp_name                = "gss.keyring",
1359         .sp_policy              = SPTLRPC_POLICY_GSS,
1360         .sp_cops                = &gss_sec_keyring_cops,
1361         .sp_sops                = &gss_sec_keyring_sops,
1362 };
1363
1364
1365 int __init gss_init_keyring(void)
1366 {
1367         int rc;
1368
1369         rc = register_key_type(&gss_key_type);
1370         if (rc) {
1371                 CERROR("failed to register keyring type: %d\n", rc);
1372                 return rc;
1373         }
1374
1375         rc = sptlrpc_register_policy(&gss_policy_keyring);
1376         if (rc) {
1377                 unregister_key_type(&gss_key_type);
1378                 return rc;
1379         }
1380
1381         return 0;
1382 }
1383
1384 void __exit gss_exit_keyring(void)
1385 {
1386         unregister_key_type(&gss_key_type);
1387         sptlrpc_unregister_policy(&gss_policy_keyring);
1388 }