X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fptlrpc%2Fgss%2Fgss_pipefs.c;h=5e1e7caa1aae6a08a066a0b665b8b773ee3dd975;hb=a7997c836bbfe2a0674007f1c23b9593e596e0ba;hp=af9da9aae0d37e3879480d2b6999a2b3169c5ca8;hpb=6e3ec5812ebd1b5ecf7cae584f429b013ffe7431;p=fs%2Flustre-release.git diff --git a/lustre/ptlrpc/gss/gss_pipefs.c b/lustre/ptlrpc/gss/gss_pipefs.c index af9da9a..5e1e7ca 100644 --- a/lustre/ptlrpc/gss/gss_pipefs.c +++ b/lustre/ptlrpc/gss/gss_pipefs.c @@ -1,9 +1,9 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * Modifications for Lustre * - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. + * + * Copyright (c) 2012, 2016, Intel Corporation. * * Author: Eric Mei */ @@ -46,30 +46,23 @@ * */ -#ifndef EXPORT_SYMTAB -# define EXPORT_SYMTAB -#endif #define DEBUG_SUBSYSTEM S_SEC -#ifdef __KERNEL__ #include #include #include #include #include -#include #include #include #include struct rpc_clnt; /* for rpc_pipefs */ #include -#else -#include -#endif +#include #include #include #include -#include +#include #include #include #include @@ -93,7 +86,7 @@ static void gss_sec_pipe_upcall_fini(struct gss_sec *gsec) } /**************************************** - * internel context helpers * + * internal context helpers * ****************************************/ static @@ -120,44 +113,44 @@ struct ptlrpc_cli_ctx *ctx_create_pf(struct ptlrpc_sec *sec, static void ctx_destroy_pf(struct ptlrpc_sec *sec, struct ptlrpc_cli_ctx *ctx) { - struct gss_cli_ctx *gctx = ctx2gctx(ctx); + struct gss_cli_ctx *gctx = ctx2gctx(ctx); - if (gss_cli_ctx_fini_common(sec, ctx)) - return; + if (gss_cli_ctx_fini_common(sec, ctx)) + return; - OBD_FREE_PTR(gctx); + OBD_FREE_PTR(gctx); - cfs_atomic_dec(&sec->ps_nctx); - sptlrpc_sec_put(sec); + atomic_dec(&sec->ps_nctx); + sptlrpc_sec_put(sec); } static -void ctx_enhash_pf(struct ptlrpc_cli_ctx *ctx, cfs_hlist_head_t *hash) +void ctx_enhash_pf(struct ptlrpc_cli_ctx *ctx, struct hlist_head *hash) { - cfs_set_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags); - cfs_atomic_inc(&ctx->cc_refcount); - cfs_hlist_add_head(&ctx->cc_cache, hash); + set_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags); + atomic_inc(&ctx->cc_refcount); + hlist_add_head(&ctx->cc_cache, hash); } /* * caller must hold spinlock */ static -void ctx_unhash_pf(struct ptlrpc_cli_ctx *ctx, cfs_hlist_head_t *freelist) +void ctx_unhash_pf(struct ptlrpc_cli_ctx *ctx, struct hlist_head *freelist) { - LASSERT_SPIN_LOCKED(&ctx->cc_sec->ps_lock); - LASSERT(cfs_atomic_read(&ctx->cc_refcount) > 0); - LASSERT(cfs_test_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags)); - LASSERT(!cfs_hlist_unhashed(&ctx->cc_cache)); - - cfs_clear_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags); - - if (cfs_atomic_dec_and_test(&ctx->cc_refcount)) { - __cfs_hlist_del(&ctx->cc_cache); - cfs_hlist_add_head(&ctx->cc_cache, freelist); - } else { - cfs_hlist_del_init(&ctx->cc_cache); - } + assert_spin_locked(&ctx->cc_sec->ps_lock); + LASSERT(atomic_read(&ctx->cc_refcount) > 0); + LASSERT(test_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags)); + LASSERT(!hlist_unhashed(&ctx->cc_cache)); + + clear_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags); + + if (atomic_dec_and_test(&ctx->cc_refcount)) { + __hlist_del(&ctx->cc_cache); + hlist_add_head(&ctx->cc_cache, freelist); + } else { + hlist_del_init(&ctx->cc_cache); + } } /* @@ -165,7 +158,7 @@ void ctx_unhash_pf(struct ptlrpc_cli_ctx *ctx, cfs_hlist_head_t *freelist) */ static int ctx_check_death_pf(struct ptlrpc_cli_ctx *ctx, - cfs_hlist_head_t *freelist) + struct hlist_head *freelist) { if (cli_ctx_check_death(ctx)) { if (freelist) @@ -178,13 +171,13 @@ int ctx_check_death_pf(struct ptlrpc_cli_ctx *ctx, static inline int ctx_check_death_locked_pf(struct ptlrpc_cli_ctx *ctx, - cfs_hlist_head_t *freelist) + struct hlist_head *freelist) { - LASSERT(ctx->cc_sec); - LASSERT(cfs_atomic_read(&ctx->cc_refcount) > 0); - LASSERT(cfs_test_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags)); + LASSERT(ctx->cc_sec); + LASSERT(atomic_read(&ctx->cc_refcount) > 0); + LASSERT(test_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags)); - return ctx_check_death_pf(ctx, freelist); + return ctx_check_death_pf(ctx, freelist); } static inline @@ -198,21 +191,21 @@ int ctx_match_pf(struct ptlrpc_cli_ctx *ctx, struct vfs_cred *vcred) } static -void ctx_list_destroy_pf(cfs_hlist_head_t *head) +void ctx_list_destroy_pf(struct hlist_head *head) { - struct ptlrpc_cli_ctx *ctx; + struct ptlrpc_cli_ctx *ctx; - while (!cfs_hlist_empty(head)) { - ctx = cfs_hlist_entry(head->first, struct ptlrpc_cli_ctx, - cc_cache); + while (!hlist_empty(head)) { + ctx = cfs_hlist_entry(head->first, struct ptlrpc_cli_ctx, + cc_cache); - LASSERT(cfs_atomic_read(&ctx->cc_refcount) == 0); - LASSERT(cfs_test_bit(PTLRPC_CTX_CACHED_BIT, - &ctx->cc_flags) == 0); + LASSERT(atomic_read(&ctx->cc_refcount) == 0); + LASSERT(test_bit(PTLRPC_CTX_CACHED_BIT, + &ctx->cc_flags) == 0); - cfs_hlist_del_init(&ctx->cc_cache); - ctx_destroy_pf(ctx->cc_sec, ctx); - } + hlist_del_init(&ctx->cc_cache); + ctx_destroy_pf(ctx->cc_sec, ctx); + } } /**************************************** @@ -232,23 +225,23 @@ int gss_cli_ctx_validate_pf(struct ptlrpc_cli_ctx *ctx) static void gss_cli_ctx_die_pf(struct ptlrpc_cli_ctx *ctx, int grace) { - LASSERT(ctx->cc_sec); - LASSERT(cfs_atomic_read(&ctx->cc_refcount) > 0); + LASSERT(ctx->cc_sec); + LASSERT(atomic_read(&ctx->cc_refcount) > 0); - cli_ctx_expire(ctx); + cli_ctx_expire(ctx); - cfs_spin_lock(&ctx->cc_sec->ps_lock); + spin_lock(&ctx->cc_sec->ps_lock); - if (cfs_test_and_clear_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags)) { - LASSERT(!cfs_hlist_unhashed(&ctx->cc_cache)); - LASSERT(cfs_atomic_read(&ctx->cc_refcount) > 1); + if (test_and_clear_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags)) { + LASSERT(!hlist_unhashed(&ctx->cc_cache)); + LASSERT(atomic_read(&ctx->cc_refcount) > 1); - cfs_hlist_del_init(&ctx->cc_cache); - if (cfs_atomic_dec_and_test(&ctx->cc_refcount)) - LBUG(); - } + hlist_del_init(&ctx->cc_cache); + if (atomic_dec_and_test(&ctx->cc_refcount)) + LBUG(); + } - cfs_spin_unlock(&ctx->cc_sec->ps_lock); + spin_unlock(&ctx->cc_sec->ps_lock); } /**************************************** @@ -265,12 +258,12 @@ static void gss_sec_ctx_replace_pf(struct gss_sec *gsec, struct ptlrpc_cli_ctx *new) { - struct gss_sec_pipefs *gsec_pf; - struct ptlrpc_cli_ctx *ctx; - cfs_hlist_node_t *pos, *next; - CFS_HLIST_HEAD(freelist); - unsigned int hash; - ENTRY; + struct hlist_node __maybe_unused *pos, *next; + struct gss_sec_pipefs *gsec_pf; + struct ptlrpc_cli_ctx *ctx; + HLIST_HEAD(freelist); + unsigned int hash; + ENTRY; gsec_pf = container_of(gsec, struct gss_sec_pipefs, gsp_base); @@ -278,7 +271,7 @@ void gss_sec_ctx_replace_pf(struct gss_sec *gsec, (__u64) new->cc_vcred.vc_uid); LASSERT(hash < gsec_pf->gsp_chash_size); - cfs_spin_lock(&gsec->gs_base.ps_lock); + spin_lock(&gsec->gs_base.ps_lock); cfs_hlist_for_each_entry_safe(ctx, pos, next, &gsec_pf->gsp_chash[hash], cc_cache) { @@ -292,7 +285,7 @@ void gss_sec_ctx_replace_pf(struct gss_sec *gsec, ctx_enhash_pf(new, &gsec_pf->gsp_chash[hash]); - cfs_spin_unlock(&gsec->gs_base.ps_lock); + spin_unlock(&gsec->gs_base.ps_lock); ctx_list_destroy_pf(&freelist); EXIT; @@ -326,13 +319,14 @@ int gss_install_rvs_cli_ctx_pf(struct gss_sec *gsec, static void gss_ctx_cache_gc_pf(struct gss_sec_pipefs *gsec_pf, - cfs_hlist_head_t *freelist) + struct hlist_head *freelist) { - struct ptlrpc_sec *sec; - struct ptlrpc_cli_ctx *ctx; - cfs_hlist_node_t *pos, *next; - int i; - ENTRY; + struct ptlrpc_sec *sec; + struct ptlrpc_cli_ctx *ctx; + struct hlist_node __maybe_unused *pos; + struct hlist_node *next; + int i; + ENTRY; sec = &gsec_pf->gsp_base.gs_base; @@ -344,8 +338,8 @@ void gss_ctx_cache_gc_pf(struct gss_sec_pipefs *gsec_pf, ctx_check_death_locked_pf(ctx, freelist); } - sec->ps_gc_next = cfs_time_current_sec() + sec->ps_gc_interval; - EXIT; + sec->ps_gc_next = ktime_get_real_seconds() + sec->ps_gc_interval; + EXIT; } static @@ -366,7 +360,7 @@ struct ptlrpc_sec* gss_sec_create_pf(struct obd_import *imp, hash_size = GSS_SEC_PIPEFS_CTX_HASH_SIZE; alloc_size = sizeof(*gsec_pf) + - sizeof(cfs_hlist_head_t) * hash_size; + sizeof(struct hlist_head) * hash_size; OBD_ALLOC(gsec_pf, alloc_size); if (!gsec_pf) @@ -374,7 +368,7 @@ struct ptlrpc_sec* gss_sec_create_pf(struct obd_import *imp, gsec_pf->gsp_chash_size = hash_size; for (i = 0; i < hash_size; i++) - CFS_INIT_HLIST_HEAD(&gsec_pf->gsp_chash[i]); + INIT_HLIST_HEAD(&gsec_pf->gsp_chash[i]); if (gss_sec_create_common(&gsec_pf->gsp_base, &gss_policy_pipefs, imp, ctx, sf)) @@ -416,7 +410,7 @@ void gss_sec_destroy_pf(struct ptlrpc_sec *sec) gss_sec_destroy_common(gsec); OBD_FREE(gsec, sizeof(*gsec_pf) + - sizeof(cfs_hlist_head_t) * gsec_pf->gsp_chash_size); + sizeof(struct hlist_head) * gsec_pf->gsp_chash_size); } static @@ -424,19 +418,19 @@ struct ptlrpc_cli_ctx * gss_sec_lookup_ctx_pf(struct ptlrpc_sec *sec, struct vfs_cred *vcred, int create, int remove_dead) { - struct gss_sec *gsec; - struct gss_sec_pipefs *gsec_pf; - struct ptlrpc_cli_ctx *ctx = NULL, *new = NULL; - cfs_hlist_head_t *hash_head; - cfs_hlist_node_t *pos, *next; - CFS_HLIST_HEAD(freelist); - unsigned int hash, gc = 0, found = 0; - ENTRY; + struct gss_sec *gsec; + struct gss_sec_pipefs *gsec_pf; + struct ptlrpc_cli_ctx *ctx = NULL, *new = NULL; + struct hlist_head *hash_head; + struct hlist_node __maybe_unused *pos, *next; + unsigned int hash, gc = 0, found = 0; + HLIST_HEAD(freelist); + ENTRY; - cfs_might_sleep(); + might_sleep(); - gsec = container_of(sec, struct gss_sec, gs_base); - gsec_pf = container_of(gsec, struct gss_sec_pipefs, gsp_base); + gsec = container_of(sec, struct gss_sec, gs_base); + gsec_pf = container_of(gsec, struct gss_sec_pipefs, gsp_base); hash = ctx_hash_index(gsec_pf->gsp_chash_size, (__u64) vcred->vc_uid); @@ -444,14 +438,14 @@ struct ptlrpc_cli_ctx * gss_sec_lookup_ctx_pf(struct ptlrpc_sec *sec, LASSERT(hash < gsec_pf->gsp_chash_size); retry: - cfs_spin_lock(&sec->ps_lock); + spin_lock(&sec->ps_lock); - /* gc_next == 0 means never do gc */ - if (remove_dead && sec->ps_gc_next && - cfs_time_after(cfs_time_current_sec(), sec->ps_gc_next)) { - gss_ctx_cache_gc_pf(gsec_pf, &freelist); - gc = 1; - } + /* gc_next == 0 means never do gc */ + if (remove_dead && sec->ps_gc_next && + (ktime_get_real_seconds() > sec->ps_gc_next)) { + gss_ctx_cache_gc_pf(gsec_pf, &freelist); + gc = 1; + } cfs_hlist_for_each_entry_safe(ctx, pos, next, hash_head, cc_cache) { if (gc == 0 && @@ -468,51 +462,51 @@ retry: if (found) { if (new && new != ctx) { /* lost the race, just free it */ - cfs_hlist_add_head(&new->cc_cache, &freelist); + hlist_add_head(&new->cc_cache, &freelist); new = NULL; } /* hot node, move to head */ if (hash_head->first != &ctx->cc_cache) { - __cfs_hlist_del(&ctx->cc_cache); - cfs_hlist_add_head(&ctx->cc_cache, hash_head); + __hlist_del(&ctx->cc_cache); + hlist_add_head(&ctx->cc_cache, hash_head); } } else { /* don't allocate for reverse sec */ if (sec_is_reverse(sec)) { - cfs_spin_unlock(&sec->ps_lock); - RETURN(NULL); - } - - if (new) { - ctx_enhash_pf(new, hash_head); - ctx = new; - } else if (create) { - cfs_spin_unlock(&sec->ps_lock); - new = ctx_create_pf(sec, vcred); - if (new) { - cfs_clear_bit(PTLRPC_CTX_NEW_BIT, - &new->cc_flags); - goto retry; - } - } else - ctx = NULL; - } - - /* hold a ref */ - if (ctx) - cfs_atomic_inc(&ctx->cc_refcount); - - cfs_spin_unlock(&sec->ps_lock); - - /* the allocator of the context must give the first push to refresh */ - if (new) { - LASSERT(new == ctx); - gss_cli_ctx_refresh_pf(new); - } - - ctx_list_destroy_pf(&freelist); - RETURN(ctx); + spin_unlock(&sec->ps_lock); + RETURN(NULL); + } + + if (new) { + ctx_enhash_pf(new, hash_head); + ctx = new; + } else if (create) { + spin_unlock(&sec->ps_lock); + new = ctx_create_pf(sec, vcred); + if (new) { + clear_bit(PTLRPC_CTX_NEW_BIT, &new->cc_flags); + goto retry; + } + } else { + ctx = NULL; + } + } + + /* hold a ref */ + if (ctx) + atomic_inc(&ctx->cc_refcount); + + spin_unlock(&sec->ps_lock); + + /* the allocator of the context must give the first push to refresh */ + if (new) { + LASSERT(new == ctx); + gss_cli_ctx_refresh_pf(new); + } + + ctx_list_destroy_pf(&freelist); + RETURN(ctx); } static @@ -520,13 +514,13 @@ void gss_sec_release_ctx_pf(struct ptlrpc_sec *sec, struct ptlrpc_cli_ctx *ctx, int sync) { - LASSERT(cfs_test_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags) == 0); - LASSERT(cfs_hlist_unhashed(&ctx->cc_cache)); + LASSERT(test_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags) == 0); + LASSERT(hlist_unhashed(&ctx->cc_cache)); /* if required async, we must clear the UPTODATE bit to prevent extra * rpcs during destroy procedure. */ if (!sync) - cfs_clear_bit(PTLRPC_CTX_UPTODATE_BIT, &ctx->cc_flags); + clear_bit(PTLRPC_CTX_UPTODATE_BIT, &ctx->cc_flags); /* destroy this context */ ctx_destroy_pf(sec, ctx); @@ -547,52 +541,52 @@ int gss_sec_flush_ctx_cache_pf(struct ptlrpc_sec *sec, uid_t uid, int grace, int force) { - struct gss_sec *gsec; - struct gss_sec_pipefs *gsec_pf; - struct ptlrpc_cli_ctx *ctx; - cfs_hlist_node_t *pos, *next; - CFS_HLIST_HEAD(freelist); - int i, busy = 0; - ENTRY; - - might_sleep_if(grace); - - gsec = container_of(sec, struct gss_sec, gs_base); - gsec_pf = container_of(gsec, struct gss_sec_pipefs, gsp_base); - - cfs_spin_lock(&sec->ps_lock); - for (i = 0; i < gsec_pf->gsp_chash_size; i++) { - cfs_hlist_for_each_entry_safe(ctx, pos, next, - &gsec_pf->gsp_chash[i], - cc_cache) { - LASSERT(cfs_atomic_read(&ctx->cc_refcount) > 0); - - if (uid != -1 && uid != ctx->cc_vcred.vc_uid) - continue; - - if (cfs_atomic_read(&ctx->cc_refcount) > 1) { - busy++; - if (!force) - continue; - - CWARN("flush busy(%d) ctx %p(%u->%s) by force, " - "grace %d\n", - cfs_atomic_read(&ctx->cc_refcount), - ctx, ctx->cc_vcred.vc_uid, - sec2target_str(ctx->cc_sec), grace); - } - ctx_unhash_pf(ctx, &freelist); - - cfs_set_bit(PTLRPC_CTX_DEAD_BIT, &ctx->cc_flags); - if (!grace) - cfs_clear_bit(PTLRPC_CTX_UPTODATE_BIT, - &ctx->cc_flags); - } - } - cfs_spin_unlock(&sec->ps_lock); - - ctx_list_destroy_pf(&freelist); - RETURN(busy); + struct gss_sec *gsec; + struct gss_sec_pipefs *gsec_pf; + struct ptlrpc_cli_ctx *ctx; + struct hlist_node __maybe_unused *pos, *next; + HLIST_HEAD(freelist); + int i, busy = 0; + ENTRY; + + might_sleep_if(grace); + + gsec = container_of(sec, struct gss_sec, gs_base); + gsec_pf = container_of(gsec, struct gss_sec_pipefs, gsp_base); + + spin_lock(&sec->ps_lock); + for (i = 0; i < gsec_pf->gsp_chash_size; i++) { + cfs_hlist_for_each_entry_safe(ctx, pos, next, + &gsec_pf->gsp_chash[i], + cc_cache) { + LASSERT(atomic_read(&ctx->cc_refcount) > 0); + + if (uid != -1 && uid != ctx->cc_vcred.vc_uid) + continue; + + if (atomic_read(&ctx->cc_refcount) > 1) { + busy++; + if (!force) + continue; + + CWARN("flush busy(%d) ctx %p(%u->%s) by force, " + "grace %d\n", + atomic_read(&ctx->cc_refcount), + ctx, ctx->cc_vcred.vc_uid, + sec2target_str(ctx->cc_sec), grace); + } + ctx_unhash_pf(ctx, &freelist); + + set_bit(PTLRPC_CTX_DEAD_BIT, &ctx->cc_flags); + if (!grace) + clear_bit(PTLRPC_CTX_UPTODATE_BIT, + &ctx->cc_flags); + } + } + spin_unlock(&sec->ps_lock); + + ctx_list_destroy_pf(&freelist); + RETURN(busy); } /**************************************** @@ -637,21 +631,21 @@ struct gss_upcall_msg_data { }; struct gss_upcall_msg { - struct rpc_pipe_msg gum_base; - cfs_atomic_t gum_refcount; - cfs_list_t gum_list; - __u32 gum_mechidx; - struct gss_sec *gum_gsec; - struct gss_cli_ctx *gum_gctx; - struct gss_upcall_msg_data gum_data; + struct rpc_pipe_msg gum_base; + atomic_t gum_refcount; + struct list_head gum_list; + __u32 gum_mechidx; + struct gss_sec *gum_gsec; + struct gss_cli_ctx *gum_gctx; + struct gss_upcall_msg_data gum_data; }; -static cfs_atomic_t upcall_seq = CFS_ATOMIC_INIT(0); +static atomic_t upcall_seq = ATOMIC_INIT(0); static inline __u32 upcall_get_sequence(void) { - return (__u32) cfs_atomic_inc_return(&upcall_seq); + return (__u32) atomic_inc_return(&upcall_seq); } enum mech_idx_t { @@ -669,40 +663,40 @@ __u32 mech_name2idx(const char *name) /* pipefs dentries for each mechanisms */ static struct dentry *de_pipes[MECH_MAX] = { NULL, }; /* all upcall messgaes linked here */ -static cfs_list_t upcall_lists[MECH_MAX]; +static struct list_head upcall_lists[MECH_MAX]; /* and protected by this */ -static cfs_spinlock_t upcall_locks[MECH_MAX]; +static spinlock_t upcall_locks[MECH_MAX]; static inline void upcall_list_lock(int idx) { - cfs_spin_lock(&upcall_locks[idx]); + spin_lock(&upcall_locks[idx]); } static inline void upcall_list_unlock(int idx) { - cfs_spin_unlock(&upcall_locks[idx]); + spin_unlock(&upcall_locks[idx]); } static void upcall_msg_enlist(struct gss_upcall_msg *msg) { - __u32 idx = msg->gum_mechidx; + __u32 idx = msg->gum_mechidx; - upcall_list_lock(idx); - cfs_list_add(&msg->gum_list, &upcall_lists[idx]); - upcall_list_unlock(idx); + upcall_list_lock(idx); + list_add(&msg->gum_list, &upcall_lists[idx]); + upcall_list_unlock(idx); } static void upcall_msg_delist(struct gss_upcall_msg *msg) { - __u32 idx = msg->gum_mechidx; + __u32 idx = msg->gum_mechidx; - upcall_list_lock(idx); - cfs_list_del_init(&msg->gum_list); - upcall_list_unlock(idx); + upcall_list_lock(idx); + list_del_init(&msg->gum_list); + upcall_list_unlock(idx); } /**************************************** @@ -712,13 +706,13 @@ void upcall_msg_delist(struct gss_upcall_msg *msg) static void gss_release_msg(struct gss_upcall_msg *gmsg) { - ENTRY; - LASSERT(cfs_atomic_read(&gmsg->gum_refcount) > 0); + ENTRY; + LASSERT(atomic_read(&gmsg->gum_refcount) > 0); - if (!cfs_atomic_dec_and_test(&gmsg->gum_refcount)) { - EXIT; - return; - } + if (!atomic_dec_and_test(&gmsg->gum_refcount)) { + EXIT; + return; + } if (gmsg->gum_gctx) { sptlrpc_cli_ctx_wakeup(&gmsg->gum_gctx->gc_base); @@ -726,26 +720,26 @@ void gss_release_msg(struct gss_upcall_msg *gmsg) gmsg->gum_gctx = NULL; } - LASSERT(cfs_list_empty(&gmsg->gum_list)); - LASSERT(cfs_list_empty(&gmsg->gum_base.list)); - OBD_FREE_PTR(gmsg); - EXIT; + LASSERT(list_empty(&gmsg->gum_list)); + LASSERT(list_empty(&gmsg->gum_base.list)); + OBD_FREE_PTR(gmsg); + EXIT; } static void gss_unhash_msg_nolock(struct gss_upcall_msg *gmsg) { - __u32 idx = gmsg->gum_mechidx; + __u32 idx = gmsg->gum_mechidx; - LASSERT(idx < MECH_MAX); - LASSERT_SPIN_LOCKED(&upcall_locks[idx]); + LASSERT(idx < MECH_MAX); + assert_spin_locked(&upcall_locks[idx]); - if (cfs_list_empty(&gmsg->gum_list)) - return; + if (list_empty(&gmsg->gum_list)) + return; - cfs_list_del_init(&gmsg->gum_list); - LASSERT(cfs_atomic_read(&gmsg->gum_refcount) > 1); - cfs_atomic_dec(&gmsg->gum_refcount); + list_del_init(&gmsg->gum_list); + LASSERT(atomic_read(&gmsg->gum_refcount) > 1); + atomic_dec(&gmsg->gum_refcount); } static @@ -762,34 +756,34 @@ void gss_unhash_msg(struct gss_upcall_msg *gmsg) static void gss_msg_fail_ctx(struct gss_upcall_msg *gmsg) { - if (gmsg->gum_gctx) { - struct ptlrpc_cli_ctx *ctx = &gmsg->gum_gctx->gc_base; + if (gmsg->gum_gctx) { + struct ptlrpc_cli_ctx *ctx = &gmsg->gum_gctx->gc_base; - LASSERT(cfs_atomic_read(&ctx->cc_refcount) > 0); - sptlrpc_cli_ctx_expire(ctx); - cfs_set_bit(PTLRPC_CTX_ERROR_BIT, &ctx->cc_flags); - } + LASSERT(atomic_read(&ctx->cc_refcount) > 0); + sptlrpc_cli_ctx_expire(ctx); + set_bit(PTLRPC_CTX_ERROR_BIT, &ctx->cc_flags); + } } static struct gss_upcall_msg * gss_find_upcall(__u32 mechidx, __u32 seq) { - struct gss_upcall_msg *gmsg; - - upcall_list_lock(mechidx); - cfs_list_for_each_entry(gmsg, &upcall_lists[mechidx], gum_list) { - if (gmsg->gum_data.gum_seq != seq) - continue; - - LASSERT(cfs_atomic_read(&gmsg->gum_refcount) > 0); - LASSERT(gmsg->gum_mechidx == mechidx); - - cfs_atomic_inc(&gmsg->gum_refcount); - upcall_list_unlock(mechidx); - return gmsg; - } - upcall_list_unlock(mechidx); - return NULL; + struct gss_upcall_msg *gmsg; + + upcall_list_lock(mechidx); + list_for_each_entry(gmsg, &upcall_lists[mechidx], gum_list) { + if (gmsg->gum_data.gum_seq != seq) + continue; + + LASSERT(atomic_read(&gmsg->gum_refcount) > 0); + LASSERT(gmsg->gum_mechidx == mechidx); + + atomic_inc(&gmsg->gum_refcount); + upcall_list_unlock(mechidx); + return gmsg; + } + upcall_list_unlock(mechidx); + return NULL; } static @@ -821,7 +815,7 @@ ssize_t gss_pipe_upcall(struct file *filp, struct rpc_pipe_msg *msg, if (mlen > buflen) mlen = buflen; - left = cfs_copy_to_user(dst, data, mlen); + left = copy_to_user(dst, data, mlen); if (left < 0) { msg->errno = left; RETURN(left); @@ -835,7 +829,7 @@ ssize_t gss_pipe_upcall(struct file *filp, struct rpc_pipe_msg *msg, static ssize_t gss_pipe_downcall(struct file *filp, const char *src, size_t mlen) { - struct rpc_inode *rpci = RPC_I(filp->f_dentry->d_inode); + struct rpc_inode *rpci = RPC_I(file_inode(filp)); struct gss_upcall_msg *gss_msg; struct ptlrpc_cli_ctx *ctx; struct gss_cli_ctx *gctx = NULL; @@ -852,7 +846,7 @@ ssize_t gss_pipe_downcall(struct file *filp, const char *src, size_t mlen) if (!buf) RETURN(-ENOMEM); - if (cfs_copy_from_user(buf, src, mlen)) { + if (copy_from_user(buf, src, mlen)) { CERROR("failed copy user space data\n"); GOTO(out_free, rc = -EFAULT); } @@ -877,10 +871,10 @@ ssize_t gss_pipe_downcall(struct file *filp, const char *src, size_t mlen) GOTO(out_free, rc = -EINVAL); } - gss_unhash_msg(gss_msg); - gctx = gss_msg->gum_gctx; - LASSERT(gctx); - LASSERT(cfs_atomic_read(&gctx->gc_base.cc_refcount) > 0); + gss_unhash_msg(gss_msg); + gctx = gss_msg->gum_gctx; + LASSERT(gctx); + LASSERT(atomic_read(&gctx->gc_base.cc_refcount) > 0); /* timeout is not in use for now */ if (simple_get_bytes(&data, &datalen, &timeout, sizeof(timeout))) @@ -929,11 +923,11 @@ ssize_t gss_pipe_downcall(struct file *filp, const char *src, size_t mlen) ctx = &gctx->gc_base; sptlrpc_cli_ctx_expire(ctx); if (rc != -ERESTART || gss_err != GSS_S_COMPLETE) - cfs_set_bit(PTLRPC_CTX_ERROR_BIT, &ctx->cc_flags); + set_bit(PTLRPC_CTX_ERROR_BIT, &ctx->cc_flags); CERROR("refresh ctx %p(uid %d) failed: %d/0x%08x: %s\n", ctx, ctx->cc_vcred.vc_uid, rc, gss_err, - cfs_test_bit(PTLRPC_CTX_ERROR_BIT, &ctx->cc_flags) ? + test_bit(PTLRPC_CTX_ERROR_BIT, &ctx->cc_flags) ? "fatal error" : "non-fatal"); } @@ -956,10 +950,10 @@ void gss_pipe_destroy_msg(struct rpc_pipe_msg *msg) { struct gss_upcall_msg *gmsg; struct gss_upcall_msg_data *gumd; - static cfs_time_t ratelimit = 0; + static time64_t ratelimit; ENTRY; - LASSERT(cfs_list_empty(&msg->list)); + LASSERT(list_empty(&msg->list)); /* normally errno is >= 0 */ if (msg->errno >= 0) { @@ -967,68 +961,68 @@ void gss_pipe_destroy_msg(struct rpc_pipe_msg *msg) return; } - gmsg = container_of(msg, struct gss_upcall_msg, gum_base); - gumd = &gmsg->gum_data; - LASSERT(cfs_atomic_read(&gmsg->gum_refcount) > 0); - - CERROR("failed msg %p (seq %u, uid %u, svc %u, nid "LPX64", obd %.*s): " - "errno %d\n", msg, gumd->gum_seq, gumd->gum_uid, gumd->gum_svc, - gumd->gum_nid, (int) sizeof(gumd->gum_obd), - gumd->gum_obd, msg->errno); - - cfs_atomic_inc(&gmsg->gum_refcount); - gss_unhash_msg(gmsg); - if (msg->errno == -ETIMEDOUT || msg->errno == -EPIPE) { - cfs_time_t now = cfs_time_current_sec(); - - if (cfs_time_after(now, ratelimit)) { - CWARN("upcall timed out, is lgssd running?\n"); - ratelimit = now + 15; - } - } - gss_msg_fail_ctx(gmsg); - gss_release_msg(gmsg); - EXIT; + gmsg = container_of(msg, struct gss_upcall_msg, gum_base); + gumd = &gmsg->gum_data; + LASSERT(atomic_read(&gmsg->gum_refcount) > 0); + + CERROR("failed msg %p (seq %u, uid %u, svc %u, nid %#llx, obd %.*s): " + "errno %d\n", msg, gumd->gum_seq, gumd->gum_uid, gumd->gum_svc, + gumd->gum_nid, (int) sizeof(gumd->gum_obd), + gumd->gum_obd, msg->errno); + + atomic_inc(&gmsg->gum_refcount); + gss_unhash_msg(gmsg); + if (msg->errno == -ETIMEDOUT || msg->errno == -EPIPE) { + time64_t now = ktime_get_real_seconds(); + + if (now > ratelimit) { + CWARN("upcall timed out, is lgssd running?\n"); + ratelimit = now + 15; + } + } + gss_msg_fail_ctx(gmsg); + gss_release_msg(gmsg); + EXIT; } static void gss_pipe_release(struct inode *inode) { - struct rpc_inode *rpci = RPC_I(inode); - __u32 idx; - ENTRY; + struct rpc_inode *rpci = RPC_I(inode); + __u32 idx; + ENTRY; - idx = (__u32) (long) rpci->private; - LASSERT(idx < MECH_MAX); + idx = (__u32) (long) rpci->private; + LASSERT(idx < MECH_MAX); - upcall_list_lock(idx); - while (!cfs_list_empty(&upcall_lists[idx])) { - struct gss_upcall_msg *gmsg; - struct gss_upcall_msg_data *gumd; + upcall_list_lock(idx); + while (!list_empty(&upcall_lists[idx])) { + struct gss_upcall_msg *gmsg; + struct gss_upcall_msg_data *gumd; - gmsg = cfs_list_entry(upcall_lists[idx].next, - struct gss_upcall_msg, gum_list); - gumd = &gmsg->gum_data; - LASSERT(cfs_list_empty(&gmsg->gum_base.list)); + gmsg = list_entry(upcall_lists[idx].next, + struct gss_upcall_msg, gum_list); + gumd = &gmsg->gum_data; + LASSERT(list_empty(&gmsg->gum_base.list)); CERROR("failing remaining msg %p:seq %u, uid %u, svc %u, " - "nid "LPX64", obd %.*s\n", gmsg, + "nid %#llx, obd %.*s\n", gmsg, gumd->gum_seq, gumd->gum_uid, gumd->gum_svc, gumd->gum_nid, (int) sizeof(gumd->gum_obd), gumd->gum_obd); - gmsg->gum_base.errno = -EPIPE; - cfs_atomic_inc(&gmsg->gum_refcount); - gss_unhash_msg_nolock(gmsg); + gmsg->gum_base.errno = -EPIPE; + atomic_inc(&gmsg->gum_refcount); + gss_unhash_msg_nolock(gmsg); - gss_msg_fail_ctx(gmsg); + gss_msg_fail_ctx(gmsg); - upcall_list_unlock(idx); - gss_release_msg(gmsg); - upcall_list_lock(idx); - } - upcall_list_unlock(idx); - EXIT; + upcall_list_unlock(idx); + gss_release_msg(gmsg); + upcall_list_lock(idx); + } + upcall_list_unlock(idx); + EXIT; } static struct rpc_pipe_ops gss_upcall_ops = { @@ -1045,17 +1039,17 @@ static struct rpc_pipe_ops gss_upcall_ops = { static int gss_ctx_refresh_pf(struct ptlrpc_cli_ctx *ctx) { - struct obd_import *imp; - struct gss_sec *gsec; - struct gss_upcall_msg *gmsg; - int rc = 0; - ENTRY; + struct obd_import *imp; + struct gss_sec *gsec; + struct gss_upcall_msg *gmsg; + int rc = 0; + ENTRY; - cfs_might_sleep(); + might_sleep(); - LASSERT(ctx->cc_sec); - LASSERT(ctx->cc_sec->ps_import); - LASSERT(ctx->cc_sec->ps_import->imp_obd); + LASSERT(ctx->cc_sec); + LASSERT(ctx->cc_sec->ps_import); + LASSERT(ctx->cc_sec->ps_import->imp_obd); imp = ctx->cc_sec->ps_import; if (!imp->imp_connection) { @@ -1070,25 +1064,25 @@ int gss_ctx_refresh_pf(struct ptlrpc_cli_ctx *ctx) RETURN(-ENOMEM); /* initialize pipefs base msg */ - CFS_INIT_LIST_HEAD(&gmsg->gum_base.list); + INIT_LIST_HEAD(&gmsg->gum_base.list); gmsg->gum_base.data = &gmsg->gum_data; gmsg->gum_base.len = sizeof(gmsg->gum_data); gmsg->gum_base.copied = 0; gmsg->gum_base.errno = 0; - /* init upcall msg */ - cfs_atomic_set(&gmsg->gum_refcount, 1); - gmsg->gum_mechidx = mech_name2idx(gsec->gs_mech->gm_name); - gmsg->gum_gsec = gsec; - gmsg->gum_gctx = container_of(sptlrpc_cli_ctx_get(ctx), - struct gss_cli_ctx, gc_base); - gmsg->gum_data.gum_seq = upcall_get_sequence(); - gmsg->gum_data.gum_uid = ctx->cc_vcred.vc_uid; - gmsg->gum_data.gum_gid = 0; /* not used for now */ - gmsg->gum_data.gum_svc = import_to_gss_svc(imp); - gmsg->gum_data.gum_nid = imp->imp_connection->c_peer.nid; - strncpy(gmsg->gum_data.gum_obd, imp->imp_obd->obd_name, - sizeof(gmsg->gum_data.gum_obd)); + /* init upcall msg */ + atomic_set(&gmsg->gum_refcount, 1); + gmsg->gum_mechidx = mech_name2idx(gsec->gs_mech->gm_name); + gmsg->gum_gsec = gsec; + gmsg->gum_gctx = container_of(sptlrpc_cli_ctx_get(ctx), + struct gss_cli_ctx, gc_base); + gmsg->gum_data.gum_seq = upcall_get_sequence(); + gmsg->gum_data.gum_uid = ctx->cc_vcred.vc_uid; + gmsg->gum_data.gum_gid = 0; /* not used for now */ + gmsg->gum_data.gum_svc = import_to_gss_svc(imp); + gmsg->gum_data.gum_nid = imp->imp_connection->c_peer.nid; + strlcpy(gmsg->gum_data.gum_obd, imp->imp_obd->obd_name, + sizeof(gmsg->gum_data.gum_obd)); /* This only could happen when sysadmin set it dead/expired * using lctl by force. */ @@ -1214,26 +1208,26 @@ int __init gss_init_pipefs_upcall(void) } de_pipes[MECH_KRB5] = de; - CFS_INIT_LIST_HEAD(&upcall_lists[MECH_KRB5]); - cfs_spin_lock_init(&upcall_locks[MECH_KRB5]); + INIT_LIST_HEAD(&upcall_lists[MECH_KRB5]); + spin_lock_init(&upcall_locks[MECH_KRB5]); - return 0; + return 0; } static void __exit gss_exit_pipefs_upcall(void) { - __u32 i; + __u32 i; - for (i = 0; i < MECH_MAX; i++) { - LASSERT(cfs_list_empty(&upcall_lists[i])); + for (i = 0; i < MECH_MAX; i++) { + LASSERT(list_empty(&upcall_lists[i])); - /* dput pipe dentry here might cause lgssd oops. */ - de_pipes[i] = NULL; - } + /* dput pipe dentry here might cause lgssd oops. */ + de_pipes[i] = NULL; + } - rpc_unlink(LUSTRE_PIPE_KRB5); - rpc_rmdir(LUSTRE_PIPE_ROOT); + rpc_unlink(LUSTRE_PIPE_KRB5); + rpc_rmdir(LUSTRE_PIPE_ROOT); } int __init gss_init_pipefs(void) @@ -1255,6 +1249,6 @@ int __init gss_init_pipefs(void) void __exit gss_exit_pipefs(void) { - gss_exit_pipefs_upcall(); - sptlrpc_unregister_policy(&gss_policy_pipefs); + gss_exit_pipefs_upcall(); + sptlrpc_unregister_policy(&gss_policy_pipefs); }