diff options
Diffstat (limited to 'drivers/staging/lustre/lustre/ptlrpc')
33 files changed, 1091 insertions, 1031 deletions
diff --git a/drivers/staging/lustre/lustre/ptlrpc/Makefile b/drivers/staging/lustre/lustre/ptlrpc/Makefile index 983eb66a554d..6d78b80487f2 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/Makefile +++ b/drivers/staging/lustre/lustre/ptlrpc/Makefile @@ -16,6 +16,7 @@ ptlrpc_objs += sec.o sec_bulk.o sec_gc.o sec_config.o sec_lproc.o ptlrpc_objs += sec_null.o sec_plain.o nrs.o nrs_fifo.o ptlrpc-y := $(ldlm_objs) $(ptlrpc_objs) +ptlrpc-$(CONFIG_LUSTRE_TRANSLATE_ERRNOS) += errno.o obj-$(CONFIG_PTLRPC_GSS) += gss/ diff --git a/drivers/staging/lustre/lustre/ptlrpc/client.c b/drivers/staging/lustre/lustre/ptlrpc/client.c index 22f7e654c9d8..810a458caed7 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/client.c +++ b/drivers/staging/lustre/lustre/ptlrpc/client.c @@ -137,11 +137,10 @@ struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_imp(struct ptlrpc_request *req, struct obd_import *imp = req->rq_import; struct ptlrpc_bulk_desc *desc; - ENTRY; LASSERT(type == BULK_PUT_SINK || type == BULK_GET_SOURCE); desc = ptlrpc_new_bulk(npages, max_brw, type, portal); if (desc == NULL) - RETURN(NULL); + return NULL; desc->bd_import_generation = req->rq_import_generation; desc->bd_import = class_import_get(imp); @@ -187,7 +186,6 @@ EXPORT_SYMBOL(__ptlrpc_prep_bulk_page); void __ptlrpc_free_bulk(struct ptlrpc_bulk_desc *desc, int unpin) { int i; - ENTRY; LASSERT(desc != NULL); LASSERT(desc->bd_iov_count != LI_POISON); /* not freed already */ @@ -208,7 +206,6 @@ void __ptlrpc_free_bulk(struct ptlrpc_bulk_desc *desc, int unpin) OBD_FREE(desc, offsetof(struct ptlrpc_bulk_desc, bd_iov[desc->bd_max_iov])); - EXIT; } EXPORT_SYMBOL(__ptlrpc_free_bulk); @@ -336,7 +333,6 @@ static int ptlrpc_at_recv_early_reply(struct ptlrpc_request *req) struct ptlrpc_request *early_req; time_t olddl; int rc; - ENTRY; req->rq_early = 0; spin_unlock(&req->rq_lock); @@ -344,7 +340,7 @@ static int ptlrpc_at_recv_early_reply(struct ptlrpc_request *req) rc = sptlrpc_cli_unwrap_early_reply(req, &early_req); if (rc) { spin_lock(&req->rq_lock); - RETURN(rc); + return rc; } rc = unpack_reply(early_req); @@ -360,7 +356,7 @@ static int ptlrpc_at_recv_early_reply(struct ptlrpc_request *req) if (rc != 0) { spin_lock(&req->rq_lock); - RETURN(rc); + return rc; } /* Adjust the local timeout for this req */ @@ -379,7 +375,7 @@ static int ptlrpc_at_recv_early_reply(struct ptlrpc_request *req) cfs_time_sub(req->rq_deadline, cfs_time_current_sec()), cfs_time_sub(req->rq_deadline, olddl)); - RETURN(rc); + return rc; } /** @@ -547,7 +543,6 @@ static int __ptlrpc_request_bufs_pack(struct ptlrpc_request *request, { struct obd_import *imp = request->rq_import; int rc; - ENTRY; if (unlikely(ctx)) request->rq_cli_ctx = sptlrpc_cli_ctx_get(ctx); @@ -601,7 +596,7 @@ static int __ptlrpc_request_bufs_pack(struct ptlrpc_request *request, lustre_msg_set_opc(request->rq_reqmsg, opcode); - RETURN(0); + return 0; out_ctx: sptlrpc_cli_ctx_put(request->rq_cli_ctx, 1); out_free: @@ -822,10 +817,9 @@ struct ptlrpc_request_set *ptlrpc_prep_set(void) { struct ptlrpc_request_set *set; - ENTRY; OBD_ALLOC(set, sizeof *set); if (!set) - RETURN(NULL); + return NULL; atomic_set(&set->set_refcount, 1); INIT_LIST_HEAD(&set->set_requests); init_waitqueue_head(&set->set_waitq); @@ -839,7 +833,7 @@ struct ptlrpc_request_set *ptlrpc_prep_set(void) set->set_producer_arg = NULL; set->set_rc = 0; - RETURN(set); + return set; } EXPORT_SYMBOL(ptlrpc_prep_set); @@ -859,13 +853,13 @@ struct ptlrpc_request_set *ptlrpc_prep_fcset(int max, set_producer_func func, set = ptlrpc_prep_set(); if (!set) - RETURN(NULL); + return NULL; set->set_max_inflight = max; set->set_producer = func; set->set_producer_arg = arg; - RETURN(set); + return set; } EXPORT_SYMBOL(ptlrpc_prep_fcset); @@ -883,7 +877,6 @@ void ptlrpc_set_destroy(struct ptlrpc_request_set *set) struct list_head *next; int expected_phase; int n = 0; - ENTRY; /* Requests on the set should either all be completed, or all be new */ expected_phase = (atomic_read(&set->set_remaining) == 0) ? @@ -925,7 +918,6 @@ void ptlrpc_set_destroy(struct ptlrpc_request_set *set) LASSERT(atomic_read(&set->set_remaining) == 0); ptlrpc_reqset_put(set); - EXIT; } EXPORT_SYMBOL(ptlrpc_set_destroy); @@ -941,13 +933,13 @@ int ptlrpc_set_add_cb(struct ptlrpc_request_set *set, OBD_ALLOC_PTR(cbdata); if (cbdata == NULL) - RETURN(-ENOMEM); + return -ENOMEM; cbdata->psc_interpret = fn; cbdata->psc_data = data; list_add_tail(&cbdata->psc_item, &set->set_cblist); - RETURN(0); + return 0; } EXPORT_SYMBOL(ptlrpc_set_add_cb); @@ -1027,7 +1019,6 @@ static int ptlrpc_import_delay_req(struct obd_import *imp, struct ptlrpc_request *req, int *status) { int delay = 0; - ENTRY; LASSERT (status != NULL); *status = 0; @@ -1078,7 +1069,7 @@ static int ptlrpc_import_delay_req(struct obd_import *imp, } } - RETURN(delay); + return delay; } /** @@ -1120,7 +1111,6 @@ static int ptlrpc_console_allow(struct ptlrpc_request *req) static int ptlrpc_check_status(struct ptlrpc_request *req) { int err; - ENTRY; err = lustre_msg_get_status(req->rq_repmsg); if (lustre_msg_get_type(req->rq_repmsg) == PTL_RPC_MSG_ERR) { @@ -1133,7 +1123,7 @@ static int ptlrpc_check_status(struct ptlrpc_request *req) libcfs_nid2str( imp->imp_connection->c_peer.nid), ll_opcode2str(opc), err); - RETURN(err < 0 ? err : -EINVAL); + return err < 0 ? err : -EINVAL; } if (err < 0) { @@ -1143,7 +1133,7 @@ static int ptlrpc_check_status(struct ptlrpc_request *req) DEBUG_REQ(D_INFO, req, "status is %d", err); } - RETURN(err); + return err; } /** @@ -1156,7 +1146,6 @@ static void ptlrpc_save_versions(struct ptlrpc_request *req) struct lustre_msg *repmsg = req->rq_repmsg; struct lustre_msg *reqmsg = req->rq_reqmsg; __u64 *versions = lustre_msg_get_versions(repmsg); - ENTRY; if (lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY) return; @@ -1165,8 +1154,6 @@ static void ptlrpc_save_versions(struct ptlrpc_request *req) lustre_msg_set_versions(reqmsg, versions); CDEBUG(D_INFO, "Client save versions ["LPX64"/"LPX64"]\n", versions[0], versions[1]); - - EXIT; } /** @@ -1183,7 +1170,6 @@ static int after_reply(struct ptlrpc_request *req) int rc; struct timeval work_start; long timediff; - ENTRY; LASSERT(obd != NULL); /* repbuf must be unlinked */ @@ -1194,7 +1180,7 @@ static int after_reply(struct ptlrpc_request *req) DEBUG_REQ(D_ERROR, req, "reply buffer overflow," " expected: %d, actual size: %d", req->rq_nob_received, req->rq_repbuf_len); - RETURN(-EOVERFLOW); + return -EOVERFLOW; } sptlrpc_cli_free_repbuf(req); @@ -1205,7 +1191,7 @@ static int after_reply(struct ptlrpc_request *req) req->rq_replen = req->rq_nob_received; req->rq_nob_received = 0; req->rq_resend = 1; - RETURN(0); + return 0; } /* @@ -1215,18 +1201,18 @@ static int after_reply(struct ptlrpc_request *req) rc = sptlrpc_cli_unwrap_reply(req); if (rc) { DEBUG_REQ(D_ERROR, req, "unwrap reply failed (%d):", rc); - RETURN(rc); + return rc; } /* * Security layer unwrap might ask resend this request. */ if (req->rq_resend) - RETURN(0); + return 0; rc = unpack_reply(req); if (rc) - RETURN(rc); + return rc; /* retry indefinitely on EINPROGRESS */ if (lustre_msg_get_status(req->rq_repmsg) == -EINPROGRESS && @@ -1257,7 +1243,7 @@ static int after_reply(struct ptlrpc_request *req) else req->rq_sent = now + req->rq_nr_resend; - RETURN(0); + return 0; } do_gettimeofday(&work_start); @@ -1272,7 +1258,7 @@ static int after_reply(struct ptlrpc_request *req) lustre_msg_get_type(req->rq_repmsg) != PTL_RPC_MSG_ERR) { DEBUG_REQ(D_ERROR, req, "invalid packet received (type=%u)", lustre_msg_get_type(req->rq_repmsg)); - RETURN(-EPROTO); + return -EPROTO; } if (lustre_msg_get_opc(req->rq_reqmsg) != OBD_PING) @@ -1293,10 +1279,10 @@ static int after_reply(struct ptlrpc_request *req) if (ll_rpc_recoverable_error(rc)) { if (req->rq_send_state != LUSTRE_IMP_FULL || imp->imp_obd->obd_no_recov || imp->imp_dlm_fake) { - RETURN(rc); + return rc; } ptlrpc_request_handle_notconn(req); - RETURN(rc); + return rc; } } else { /* @@ -1360,7 +1346,7 @@ static int after_reply(struct ptlrpc_request *req) spin_unlock(&imp->imp_lock); } - RETURN(rc); + return rc; } /** @@ -1372,13 +1358,12 @@ static int ptlrpc_send_new_req(struct ptlrpc_request *req) { struct obd_import *imp = req->rq_import; int rc; - ENTRY; LASSERT(req->rq_phase == RQ_PHASE_NEW); if (req->rq_sent && (req->rq_sent > cfs_time_current_sec()) && (!req->rq_generation_set || req->rq_import_generation == imp->imp_generation)) - RETURN (0); + return 0; ptlrpc_rqphase_move(req, RQ_PHASE_RPC); @@ -1400,14 +1385,14 @@ static int ptlrpc_send_new_req(struct ptlrpc_request *req) list_add_tail(&req->rq_list, &imp->imp_delayed_list); atomic_inc(&req->rq_import->imp_inflight); spin_unlock(&imp->imp_lock); - RETURN(0); + return 0; } if (rc != 0) { spin_unlock(&imp->imp_lock); req->rq_status = rc; ptlrpc_rqphase_move(req, RQ_PHASE_INTERPRET); - RETURN(rc); + return rc; } LASSERT(list_empty(&req->rq_list)); @@ -1421,10 +1406,10 @@ static int ptlrpc_send_new_req(struct ptlrpc_request *req) if (rc) { if (req->rq_err) { req->rq_status = rc; - RETURN(1); + return 1; } else { req->rq_wait_ctx = 1; - RETURN(0); + return 0; } } @@ -1439,15 +1424,14 @@ static int ptlrpc_send_new_req(struct ptlrpc_request *req) if (rc) { DEBUG_REQ(D_HA, req, "send failed (%d); expect timeout", rc); req->rq_net_err = 1; - RETURN(rc); + return rc; } - RETURN(0); + return 0; } static inline int ptlrpc_set_producer(struct ptlrpc_request_set *set) { int remaining, rc; - ENTRY; LASSERT(set->set_producer != NULL); @@ -1461,11 +1445,11 @@ static inline int ptlrpc_set_producer(struct ptlrpc_request_set *set) /* no more RPC to produce */ set->set_producer = NULL; set->set_producer_arg = NULL; - RETURN(0); + return 0; } } - RETURN((atomic_read(&set->set_remaining) - remaining)); + return (atomic_read(&set->set_remaining) - remaining); } /** @@ -1478,10 +1462,9 @@ int ptlrpc_check_set(const struct lu_env *env, struct ptlrpc_request_set *set) { struct list_head *tmp, *next; int force_timer_recalc = 0; - ENTRY; if (atomic_read(&set->set_remaining) == 0) - RETURN(1); + return 1; list_for_each_safe(tmp, next, &set->set_requests) { struct ptlrpc_request *req = @@ -1834,7 +1817,7 @@ int ptlrpc_check_set(const struct lu_env *env, struct ptlrpc_request_set *set) } /* If we hit an error, we want to recover promptly. */ - RETURN(atomic_read(&set->set_remaining) == 0 || force_timer_recalc); + return atomic_read(&set->set_remaining) == 0 || force_timer_recalc; } EXPORT_SYMBOL(ptlrpc_check_set); @@ -1847,7 +1830,6 @@ int ptlrpc_expire_one_request(struct ptlrpc_request *req, int async_unlink) { struct obd_import *imp = req->rq_import; int rc = 0; - ENTRY; spin_lock(&req->rq_lock); req->rq_timedout = 1; @@ -1873,14 +1855,14 @@ int ptlrpc_expire_one_request(struct ptlrpc_request *req, int async_unlink) if (imp == NULL) { DEBUG_REQ(D_HA, req, "NULL import: already cleaned up?"); - RETURN(1); + return 1; } atomic_inc(&imp->imp_timeouts); /* The DLM server doesn't want recovery run on its imports. */ if (imp->imp_dlm_fake) - RETURN(1); + return 1; /* If this request is for recovery or other primordial tasks, * then error it out here. */ @@ -1894,7 +1876,7 @@ int ptlrpc_expire_one_request(struct ptlrpc_request *req, int async_unlink) req->rq_status = -ETIMEDOUT; req->rq_err = 1; spin_unlock(&req->rq_lock); - RETURN(1); + return 1; } /* if a request can't be resent we can't wait for an answer after @@ -1906,7 +1888,7 @@ int ptlrpc_expire_one_request(struct ptlrpc_request *req, int async_unlink) ptlrpc_fail_import(imp, lustre_msg_get_conn_cnt(req->rq_reqmsg)); - RETURN(rc); + return rc; } /** @@ -1919,7 +1901,6 @@ int ptlrpc_expired_set(void *data) struct ptlrpc_request_set *set = data; struct list_head *tmp; time_t now = cfs_time_current_sec(); - ENTRY; LASSERT(set != NULL); @@ -1955,7 +1936,7 @@ int ptlrpc_expired_set(void *data) * sleep so we can recalculate the timeout, or enable interrupts * if everyone's timed out. */ - RETURN(1); + return 1; } EXPORT_SYMBOL(ptlrpc_expired_set); @@ -2006,7 +1987,6 @@ int ptlrpc_set_next_timeout(struct ptlrpc_request_set *set) int timeout = 0; struct ptlrpc_request *req; int deadline; - ENTRY; SIGNAL_MASK_ASSERT(); /* XXX BUG 1511 */ @@ -2045,7 +2025,7 @@ int ptlrpc_set_next_timeout(struct ptlrpc_request_set *set) else if (timeout == 0 || timeout > deadline - now) timeout = deadline - now; } - RETURN(timeout); + return timeout; } EXPORT_SYMBOL(ptlrpc_set_next_timeout); @@ -2061,7 +2041,6 @@ int ptlrpc_set_wait(struct ptlrpc_request_set *set) struct ptlrpc_request *req; struct l_wait_info lwi; int rc, timeout; - ENTRY; if (set->set_producer) (void)ptlrpc_set_producer(set); @@ -2074,7 +2053,7 @@ int ptlrpc_set_wait(struct ptlrpc_request_set *set) } if (list_empty(&set->set_requests)) - RETURN(0); + return 0; do { timeout = ptlrpc_set_next_timeout(set); @@ -2171,7 +2150,7 @@ int ptlrpc_set_wait(struct ptlrpc_request_set *set) } } - RETURN(rc); + return rc; } EXPORT_SYMBOL(ptlrpc_set_wait); @@ -2185,9 +2164,7 @@ EXPORT_SYMBOL(ptlrpc_set_wait); */ static void __ptlrpc_free_req(struct ptlrpc_request *request, int locked) { - ENTRY; if (request == NULL) { - EXIT; return; } @@ -2240,7 +2217,6 @@ static void __ptlrpc_free_req(struct ptlrpc_request *request, int locked) __ptlrpc_free_req_to_pool(request); else OBD_FREE(request, sizeof(*request)); - EXIT; } static int __ptlrpc_req_finished(struct ptlrpc_request *request, int locked); @@ -2263,15 +2239,14 @@ EXPORT_SYMBOL(ptlrpc_req_finished_with_imp_lock); */ static int __ptlrpc_req_finished(struct ptlrpc_request *request, int locked) { - ENTRY; if (request == NULL) - RETURN(1); + return 1; if (request == LP_POISON || request->rq_reqmsg == LP_POISON) { CERROR("dereferencing freed request (bug 575)\n"); LBUG(); - RETURN(1); + return 1; } DEBUG_REQ(D_INFO, request, "refcount now %u", @@ -2279,10 +2254,10 @@ static int __ptlrpc_req_finished(struct ptlrpc_request *request, int locked) if (atomic_dec_and_test(&request->rq_refcount)) { __ptlrpc_free_req(request, locked); - RETURN(1); + return 1; } - RETURN(0); + return 0; } /** @@ -2332,7 +2307,7 @@ int ptlrpc_unregister_reply(struct ptlrpc_request *request, int async) * Nothing left to do. */ if (!ptlrpc_client_recv_or_unlink(request)) - RETURN(1); + return 1; LNetMDUnlink(request->rq_reply_md_h); @@ -2340,7 +2315,7 @@ int ptlrpc_unregister_reply(struct ptlrpc_request *request, int async) * Let's check it once again. */ if (!ptlrpc_client_recv_or_unlink(request)) - RETURN(1); + return 1; /* * Move to "Unregistering" phase as reply was not unlinked yet. @@ -2351,7 +2326,7 @@ int ptlrpc_unregister_reply(struct ptlrpc_request *request, int async) * Do not wait for unlink to finish. */ if (async) - RETURN(0); + return 0; /* * We have to l_wait_event() whatever the result, to give liblustre @@ -2372,7 +2347,7 @@ int ptlrpc_unregister_reply(struct ptlrpc_request *request, int async) &lwi); if (rc == 0) { ptlrpc_rqphase_move(request, request->rq_next_phase); - RETURN(1); + return 1; } LASSERT(rc == -ETIMEDOUT); @@ -2380,7 +2355,7 @@ int ptlrpc_unregister_reply(struct ptlrpc_request *request, int async) "rvcng=%d unlnk=%d", request->rq_receiving_reply, request->rq_must_unlink); } - RETURN(0); + return 0; } EXPORT_SYMBOL(ptlrpc_unregister_reply); @@ -2397,7 +2372,6 @@ void ptlrpc_free_committed(struct obd_import *imp) struct list_head *tmp, *saved; struct ptlrpc_request *req; struct ptlrpc_request *last_req = NULL; /* temporary fire escape */ - ENTRY; LASSERT(imp != NULL); @@ -2408,7 +2382,6 @@ void ptlrpc_free_committed(struct obd_import *imp) imp->imp_generation == imp->imp_last_generation_checked) { CDEBUG(D_INFO, "%s: skip recheck: last_committed "LPU64"\n", imp->imp_obd->obd_name, imp->imp_peer_committed_transno); - EXIT; return; } CDEBUG(D_RPCTRACE, "%s: committing for last_committed "LPU64" gen %d\n", @@ -2456,16 +2429,10 @@ free_req: list_del_init(&req->rq_replay_list); __ptlrpc_req_finished(req, 1); } - - EXIT; - return; } void ptlrpc_cleanup_client(struct obd_import *imp) { - ENTRY; - EXIT; - return; } EXPORT_SYMBOL(ptlrpc_cleanup_client); @@ -2517,9 +2484,8 @@ EXPORT_SYMBOL(ptlrpc_restart_req); */ struct ptlrpc_request *ptlrpc_request_addref(struct ptlrpc_request *req) { - ENTRY; atomic_inc(&req->rq_refcount); - RETURN(req); + return req; } EXPORT_SYMBOL(ptlrpc_request_addref); @@ -2588,7 +2554,6 @@ int ptlrpc_queue_wait(struct ptlrpc_request *req) { struct ptlrpc_request_set *set; int rc; - ENTRY; LASSERT(req->rq_set == NULL); LASSERT(!req->rq_receiving_reply); @@ -2596,7 +2561,7 @@ int ptlrpc_queue_wait(struct ptlrpc_request *req) set = ptlrpc_prep_set(); if (set == NULL) { CERROR("Unable to allocate ptlrpc set."); - RETURN(-ENOMEM); + return -ENOMEM; } /* for distributed debugging */ @@ -2608,7 +2573,7 @@ int ptlrpc_queue_wait(struct ptlrpc_request *req) rc = ptlrpc_set_wait(set); ptlrpc_set_destroy(set); - RETURN(rc); + return rc; } EXPORT_SYMBOL(ptlrpc_queue_wait); @@ -2629,7 +2594,6 @@ static int ptlrpc_replay_interpret(const struct lu_env *env, struct ptlrpc_replay_async_args *aa = data; struct obd_import *imp = req->rq_import; - ENTRY; atomic_dec(&imp->imp_replay_inflight); if (!ptlrpc_client_replied(req)) { @@ -2710,7 +2674,7 @@ static int ptlrpc_replay_interpret(const struct lu_env *env, /* this replay failed, so restart recovery */ ptlrpc_connect_import(imp); - RETURN(rc); + return rc; } /** @@ -2721,7 +2685,6 @@ static int ptlrpc_replay_interpret(const struct lu_env *env, int ptlrpc_replay_req(struct ptlrpc_request *req) { struct ptlrpc_replay_async_args *aa; - ENTRY; LASSERT(req->rq_import->imp_state == LUSTRE_IMP_REPLAY); @@ -2751,7 +2714,7 @@ int ptlrpc_replay_req(struct ptlrpc_request *req) ptlrpc_request_addref(req); /* ptlrpcd needs a ref */ ptlrpcd_add_req(req, PDL_POLICY_LOCAL, -1); - RETURN(0); + return 0; } EXPORT_SYMBOL(ptlrpc_replay_req); @@ -2761,7 +2724,6 @@ EXPORT_SYMBOL(ptlrpc_replay_req); void ptlrpc_abort_inflight(struct obd_import *imp) { struct list_head *tmp, *n; - ENTRY; /* Make sure that no new requests get processed for this import. * ptlrpc_{queue,set}_wait must (and does) hold imp_lock while testing @@ -2809,8 +2771,6 @@ void ptlrpc_abort_inflight(struct obd_import *imp) ptlrpc_free_committed(imp); spin_unlock(&imp->imp_lock); - - EXIT; } EXPORT_SYMBOL(ptlrpc_abort_inflight); @@ -2969,18 +2929,17 @@ void *ptlrpcd_alloc_work(struct obd_import *imp, { struct ptlrpc_request *req = NULL; struct ptlrpc_work_async_args *args; - ENTRY; might_sleep(); if (cb == NULL) - RETURN(ERR_PTR(-EINVAL)); + return ERR_PTR(-EINVAL); /* copy some code from deprecated fakereq. */ OBD_ALLOC_PTR(req); if (req == NULL) { CERROR("ptlrpc: run out of memory!\n"); - RETURN(ERR_PTR(-ENOMEM)); + return ERR_PTR(-ENOMEM); } req->rq_send_state = LUSTRE_IMP_FULL; @@ -3009,7 +2968,7 @@ void *ptlrpcd_alloc_work(struct obd_import *imp, args->cb = cb; args->cbdata = cbdata; - RETURN(req); + return req; } EXPORT_SYMBOL(ptlrpcd_alloc_work); diff --git a/drivers/staging/lustre/lustre/ptlrpc/connection.c b/drivers/staging/lustre/lustre/ptlrpc/connection.c index a0757f372be5..17ca84208873 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/connection.c +++ b/drivers/staging/lustre/lustre/ptlrpc/connection.c @@ -49,7 +49,6 @@ ptlrpc_connection_get(lnet_process_id_t peer, lnet_nid_t self, struct obd_uuid *uuid) { struct ptlrpc_connection *conn, *conn2; - ENTRY; conn = cfs_hash_lookup(conn_hash, &peer); if (conn) @@ -57,7 +56,7 @@ ptlrpc_connection_get(lnet_process_id_t peer, lnet_nid_t self, OBD_ALLOC_PTR(conn); if (!conn) - RETURN(NULL); + return NULL; conn->c_peer = peer; conn->c_self = self; @@ -80,7 +79,6 @@ ptlrpc_connection_get(lnet_process_id_t peer, lnet_nid_t self, OBD_FREE_PTR(conn); conn = conn2; } - EXIT; out: CDEBUG(D_INFO, "conn=%p refcount %d to %s\n", conn, atomic_read(&conn->c_refcount), @@ -92,10 +90,9 @@ EXPORT_SYMBOL(ptlrpc_connection_get); int ptlrpc_connection_put(struct ptlrpc_connection *conn) { int rc = 0; - ENTRY; if (!conn) - RETURN(rc); + return rc; LASSERT(atomic_read(&conn->c_refcount) > 1); @@ -122,28 +119,24 @@ int ptlrpc_connection_put(struct ptlrpc_connection *conn) conn, atomic_read(&conn->c_refcount), libcfs_nid2str(conn->c_peer.nid)); - RETURN(rc); + return rc; } EXPORT_SYMBOL(ptlrpc_connection_put); struct ptlrpc_connection * ptlrpc_connection_addref(struct ptlrpc_connection *conn) { - ENTRY; - atomic_inc(&conn->c_refcount); CDEBUG(D_INFO, "conn=%p refcount %d to %s\n", conn, atomic_read(&conn->c_refcount), libcfs_nid2str(conn->c_peer.nid)); - RETURN(conn); + return conn; } EXPORT_SYMBOL(ptlrpc_connection_addref); int ptlrpc_connection_init(void) { - ENTRY; - conn_hash = cfs_hash_create("CONN_HASH", HASH_CONN_CUR_BITS, HASH_CONN_MAX_BITS, @@ -152,16 +145,15 @@ int ptlrpc_connection_init(void) CFS_HASH_MAX_THETA, &conn_hash_ops, CFS_HASH_DEFAULT); if (!conn_hash) - RETURN(-ENOMEM); + return -ENOMEM; - RETURN(0); + return 0; } EXPORT_SYMBOL(ptlrpc_connection_init); -void ptlrpc_connection_fini(void) { - ENTRY; +void ptlrpc_connection_fini(void) +{ cfs_hash_putref(conn_hash); - EXIT; } EXPORT_SYMBOL(ptlrpc_connection_fini); diff --git a/drivers/staging/lustre/lustre/ptlrpc/errno.c b/drivers/staging/lustre/lustre/ptlrpc/errno.c new file mode 100644 index 000000000000..1c1006333960 --- /dev/null +++ b/drivers/staging/lustre/lustre/ptlrpc/errno.c @@ -0,0 +1,380 @@ +/* + * GPL HEADER START + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU General Public License + * version 2 along with this program; If not, see + * http://www.gnu.org/licenses/gpl-2.0.txt + * + * GPL HEADER END + */ +/* + * Copyright (C) 2011 FUJITSU LIMITED. All rights reserved. + * + * Copyright (c) 2013, Intel Corporation. + */ + +#include <linux/libcfs/libcfs.h> +#include <lustre/lustre_errno.h> + +/* + * The two translation tables below must define a one-to-one mapping between + * host and network errnos. + * + * EWOULDBLOCK is equal to EAGAIN on all architectures except for parisc, which + * appears irrelevant. Thus, existing references to EWOULDBLOCK are fine. + * + * EDEADLOCK is equal to EDEADLK on x86 but not on sparc, at least. A sparc + * host has no context-free way to determine if a LUSTRE_EDEADLK represents an + * EDEADLK or an EDEADLOCK. Therefore, all existing references to EDEADLOCK + * that need to be transferred on wire have been replaced with EDEADLK. + */ +static int lustre_errno_hton_mapping[] = { + [EPERM] = LUSTRE_EPERM, + [ENOENT] = LUSTRE_ENOENT, + [ESRCH] = LUSTRE_ESRCH, + [EINTR] = LUSTRE_EINTR, + [EIO] = LUSTRE_EIO, + [ENXIO] = LUSTRE_ENXIO, + [E2BIG] = LUSTRE_E2BIG, + [ENOEXEC] = LUSTRE_ENOEXEC, + [EBADF] = LUSTRE_EBADF, + [ECHILD] = LUSTRE_ECHILD, + [EAGAIN] = LUSTRE_EAGAIN, + [ENOMEM] = LUSTRE_ENOMEM, + [EACCES] = LUSTRE_EACCES, + [EFAULT] = LUSTRE_EFAULT, + [ENOTBLK] = LUSTRE_ENOTBLK, + [EBUSY] = LUSTRE_EBUSY, + [EEXIST] = LUSTRE_EEXIST, + [EXDEV] = LUSTRE_EXDEV, + [ENODEV] = LUSTRE_ENODEV, + [ENOTDIR] = LUSTRE_ENOTDIR, + [EISDIR] = LUSTRE_EISDIR, + [EINVAL] = LUSTRE_EINVAL, + [ENFILE] = LUSTRE_ENFILE, + [EMFILE] = LUSTRE_EMFILE, + [ENOTTY] = LUSTRE_ENOTTY, + [ETXTBSY] = LUSTRE_ETXTBSY, + [EFBIG] = LUSTRE_EFBIG, + [ENOSPC] = LUSTRE_ENOSPC, + [ESPIPE] = LUSTRE_ESPIPE, + [EROFS] = LUSTRE_EROFS, + [EMLINK] = LUSTRE_EMLINK, + [EPIPE] = LUSTRE_EPIPE, + [EDOM] = LUSTRE_EDOM, + [ERANGE] = LUSTRE_ERANGE, + [EDEADLK] = LUSTRE_EDEADLK, + [ENAMETOOLONG] = LUSTRE_ENAMETOOLONG, + [ENOLCK] = LUSTRE_ENOLCK, + [ENOSYS] = LUSTRE_ENOSYS, + [ENOTEMPTY] = LUSTRE_ENOTEMPTY, + [ELOOP] = LUSTRE_ELOOP, + [ENOMSG] = LUSTRE_ENOMSG, + [EIDRM] = LUSTRE_EIDRM, + [ECHRNG] = LUSTRE_ECHRNG, + [EL2NSYNC] = LUSTRE_EL2NSYNC, + [EL3HLT] = LUSTRE_EL3HLT, + [EL3RST] = LUSTRE_EL3RST, + [ELNRNG] = LUSTRE_ELNRNG, + [EUNATCH] = LUSTRE_EUNATCH, + [ENOCSI] = LUSTRE_ENOCSI, + [EL2HLT] = LUSTRE_EL2HLT, + [EBADE] = LUSTRE_EBADE, + [EBADR] = LUSTRE_EBADR, + [EXFULL] = LUSTRE_EXFULL, + [ENOANO] = LUSTRE_ENOANO, + [EBADRQC] = LUSTRE_EBADRQC, + [EBADSLT] = LUSTRE_EBADSLT, + [EBFONT] = LUSTRE_EBFONT, + [ENOSTR] = LUSTRE_ENOSTR, + [ENODATA] = LUSTRE_ENODATA, + [ETIME] = LUSTRE_ETIME, + [ENOSR] = LUSTRE_ENOSR, + [ENONET] = LUSTRE_ENONET, + [ENOPKG] = LUSTRE_ENOPKG, + [EREMOTE] = LUSTRE_EREMOTE, + [ENOLINK] = LUSTRE_ENOLINK, + [EADV] = LUSTRE_EADV, + [ESRMNT] = LUSTRE_ESRMNT, + [ECOMM] = LUSTRE_ECOMM, + [EPROTO] = LUSTRE_EPROTO, + [EMULTIHOP] = LUSTRE_EMULTIHOP, + [EDOTDOT] = LUSTRE_EDOTDOT, + [EBADMSG] = LUSTRE_EBADMSG, + [EOVERFLOW] = LUSTRE_EOVERFLOW, + [ENOTUNIQ] = LUSTRE_ENOTUNIQ, + [EBADFD] = LUSTRE_EBADFD, + [EREMCHG] = LUSTRE_EREMCHG, + [ELIBACC] = LUSTRE_ELIBACC, + [ELIBBAD] = LUSTRE_ELIBBAD, + [ELIBSCN] = LUSTRE_ELIBSCN, + [ELIBMAX] = LUSTRE_ELIBMAX, + [ELIBEXEC] = LUSTRE_ELIBEXEC, + [EILSEQ] = LUSTRE_EILSEQ, + [ERESTART] = LUSTRE_ERESTART, + [ESTRPIPE] = LUSTRE_ESTRPIPE, + [EUSERS] = LUSTRE_EUSERS, + [ENOTSOCK] = LUSTRE_ENOTSOCK, + [EDESTADDRREQ] = LUSTRE_EDESTADDRREQ, + [EMSGSIZE] = LUSTRE_EMSGSIZE, + [EPROTOTYPE] = LUSTRE_EPROTOTYPE, + [ENOPROTOOPT] = LUSTRE_ENOPROTOOPT, + [EPROTONOSUPPORT] = LUSTRE_EPROTONOSUPPORT, + [ESOCKTNOSUPPORT] = LUSTRE_ESOCKTNOSUPPORT, + [EOPNOTSUPP] = LUSTRE_EOPNOTSUPP, + [EPFNOSUPPORT] = LUSTRE_EPFNOSUPPORT, + [EAFNOSUPPORT] = LUSTRE_EAFNOSUPPORT, + [EADDRINUSE] = LUSTRE_EADDRINUSE, + [EADDRNOTAVAIL] = LUSTRE_EADDRNOTAVAIL, + [ENETDOWN] = LUSTRE_ENETDOWN, + [ENETUNREACH] = LUSTRE_ENETUNREACH, + [ENETRESET] = LUSTRE_ENETRESET, + [ECONNABORTED] = LUSTRE_ECONNABORTED, + [ECONNRESET] = LUSTRE_ECONNRESET, + [ENOBUFS] = LUSTRE_ENOBUFS, + [EISCONN] = LUSTRE_EISCONN, + [ENOTCONN] = LUSTRE_ENOTCONN, + [ESHUTDOWN] = LUSTRE_ESHUTDOWN, + [ETOOMANYREFS] = LUSTRE_ETOOMANYREFS, + [ETIMEDOUT] = LUSTRE_ETIMEDOUT, + [ECONNREFUSED] = LUSTRE_ECONNREFUSED, + [EHOSTDOWN] = LUSTRE_EHOSTDOWN, + [EHOSTUNREACH] = LUSTRE_EHOSTUNREACH, + [EALREADY] = LUSTRE_EALREADY, + [EINPROGRESS] = LUSTRE_EINPROGRESS, + [ESTALE] = LUSTRE_ESTALE, + [EUCLEAN] = LUSTRE_EUCLEAN, + [ENOTNAM] = LUSTRE_ENOTNAM, + [ENAVAIL] = LUSTRE_ENAVAIL, + [EISNAM] = LUSTRE_EISNAM, + [EREMOTEIO] = LUSTRE_EREMOTEIO, + [EDQUOT] = LUSTRE_EDQUOT, + [ENOMEDIUM] = LUSTRE_ENOMEDIUM, + [EMEDIUMTYPE] = LUSTRE_EMEDIUMTYPE, + [ECANCELED] = LUSTRE_ECANCELED, + [ENOKEY] = LUSTRE_ENOKEY, + [EKEYEXPIRED] = LUSTRE_EKEYEXPIRED, + [EKEYREVOKED] = LUSTRE_EKEYREVOKED, + [EKEYREJECTED] = LUSTRE_EKEYREJECTED, + [EOWNERDEAD] = LUSTRE_EOWNERDEAD, + [ENOTRECOVERABLE] = LUSTRE_ENOTRECOVERABLE, + [ERESTARTSYS] = LUSTRE_ERESTARTSYS, + [ERESTARTNOINTR] = LUSTRE_ERESTARTNOINTR, + [ERESTARTNOHAND] = LUSTRE_ERESTARTNOHAND, + [ENOIOCTLCMD] = LUSTRE_ENOIOCTLCMD, + [ERESTART_RESTARTBLOCK] = LUSTRE_ERESTART_RESTARTBLOCK, + [EBADHANDLE] = LUSTRE_EBADHANDLE, + [ENOTSYNC] = LUSTRE_ENOTSYNC, + [EBADCOOKIE] = LUSTRE_EBADCOOKIE, + [ENOTSUPP] = LUSTRE_ENOTSUPP, + [ETOOSMALL] = LUSTRE_ETOOSMALL, + [ESERVERFAULT] = LUSTRE_ESERVERFAULT, + [EBADTYPE] = LUSTRE_EBADTYPE, + [EJUKEBOX] = LUSTRE_EJUKEBOX, + [EIOCBQUEUED] = LUSTRE_EIOCBQUEUED, +}; + +static int lustre_errno_ntoh_mapping[] = { + [LUSTRE_EPERM] = EPERM, + [LUSTRE_ENOENT] = ENOENT, + [LUSTRE_ESRCH] = ESRCH, + [LUSTRE_EINTR] = EINTR, + [LUSTRE_EIO] = EIO, + [LUSTRE_ENXIO] = ENXIO, + [LUSTRE_E2BIG] = E2BIG, + [LUSTRE_ENOEXEC] = ENOEXEC, + [LUSTRE_EBADF] = EBADF, + [LUSTRE_ECHILD] = ECHILD, + [LUSTRE_EAGAIN] = EAGAIN, + [LUSTRE_ENOMEM] = ENOMEM, + [LUSTRE_EACCES] = EACCES, + [LUSTRE_EFAULT] = EFAULT, + [LUSTRE_ENOTBLK] = ENOTBLK, + [LUSTRE_EBUSY] = EBUSY, + [LUSTRE_EEXIST] = EEXIST, + [LUSTRE_EXDEV] = EXDEV, + [LUSTRE_ENODEV] = ENODEV, + [LUSTRE_ENOTDIR] = ENOTDIR, + [LUSTRE_EISDIR] = EISDIR, + [LUSTRE_EINVAL] = EINVAL, + [LUSTRE_ENFILE] = ENFILE, + [LUSTRE_EMFILE] = EMFILE, + [LUSTRE_ENOTTY] = ENOTTY, + [LUSTRE_ETXTBSY] = ETXTBSY, + [LUSTRE_EFBIG] = EFBIG, + [LUSTRE_ENOSPC] = ENOSPC, + [LUSTRE_ESPIPE] = ESPIPE, + [LUSTRE_EROFS] = EROFS, + [LUSTRE_EMLINK] = EMLINK, + [LUSTRE_EPIPE] = EPIPE, + [LUSTRE_EDOM] = EDOM, + [LUSTRE_ERANGE] = ERANGE, + [LUSTRE_EDEADLK] = EDEADLK, + [LUSTRE_ENAMETOOLONG] = ENAMETOOLONG, + [LUSTRE_ENOLCK] = ENOLCK, + [LUSTRE_ENOSYS] = ENOSYS, + [LUSTRE_ENOTEMPTY] = ENOTEMPTY, + [LUSTRE_ELOOP] = ELOOP, + [LUSTRE_ENOMSG] = ENOMSG, + [LUSTRE_EIDRM] = EIDRM, + [LUSTRE_ECHRNG] = ECHRNG, + [LUSTRE_EL2NSYNC] = EL2NSYNC, + [LUSTRE_EL3HLT] = EL3HLT, + [LUSTRE_EL3RST] = EL3RST, + [LUSTRE_ELNRNG] = ELNRNG, + [LUSTRE_EUNATCH] = EUNATCH, + [LUSTRE_ENOCSI] = ENOCSI, + [LUSTRE_EL2HLT] = EL2HLT, + [LUSTRE_EBADE] = EBADE, + [LUSTRE_EBADR] = EBADR, + [LUSTRE_EXFULL] = EXFULL, + [LUSTRE_ENOANO] = ENOANO, + [LUSTRE_EBADRQC] = EBADRQC, + [LUSTRE_EBADSLT] = EBADSLT, + [LUSTRE_EBFONT] = EBFONT, + [LUSTRE_ENOSTR] = ENOSTR, + [LUSTRE_ENODATA] = ENODATA, + [LUSTRE_ETIME] = ETIME, + [LUSTRE_ENOSR] = ENOSR, + [LUSTRE_ENONET] = ENONET, + [LUSTRE_ENOPKG] = ENOPKG, + [LUSTRE_EREMOTE] = EREMOTE, + [LUSTRE_ENOLINK] = ENOLINK, + [LUSTRE_EADV] = EADV, + [LUSTRE_ESRMNT] = ESRMNT, + [LUSTRE_ECOMM] = ECOMM, + [LUSTRE_EPROTO] = EPROTO, + [LUSTRE_EMULTIHOP] = EMULTIHOP, + [LUSTRE_EDOTDOT] = EDOTDOT, + [LUSTRE_EBADMSG] = EBADMSG, + [LUSTRE_EOVERFLOW] = EOVERFLOW, + [LUSTRE_ENOTUNIQ] = ENOTUNIQ, + [LUSTRE_EBADFD] = EBADFD, + [LUSTRE_EREMCHG] = EREMCHG, + [LUSTRE_ELIBACC] = ELIBACC, + [LUSTRE_ELIBBAD] = ELIBBAD, + [LUSTRE_ELIBSCN] = ELIBSCN, + [LUSTRE_ELIBMAX] = ELIBMAX, + [LUSTRE_ELIBEXEC] = ELIBEXEC, + [LUSTRE_EILSEQ] = EILSEQ, + [LUSTRE_ERESTART] = ERESTART, + [LUSTRE_ESTRPIPE] = ESTRPIPE, + [LUSTRE_EUSERS] = EUSERS, + [LUSTRE_ENOTSOCK] = ENOTSOCK, + [LUSTRE_EDESTADDRREQ] = EDESTADDRREQ, + [LUSTRE_EMSGSIZE] = EMSGSIZE, + [LUSTRE_EPROTOTYPE] = EPROTOTYPE, + [LUSTRE_ENOPROTOOPT] = ENOPROTOOPT, + [LUSTRE_EPROTONOSUPPORT] = EPROTONOSUPPORT, + [LUSTRE_ESOCKTNOSUPPORT] = ESOCKTNOSUPPORT, + [LUSTRE_EOPNOTSUPP] = EOPNOTSUPP, + [LUSTRE_EPFNOSUPPORT] = EPFNOSUPPORT, + [LUSTRE_EAFNOSUPPORT] = EAFNOSUPPORT, + [LUSTRE_EADDRINUSE] = EADDRINUSE, + [LUSTRE_EADDRNOTAVAIL] = EADDRNOTAVAIL, + [LUSTRE_ENETDOWN] = ENETDOWN, + [LUSTRE_ENETUNREACH] = ENETUNREACH, + [LUSTRE_ENETRESET] = ENETRESET, + [LUSTRE_ECONNABORTED] = ECONNABORTED, + [LUSTRE_ECONNRESET] = ECONNRESET, + [LUSTRE_ENOBUFS] = ENOBUFS, + [LUSTRE_EISCONN] = EISCONN, + [LUSTRE_ENOTCONN] = ENOTCONN, + [LUSTRE_ESHUTDOWN] = ESHUTDOWN, + [LUSTRE_ETOOMANYREFS] = ETOOMANYREFS, + [LUSTRE_ETIMEDOUT] = ETIMEDOUT, + [LUSTRE_ECONNREFUSED] = ECONNREFUSED, + [LUSTRE_EHOSTDOWN] = EHOSTDOWN, + [LUSTRE_EHOSTUNREACH] = EHOSTUNREACH, + [LUSTRE_EALREADY] = EALREADY, + [LUSTRE_EINPROGRESS] = EINPROGRESS, + [LUSTRE_ESTALE] = ESTALE, + [LUSTRE_EUCLEAN] = EUCLEAN, + [LUSTRE_ENOTNAM] = ENOTNAM, + [LUSTRE_ENAVAIL] = ENAVAIL, + [LUSTRE_EISNAM] = EISNAM, + [LUSTRE_EREMOTEIO] = EREMOTEIO, + [LUSTRE_EDQUOT] = EDQUOT, + [LUSTRE_ENOMEDIUM] = ENOMEDIUM, + [LUSTRE_EMEDIUMTYPE] = EMEDIUMTYPE, + [LUSTRE_ECANCELED] = ECANCELED, + [LUSTRE_ENOKEY] = ENOKEY, + [LUSTRE_EKEYEXPIRED] = EKEYEXPIRED, + [LUSTRE_EKEYREVOKED] = EKEYREVOKED, + [LUSTRE_EKEYREJECTED] = EKEYREJECTED, + [LUSTRE_EOWNERDEAD] = EOWNERDEAD, + [LUSTRE_ENOTRECOVERABLE] = ENOTRECOVERABLE, + [LUSTRE_ERESTARTSYS] = ERESTARTSYS, + [LUSTRE_ERESTARTNOINTR] = ERESTARTNOINTR, + [LUSTRE_ERESTARTNOHAND] = ERESTARTNOHAND, + [LUSTRE_ENOIOCTLCMD] = ENOIOCTLCMD, + [LUSTRE_ERESTART_RESTARTBLOCK] = ERESTART_RESTARTBLOCK, + [LUSTRE_EBADHANDLE] = EBADHANDLE, + [LUSTRE_ENOTSYNC] = ENOTSYNC, + [LUSTRE_EBADCOOKIE] = EBADCOOKIE, + [LUSTRE_ENOTSUPP] = ENOTSUPP, + [LUSTRE_ETOOSMALL] = ETOOSMALL, + [LUSTRE_ESERVERFAULT] = ESERVERFAULT, + [LUSTRE_EBADTYPE] = EBADTYPE, + [LUSTRE_EJUKEBOX] = EJUKEBOX, + [LUSTRE_EIOCBQUEUED] = EIOCBQUEUED, +}; + +unsigned int lustre_errno_hton(unsigned int h) +{ + unsigned int n; + + if (h == 0) { + n = 0; + } else if (h < ARRAY_SIZE(lustre_errno_hton_mapping)) { + n = lustre_errno_hton_mapping[h]; + if (n == 0) + goto generic; + } else { +generic: + /* + * A generic errno is better than the unknown one that could + * mean anything to a different host. + */ + n = LUSTRE_EIO; + } + + return n; +} +EXPORT_SYMBOL(lustre_errno_hton); + +unsigned int lustre_errno_ntoh(unsigned int n) +{ + unsigned int h; + + if (n == 0) { + h = 0; + } else if (n < ARRAY_SIZE(lustre_errno_ntoh_mapping)) { + h = lustre_errno_ntoh_mapping[n]; + if (h == 0) + goto generic; + } else { +generic: + /* + * Similar to the situation in lustre_errno_hton(), an unknown + * network errno could coincide with anything. Hence, it is + * better to return a generic errno. + */ + h = EIO; + } + + return h; +} +EXPORT_SYMBOL(lustre_errno_ntoh); diff --git a/drivers/staging/lustre/lustre/ptlrpc/events.c b/drivers/staging/lustre/lustre/ptlrpc/events.c index 0264c102cb3e..58d089c3fef4 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/events.c +++ b/drivers/staging/lustre/lustre/ptlrpc/events.c @@ -55,7 +55,6 @@ void request_out_callback(lnet_event_t *ev) { struct ptlrpc_cb_id *cbid = ev->md.user_ptr; struct ptlrpc_request *req = cbid->cbid_arg; - ENTRY; LASSERT (ev->type == LNET_EVENT_SEND || ev->type == LNET_EVENT_UNLINK); @@ -79,8 +78,6 @@ void request_out_callback(lnet_event_t *ev) } ptlrpc_req_finished(req); - - EXIT; } /* @@ -90,7 +87,6 @@ void reply_in_callback(lnet_event_t *ev) { struct ptlrpc_cb_id *cbid = ev->md.user_ptr; struct ptlrpc_request *req = cbid->cbid_arg; - ENTRY; DEBUG_REQ(D_NET, req, "type %d, status %d", ev->type, ev->status); @@ -166,7 +162,6 @@ out_wake: * since we don't have our own ref */ ptlrpc_client_wake_req(req); spin_unlock(&req->rq_lock); - EXIT; } /* @@ -177,7 +172,6 @@ void client_bulk_callback (lnet_event_t *ev) struct ptlrpc_cb_id *cbid = ev->md.user_ptr; struct ptlrpc_bulk_desc *desc = cbid->cbid_arg; struct ptlrpc_request *req; - ENTRY; LASSERT ((desc->bd_type == BULK_PUT_SINK && ev->type == LNET_EVENT_PUT) || @@ -220,7 +214,6 @@ void client_bulk_callback (lnet_event_t *ev) ptlrpc_client_wake_req(desc->bd_req); spin_unlock(&desc->bd_lock); - EXIT; } /* @@ -289,7 +282,6 @@ void request_in_callback(lnet_event_t *ev) struct ptlrpc_service_part *svcpt = rqbd->rqbd_svcpt; struct ptlrpc_service *service = svcpt->scp_service; struct ptlrpc_request *req; - ENTRY; LASSERT (ev->type == LNET_EVENT_PUT || ev->type == LNET_EVENT_UNLINK); @@ -378,7 +370,6 @@ void request_in_callback(lnet_event_t *ev) wake_up(&svcpt->scp_waitq); spin_unlock(&svcpt->scp_lock); - EXIT; } /* @@ -389,7 +380,6 @@ void reply_out_callback(lnet_event_t *ev) struct ptlrpc_cb_id *cbid = ev->md.user_ptr; struct ptlrpc_reply_state *rs = cbid->cbid_arg; struct ptlrpc_service_part *svcpt = rs->rs_svcpt; - ENTRY; LASSERT (ev->type == LNET_EVENT_SEND || ev->type == LNET_EVENT_ACK || @@ -400,7 +390,6 @@ void reply_out_callback(lnet_event_t *ev) * net's ref on 'rs' */ LASSERT (ev->unlinked); ptlrpc_rs_decref(rs); - EXIT; return; } @@ -421,7 +410,6 @@ void reply_out_callback(lnet_event_t *ev) spin_unlock(&rs->rs_lock); spin_unlock(&svcpt->scp_rep_lock); } - EXIT; } diff --git a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_api.h b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_api.h index feac60482c97..0e9f6c472a37 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_api.h +++ b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_api.h @@ -100,7 +100,7 @@ struct subflavor_desc { /* Each mechanism is described by the following struct: */ struct gss_api_mech { struct list_head gm_list; - module_t *gm_owner; + struct module *gm_owner; char *gm_name; rawobj_t gm_oid; atomic_t gm_count; diff --git a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_bulk.c b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_bulk.c index ed95bbba95ca..b518d8a0aaba 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_bulk.c +++ b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_bulk.c @@ -68,7 +68,6 @@ int gss_cli_ctx_wrap_bulk(struct ptlrpc_cli_ctx *ctx, __u32 maj; int offset; int rc; - ENTRY; LASSERT(req->rq_pack_bulk); LASSERT(req->rq_bulk_read || req->rq_bulk_write); @@ -104,7 +103,7 @@ int gss_cli_ctx_wrap_bulk(struct ptlrpc_cli_ctx *ctx, bsd->bsd_svc = SPTLRPC_FLVR_BULK_SVC(req->rq_flvr.sf_rpc); if (bsd->bsd_svc == SPTLRPC_BULK_SVC_NULL) - RETURN(0); + return 0; LASSERT(bsd->bsd_svc == SPTLRPC_BULK_SVC_INTG || bsd->bsd_svc == SPTLRPC_BULK_SVC_PRIV); @@ -132,18 +131,18 @@ int gss_cli_ctx_wrap_bulk(struct ptlrpc_cli_ctx *ctx, &token); if (maj != GSS_S_COMPLETE) { CWARN("failed to sign bulk data: %x\n", maj); - RETURN(-EACCES); + return -EACCES; } } else { /* privacy mode */ if (desc->bd_iov_count == 0) - RETURN(0); + return 0; rc = sptlrpc_enc_pool_get_pages(desc); if (rc) { CERROR("bulk write: failed to allocate " "encryption pages: %d\n", rc); - RETURN(rc); + return rc; } token.data = bsd->bsd_data; @@ -153,12 +152,12 @@ int gss_cli_ctx_wrap_bulk(struct ptlrpc_cli_ctx *ctx, maj = lgss_wrap_bulk(gctx->gc_mechctx, desc, &token, 0); if (maj != GSS_S_COMPLETE) { CWARN("fail to encrypt bulk data: %x\n", maj); - RETURN(-EACCES); + return -EACCES; } } } - RETURN(0); + return 0; } int gss_cli_ctx_unwrap_bulk(struct ptlrpc_cli_ctx *ctx, @@ -171,7 +170,6 @@ int gss_cli_ctx_unwrap_bulk(struct ptlrpc_cli_ctx *ctx, rawobj_t token; __u32 maj; int roff, voff; - ENTRY; LASSERT(req->rq_pack_bulk); LASSERT(req->rq_bulk_read || req->rq_bulk_write); @@ -220,7 +218,7 @@ int gss_cli_ctx_unwrap_bulk(struct ptlrpc_cli_ctx *ctx, "(%u,%u,%u) != (%u,%u,%u)\n", bsdr->bsd_version, bsdr->bsd_type, bsdr->bsd_svc, bsdv->bsd_version, bsdv->bsd_type, bsdv->bsd_svc); - RETURN(-EPROTO); + return -EPROTO; } LASSERT(bsdv->bsd_svc == SPTLRPC_BULK_SVC_NULL || @@ -235,7 +233,7 @@ int gss_cli_ctx_unwrap_bulk(struct ptlrpc_cli_ctx *ctx, if (req->rq_bulk_write) { if (bsdv->bsd_flags & BSD_FL_ERR) { CERROR("server reported bulk i/o failure\n"); - RETURN(-EIO); + return -EIO; } if (bsdv->bsd_svc == SPTLRPC_BULK_SVC_PRIV) @@ -270,12 +268,12 @@ int gss_cli_ctx_unwrap_bulk(struct ptlrpc_cli_ctx *ctx, &token); if (maj != GSS_S_COMPLETE) { CERROR("failed to verify bulk read: %x\n", maj); - RETURN(-EACCES); + return -EACCES; } } else if (bsdv->bsd_svc == SPTLRPC_BULK_SVC_PRIV) { desc->bd_nob = bsdv->bsd_nob; if (desc->bd_nob == 0) - RETURN(0); + return 0; token.data = bsdv->bsd_data; token.len = lustre_msg_buflen(vmsg, voff) - @@ -286,14 +284,14 @@ int gss_cli_ctx_unwrap_bulk(struct ptlrpc_cli_ctx *ctx, if (maj != GSS_S_COMPLETE) { CERROR("failed to decrypt bulk read: %x\n", maj); - RETURN(-EACCES); + return -EACCES; } desc->bd_nob_transferred = desc->bd_nob; } } - RETURN(0); + return 0; } static int gss_prep_bulk(struct ptlrpc_bulk_desc *desc, @@ -318,21 +316,20 @@ int gss_cli_prep_bulk(struct ptlrpc_request *req, struct ptlrpc_bulk_desc *desc) { int rc; - ENTRY; LASSERT(req->rq_cli_ctx); LASSERT(req->rq_pack_bulk); LASSERT(req->rq_bulk_read); if (SPTLRPC_FLVR_BULK_SVC(req->rq_flvr.sf_rpc) != SPTLRPC_BULK_SVC_PRIV) - RETURN(0); + return 0; rc = gss_prep_bulk(desc, ctx2gctx(req->rq_cli_ctx)->gc_mechctx); if (rc) CERROR("bulk read: failed to prepare encryption " "pages: %d\n", rc); - RETURN(rc); + return rc; } int gss_svc_prep_bulk(struct ptlrpc_request *req, @@ -341,7 +338,6 @@ int gss_svc_prep_bulk(struct ptlrpc_request *req, struct gss_svc_reqctx *grctx; struct ptlrpc_bulk_sec_desc *bsd; int rc; - ENTRY; LASSERT(req->rq_svc_ctx); LASSERT(req->rq_pack_bulk); @@ -355,14 +351,14 @@ int gss_svc_prep_bulk(struct ptlrpc_request *req, bsd = grctx->src_reqbsd; if (bsd->bsd_svc != SPTLRPC_BULK_SVC_PRIV) - RETURN(0); + return 0; rc = gss_prep_bulk(desc, grctx->src_ctx->gsc_mechctx); if (rc) CERROR("bulk write: failed to prepare encryption " "pages: %d\n", rc); - RETURN(rc); + return rc; } int gss_svc_unwrap_bulk(struct ptlrpc_request *req, @@ -372,7 +368,6 @@ int gss_svc_unwrap_bulk(struct ptlrpc_request *req, struct ptlrpc_bulk_sec_desc *bsdr, *bsdv; rawobj_t token; __u32 maj; - ENTRY; LASSERT(req->rq_svc_ctx); LASSERT(req->rq_pack_bulk); @@ -404,7 +399,7 @@ int gss_svc_unwrap_bulk(struct ptlrpc_request *req, if (maj != GSS_S_COMPLETE) { bsdv->bsd_flags |= BSD_FL_ERR; CERROR("failed to verify bulk signature: %x\n", maj); - RETURN(-EACCES); + return -EACCES; } break; case SPTLRPC_BULK_SVC_PRIV: @@ -412,7 +407,7 @@ int gss_svc_unwrap_bulk(struct ptlrpc_request *req, bsdv->bsd_flags |= BSD_FL_ERR; CERROR("prepared nob %d doesn't match the actual " "nob %d\n", desc->bd_nob, bsdr->bsd_nob); - RETURN(-EPROTO); + return -EPROTO; } if (desc->bd_iov_count == 0) { @@ -428,12 +423,12 @@ int gss_svc_unwrap_bulk(struct ptlrpc_request *req, if (maj != GSS_S_COMPLETE) { bsdv->bsd_flags |= BSD_FL_ERR; CERROR("failed decrypt bulk data: %x\n", maj); - RETURN(-EACCES); + return -EACCES; } break; } - RETURN(0); + return 0; } int gss_svc_wrap_bulk(struct ptlrpc_request *req, @@ -444,7 +439,6 @@ int gss_svc_wrap_bulk(struct ptlrpc_request *req, rawobj_t token; __u32 maj; int rc; - ENTRY; LASSERT(req->rq_svc_ctx); LASSERT(req->rq_pack_bulk); @@ -476,7 +470,7 @@ int gss_svc_wrap_bulk(struct ptlrpc_request *req, if (maj != GSS_S_COMPLETE) { bsdv->bsd_flags |= BSD_FL_ERR; CERROR("failed to sign bulk data: %x\n", maj); - RETURN(-EACCES); + return -EACCES; } break; case SPTLRPC_BULK_SVC_PRIV: @@ -492,7 +486,7 @@ int gss_svc_wrap_bulk(struct ptlrpc_request *req, bsdv->bsd_flags |= BSD_FL_ERR; CERROR("bulk read: failed to allocate encryption " "pages: %d\n", rc); - RETURN(rc); + return rc; } token.data = bsdv->bsd_data; @@ -503,10 +497,10 @@ int gss_svc_wrap_bulk(struct ptlrpc_request *req, if (maj != GSS_S_COMPLETE) { bsdv->bsd_flags |= BSD_FL_ERR; CERROR("failed to encrypt bulk data: %x\n", maj); - RETURN(-EACCES); + return -EACCES; } break; } - RETURN(0); + return 0; } diff --git a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_cli_upcall.c b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_cli_upcall.c index 142c789b1bc6..55247af3910e 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_cli_upcall.c +++ b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_cli_upcall.c @@ -243,41 +243,41 @@ int gss_do_ctx_init_rpc(__user char *buffer, unsigned long count) if (count != sizeof(param)) { CERROR("ioctl size %lu, expect %lu, please check lgss_keyring " "version\n", count, (unsigned long) sizeof(param)); - RETURN(-EINVAL); + return -EINVAL; } if (copy_from_user(¶m, buffer, sizeof(param))) { CERROR("failed copy data from lgssd\n"); - RETURN(-EFAULT); + return -EFAULT; } if (param.version != GSSD_INTERFACE_VERSION) { CERROR("gssd interface version %d (expect %d)\n", param.version, GSSD_INTERFACE_VERSION); - RETURN(-EINVAL); + return -EINVAL; } /* take name */ if (strncpy_from_user(obdname, param.uuid, sizeof(obdname)) <= 0) { CERROR("Invalid obdname pointer\n"); - RETURN(-EFAULT); + return -EFAULT; } obd = class_name2obd(obdname); if (!obd) { CERROR("no such obd %s\n", obdname); - RETURN(-EINVAL); + return -EINVAL; } if (unlikely(!obd->obd_set_up)) { CERROR("obd %s not setup\n", obdname); - RETURN(-EINVAL); + return -EINVAL; } spin_lock(&obd->obd_dev_lock); if (obd->obd_stopping) { CERROR("obd %s has stopped\n", obdname); spin_unlock(&obd->obd_dev_lock); - RETURN(-EINVAL); + return -EINVAL; } if (strcmp(obd->obd_type->typ_name, LUSTRE_MDC_NAME) && @@ -285,7 +285,7 @@ int gss_do_ctx_init_rpc(__user char *buffer, unsigned long count) strcmp(obd->obd_type->typ_name, LUSTRE_MGC_NAME)) { CERROR("obd %s is not a client device\n", obdname); spin_unlock(&obd->obd_dev_lock); - RETURN(-EINVAL); + return -EINVAL; } spin_unlock(&obd->obd_dev_lock); @@ -293,7 +293,7 @@ int gss_do_ctx_init_rpc(__user char *buffer, unsigned long count) if (obd->u.cli.cl_import == NULL) { CERROR("obd %s: import has gone\n", obd->obd_name); up_read(&obd->u.cli.cl_sem); - RETURN(-EINVAL); + return -EINVAL; } imp = class_import_get(obd->u.cli.cl_import); up_read(&obd->u.cli.cl_sem); @@ -301,7 +301,7 @@ int gss_do_ctx_init_rpc(__user char *buffer, unsigned long count) if (imp->imp_deactive) { CERROR("import has been deactivated\n"); class_import_put(imp); - RETURN(-EINVAL); + return -EINVAL; } req = ptlrpc_request_alloc_pack(imp, &RQF_SEC_CTX, LUSTRE_OBD_VERSION, @@ -368,7 +368,7 @@ out_copy: class_import_put(imp); ptlrpc_req_finished(req); - RETURN(rc); + return rc; } int gss_do_ctx_fini_rpc(struct gss_cli_ctx *gctx) @@ -378,7 +378,6 @@ int gss_do_ctx_fini_rpc(struct gss_cli_ctx *gctx) struct ptlrpc_request *req; struct ptlrpc_user_desc *pud; int rc; - ENTRY; LASSERT(atomic_read(&ctx->cc_refcount) > 0); @@ -386,7 +385,7 @@ int gss_do_ctx_fini_rpc(struct gss_cli_ctx *gctx) CDEBUG(D_SEC, "ctx %p(%u->%s) not uptodate, " "don't send destroy rpc\n", ctx, ctx->cc_vcred.vc_uid, sec2target_str(ctx->cc_sec)); - RETURN(0); + return 0; } might_sleep(); @@ -434,7 +433,7 @@ int gss_do_ctx_fini_rpc(struct gss_cli_ctx *gctx) out_ref: ptlrpc_req_finished(req); out: - RETURN(rc); + return rc; } int __init gss_init_cli_upcall(void) diff --git a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_keyring.c b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_keyring.c index bb571ae51054..188dbbfbd2f4 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_keyring.c +++ b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_keyring.c @@ -524,7 +524,6 @@ void rvs_sec_install_root_ctx_kr(struct ptlrpc_sec *sec, struct gss_sec_keyring *gsec_kr = sec2gsec_keyring(sec); struct ptlrpc_cli_ctx *ctx; cfs_time_t now; - ENTRY; LASSERT(sec_is_reverse(sec)); @@ -569,11 +568,10 @@ struct ptlrpc_sec * gss_sec_create_kr(struct obd_import *imp, struct sptlrpc_flavor *sf) { struct gss_sec_keyring *gsec_kr; - ENTRY; OBD_ALLOC(gsec_kr, sizeof(*gsec_kr)); if (gsec_kr == NULL) - RETURN(NULL); + return NULL; INIT_HLIST_HEAD(&gsec_kr->gsk_clist); gsec_kr->gsk_root_ctx = NULL; @@ -592,11 +590,11 @@ struct ptlrpc_sec * gss_sec_create_kr(struct obd_import *imp, goto err_free; } - RETURN(&gsec_kr->gsk_base.gs_base); + return &gsec_kr->gsk_base.gs_base; err_free: OBD_FREE(gsec_kr, sizeof(*gsec_kr)); - RETURN(NULL); + return NULL; } static @@ -683,7 +681,6 @@ struct ptlrpc_cli_ctx * gss_sec_lookup_ctx_kr(struct ptlrpc_sec *sec, char *coinfo; int coinfo_size; char *co_flags = ""; - ENTRY; LASSERT(imp != NULL); @@ -697,7 +694,7 @@ struct ptlrpc_cli_ctx * gss_sec_lookup_ctx_kr(struct ptlrpc_sec *sec, * always succeed. */ if (ctx || sec_is_reverse(sec)) - RETURN(ctx); + return ctx; } LASSERT(create != 0); @@ -821,7 +818,7 @@ struct ptlrpc_cli_ctx * gss_sec_lookup_ctx_kr(struct ptlrpc_sec *sec, out: if (is_root) mutex_unlock(&gsec_kr->gsk_root_uc_lock); - RETURN(ctx); + return ctx; } static @@ -891,7 +888,6 @@ void flush_spec_ctx_cache_kr(struct ptlrpc_sec *sec, struct hlist_head freelist = HLIST_HEAD_INIT; struct hlist_node *next; struct ptlrpc_cli_ctx *ctx; - ENTRY; gsec_kr = sec2gsec_keyring(sec); @@ -930,15 +926,12 @@ void flush_spec_ctx_cache_kr(struct ptlrpc_sec *sec, spin_unlock(&sec->ps_lock); dispose_ctx_list_kr(&freelist); - EXIT; } static int gss_sec_flush_ctx_cache_kr(struct ptlrpc_sec *sec, uid_t uid, int grace, int force) { - ENTRY; - CDEBUG(D_SEC, "sec %p(%d, nctx %d), uid %d, grace %d, force %d\n", sec, atomic_read(&sec->ps_refcount), atomic_read(&sec->ps_nctx), @@ -949,7 +942,7 @@ int gss_sec_flush_ctx_cache_kr(struct ptlrpc_sec *sec, else flush_spec_ctx_cache_kr(sec, uid, grace, force); - RETURN(0); + return 0; } static @@ -959,7 +952,6 @@ void gss_sec_gc_ctx_kr(struct ptlrpc_sec *sec) struct hlist_head freelist = HLIST_HEAD_INIT; struct hlist_node *next; struct ptlrpc_cli_ctx *ctx; - ENTRY; CWARN("running gc\n"); @@ -981,8 +973,6 @@ void gss_sec_gc_ctx_kr(struct ptlrpc_sec *sec) spin_unlock(&sec->ps_lock); dispose_ctx_list_kr(&freelist); - EXIT; - return; } static @@ -993,7 +983,6 @@ int gss_sec_display_kr(struct ptlrpc_sec *sec, struct seq_file *seq) struct ptlrpc_cli_ctx *ctx; struct gss_cli_ctx *gctx; time_t now = cfs_time_current_sec(); - ENTRY; spin_lock(&sec->ps_lock); hlist_for_each_entry_safe(ctx, next, @@ -1032,7 +1021,7 @@ int gss_sec_display_kr(struct ptlrpc_sec *sec, struct seq_file *seq) } spin_unlock(&sec->ps_lock); - RETURN(0); + return 0; } /**************************************** @@ -1148,16 +1137,15 @@ static int gss_kt_instantiate(struct key *key, const void *data, size_t datalen) { int rc; - ENTRY; if (data != NULL || datalen != 0) { CERROR("invalid: data %p, len %lu\n", data, (long)datalen); - RETURN(-EINVAL); + return -EINVAL; } if (key->payload.data != 0) { CERROR("key already have payload\n"); - RETURN(-EINVAL); + return -EINVAL; } /* link the key to session keyring, so following context negotiation @@ -1179,11 +1167,11 @@ int gss_kt_instantiate(struct key *key, const void *data, size_t datalen) CERROR("failed to link key %08x to keyring %08x: %d\n", key->serial, key_tgcred(current)->session_keyring->serial, rc); - RETURN(rc); + return rc; } CDEBUG(D_SEC, "key %p instantiated, ctx %p\n", key, key->payload.data); - RETURN(0); + return 0; } /* @@ -1198,11 +1186,10 @@ int gss_kt_update(struct key *key, const void *data, size_t datalen) rawobj_t tmpobj = RAWOBJ_EMPTY; __u32 datalen32 = (__u32) datalen; int rc; - ENTRY; if (data == NULL || datalen == 0) { CWARN("invalid: data %p, len %lu\n", data, (long)datalen); - RETURN(-EINVAL); + return -EINVAL; } /* if upcall finished negotiation too fast (mostly likely because @@ -1216,9 +1203,9 @@ int gss_kt_update(struct key *key, const void *data, size_t datalen) rc = key_validate(key); if (rc == 0) - RETURN(-EAGAIN); + return -EAGAIN; else - RETURN(rc); + return rc; } LASSERT(atomic_read(&ctx->cc_refcount) > 0); @@ -1229,7 +1216,7 @@ int gss_kt_update(struct key *key, const void *data, size_t datalen) /* don't proceed if already refreshed */ if (cli_ctx_is_refreshed(ctx)) { CWARN("ctx already done refresh\n"); - RETURN(0); + return 0; } sptlrpc_cli_ctx_get(ctx); @@ -1304,7 +1291,7 @@ out: /* let user space think it's a success */ sptlrpc_cli_ctx_put(ctx, 1); - RETURN(0); + return 0; } static @@ -1316,10 +1303,8 @@ int gss_kt_match(const struct key *key, const void *desc) static void gss_kt_destroy(struct key *key) { - ENTRY; LASSERT(key->payload.data == NULL); CDEBUG(D_SEC, "destroy key %p\n", key); - EXIT; } static diff --git a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_krb5_mech.c b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_krb5_mech.c index 4b28931bbc96..c106a9e049a7 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_krb5_mech.c +++ b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_krb5_mech.c @@ -54,6 +54,7 @@ #include <linux/slab.h> #include <linux/crypto.h> #include <linux/mutex.h> +#include <linux/crypto.h> #include <obd.h> #include <obd_class.h> @@ -147,14 +148,14 @@ static const char * enctype2str(__u32 enctype) static int keyblock_init(struct krb5_keyblock *kb, char *alg_name, int alg_mode) { - kb->kb_tfm = ll_crypto_alloc_blkcipher(alg_name, alg_mode, 0); + kb->kb_tfm = crypto_alloc_blkcipher(alg_name, alg_mode, 0); if (IS_ERR(kb->kb_tfm)) { CERROR("failed to alloc tfm: %s, mode %d\n", alg_name, alg_mode); return -1; } - if (ll_crypto_blkcipher_setkey(kb->kb_tfm, kb->kb_key.data, kb->kb_key.len)) { + if (crypto_blkcipher_setkey(kb->kb_tfm, kb->kb_key.data, kb->kb_key.len)) { CERROR("failed to set %s key, len %d\n", alg_name, kb->kb_key.len); return -1; @@ -197,7 +198,7 @@ void keyblock_free(struct krb5_keyblock *kb) { rawobj_free(&kb->kb_key); if (kb->kb_tfm) - ll_crypto_free_blkcipher(kb->kb_tfm); + crypto_free_blkcipher(kb->kb_tfm); } static @@ -341,7 +342,7 @@ __u32 import_context_rfc1964(struct krb5_ctx *kctx, char *p, char *end) if (p != end) goto out_err; - CDEBUG(D_SEC, "succesfully imported rfc1964 context\n"); + CDEBUG(D_SEC, "successfully imported rfc1964 context\n"); return 0; out_err: return GSS_S_FAILURE; @@ -403,7 +404,7 @@ __u32 import_context_rfc4121(struct krb5_ctx *kctx, char *p, char *end) if (get_keyblock(&p, end, &kctx->kc_keyc, keysize)) goto out_err; - CDEBUG(D_SEC, "succesfully imported v2 context\n"); + CDEBUG(D_SEC, "successfully imported v2 context\n"); return 0; out_err: return GSS_S_FAILURE; @@ -494,7 +495,7 @@ __u32 gss_copy_reverse_context_kerberos(struct gss_ctx *gctx, goto out_err; gctx_new->internal_ctx_id = knew; - CDEBUG(D_SEC, "succesfully copied reverse context\n"); + CDEBUG(D_SEC, "successfully copied reverse context\n"); return GSS_S_COMPLETE; out_err: @@ -529,7 +530,7 @@ void buf_to_sg(struct scatterlist *sg, void *ptr, int len) } static -__u32 krb5_encrypt(struct ll_crypto_cipher *tfm, +__u32 krb5_encrypt(struct crypto_blkcipher *tfm, int decrypt, void * iv, void * in, @@ -546,27 +547,27 @@ __u32 krb5_encrypt(struct ll_crypto_cipher *tfm, desc.info = local_iv; desc.flags= 0; - if (length % ll_crypto_blkcipher_blocksize(tfm) != 0) { + if (length % crypto_blkcipher_blocksize(tfm) != 0) { CERROR("output length %d mismatch blocksize %d\n", - length, ll_crypto_blkcipher_blocksize(tfm)); + length, crypto_blkcipher_blocksize(tfm)); goto out; } - if (ll_crypto_blkcipher_ivsize(tfm) > 16) { - CERROR("iv size too large %d\n", ll_crypto_blkcipher_ivsize(tfm)); + if (crypto_blkcipher_ivsize(tfm) > 16) { + CERROR("iv size too large %d\n", crypto_blkcipher_ivsize(tfm)); goto out; } if (iv) - memcpy(local_iv, iv, ll_crypto_blkcipher_ivsize(tfm)); + memcpy(local_iv, iv, crypto_blkcipher_ivsize(tfm)); memcpy(out, in, length); buf_to_sg(&sg, out, length); if (decrypt) - ret = ll_crypto_blkcipher_decrypt_iv(&desc, &sg, &sg, length); + ret = crypto_blkcipher_decrypt_iv(&desc, &sg, &sg, length); else - ret = ll_crypto_blkcipher_encrypt_iv(&desc, &sg, &sg, length); + ret = crypto_blkcipher_encrypt_iv(&desc, &sg, &sg, length); out: return(ret); @@ -574,7 +575,7 @@ out: static inline -int krb5_digest_hmac(struct ll_crypto_hash *tfm, +int krb5_digest_hmac(struct crypto_hash *tfm, rawobj_t *key, struct krb5_header *khdr, int msgcnt, rawobj_t *msgs, @@ -585,17 +586,17 @@ int krb5_digest_hmac(struct ll_crypto_hash *tfm, struct scatterlist sg[1]; int i; - ll_crypto_hash_setkey(tfm, key->data, key->len); + crypto_hash_setkey(tfm, key->data, key->len); desc.tfm = tfm; desc.flags= 0; - ll_crypto_hash_init(&desc); + crypto_hash_init(&desc); for (i = 0; i < msgcnt; i++) { if (msgs[i].len == 0) continue; buf_to_sg(sg, (char *) msgs[i].data, msgs[i].len); - ll_crypto_hash_update(&desc, sg, msgs[i].len); + crypto_hash_update(&desc, sg, msgs[i].len); } for (i = 0; i < iovcnt; i++) { @@ -604,20 +605,20 @@ int krb5_digest_hmac(struct ll_crypto_hash *tfm, sg_set_page(&sg[0], iovs[i].kiov_page, iovs[i].kiov_len, iovs[i].kiov_offset); - ll_crypto_hash_update(&desc, sg, iovs[i].kiov_len); + crypto_hash_update(&desc, sg, iovs[i].kiov_len); } if (khdr) { buf_to_sg(sg, (char *) khdr, sizeof(*khdr)); - ll_crypto_hash_update(&desc, sg, sizeof(*khdr)); + crypto_hash_update(&desc, sg, sizeof(*khdr)); } - return ll_crypto_hash_final(&desc, cksum->data); + return crypto_hash_final(&desc, cksum->data); } static inline -int krb5_digest_norm(struct ll_crypto_hash *tfm, +int krb5_digest_norm(struct crypto_hash *tfm, struct krb5_keyblock *kb, struct krb5_header *khdr, int msgcnt, rawobj_t *msgs, @@ -632,13 +633,13 @@ int krb5_digest_norm(struct ll_crypto_hash *tfm, desc.tfm = tfm; desc.flags= 0; - ll_crypto_hash_init(&desc); + crypto_hash_init(&desc); for (i = 0; i < msgcnt; i++) { if (msgs[i].len == 0) continue; buf_to_sg(sg, (char *) msgs[i].data, msgs[i].len); - ll_crypto_hash_update(&desc, sg, msgs[i].len); + crypto_hash_update(&desc, sg, msgs[i].len); } for (i = 0; i < iovcnt; i++) { @@ -647,15 +648,15 @@ int krb5_digest_norm(struct ll_crypto_hash *tfm, sg_set_page(&sg[0], iovs[i].kiov_page, iovs[i].kiov_len, iovs[i].kiov_offset); - ll_crypto_hash_update(&desc, sg, iovs[i].kiov_len); + crypto_hash_update(&desc, sg, iovs[i].kiov_len); } if (khdr) { buf_to_sg(sg, (char *) khdr, sizeof(*khdr)); - ll_crypto_hash_update(&desc, sg, sizeof(*khdr)); + crypto_hash_update(&desc, sg, sizeof(*khdr)); } - ll_crypto_hash_final(&desc, cksum->data); + crypto_hash_final(&desc, cksum->data); return krb5_encrypt(kb->kb_tfm, 0, NULL, cksum->data, cksum->data, cksum->len); @@ -674,7 +675,7 @@ __s32 krb5_make_checksum(__u32 enctype, rawobj_t *cksum) { struct krb5_enctype *ke = &enctypes[enctype]; - struct ll_crypto_hash *tfm; + struct crypto_hash *tfm; __u32 code = GSS_S_FAILURE; int rc; @@ -683,7 +684,7 @@ __s32 krb5_make_checksum(__u32 enctype, return GSS_S_FAILURE; } - cksum->len = ll_crypto_hash_digestsize(tfm); + cksum->len = crypto_hash_digestsize(tfm); OBD_ALLOC_LARGE(cksum->data, cksum->len); if (!cksum->data) { cksum->len = 0; @@ -700,7 +701,7 @@ __s32 krb5_make_checksum(__u32 enctype, if (rc == 0) code = GSS_S_COMPLETE; out_tfm: - ll_crypto_free_hash(tfm); + crypto_free_hash(tfm); return code; } @@ -878,7 +879,7 @@ int add_padding(rawobj_t *msg, int msg_buflen, int blocksize) } static -int krb5_encrypt_rawobjs(struct ll_crypto_cipher *tfm, +int krb5_encrypt_rawobjs(struct crypto_blkcipher *tfm, int mode_ecb, int inobj_cnt, rawobj_t *inobjs, @@ -890,7 +891,6 @@ int krb5_encrypt_rawobjs(struct ll_crypto_cipher *tfm, __u8 local_iv[16] = {0}, *buf; __u32 datalen = 0; int i, rc; - ENTRY; buf = outobj->data; desc.tfm = tfm; @@ -905,23 +905,23 @@ int krb5_encrypt_rawobjs(struct ll_crypto_cipher *tfm, if (mode_ecb) { if (enc) - rc = ll_crypto_blkcipher_encrypt( + rc = crypto_blkcipher_encrypt( &desc, &dst, &src, src.length); else - rc = ll_crypto_blkcipher_decrypt( + rc = crypto_blkcipher_decrypt( &desc, &dst, &src, src.length); } else { if (enc) - rc = ll_crypto_blkcipher_encrypt_iv( + rc = crypto_blkcipher_encrypt_iv( &desc, &dst, &src, src.length); else - rc = ll_crypto_blkcipher_decrypt_iv( + rc = crypto_blkcipher_decrypt_iv( &desc, &dst, &src, src.length); } if (rc) { CERROR("encrypt error %d\n", rc); - RETURN(rc); + return rc; } datalen += inobjs[i].len; @@ -929,14 +929,14 @@ int krb5_encrypt_rawobjs(struct ll_crypto_cipher *tfm, } outobj->len = datalen; - RETURN(0); + return 0; } /* * if adj_nob != 0, we adjust desc->bd_nob to the actual cipher text size. */ static -int krb5_encrypt_bulk(struct ll_crypto_cipher *tfm, +int krb5_encrypt_bulk(struct crypto_blkcipher *tfm, struct krb5_header *khdr, char *confounder, struct ptlrpc_bulk_desc *desc, @@ -951,7 +951,7 @@ int krb5_encrypt_bulk(struct ll_crypto_cipher *tfm, LASSERT(desc->bd_iov_count); LASSERT(desc->bd_enc_iov); - blocksize = ll_crypto_blkcipher_blocksize(tfm); + blocksize = crypto_blkcipher_blocksize(tfm); LASSERT(blocksize > 1); LASSERT(cipher->len == blocksize + sizeof(*khdr)); @@ -963,7 +963,7 @@ int krb5_encrypt_bulk(struct ll_crypto_cipher *tfm, buf_to_sg(&src, confounder, blocksize); buf_to_sg(&dst, cipher->data, blocksize); - rc = ll_crypto_blkcipher_encrypt_iv(&ciph_desc, &dst, &src, blocksize); + rc = crypto_blkcipher_encrypt_iv(&ciph_desc, &dst, &src, blocksize); if (rc) { CERROR("error to encrypt confounder: %d\n", rc); return rc; @@ -983,7 +983,7 @@ int krb5_encrypt_bulk(struct ll_crypto_cipher *tfm, desc->bd_enc_iov[i].kiov_offset = dst.offset; desc->bd_enc_iov[i].kiov_len = dst.length; - rc = ll_crypto_blkcipher_encrypt_iv(&ciph_desc, &dst, &src, + rc = crypto_blkcipher_encrypt_iv(&ciph_desc, &dst, &src, src.length); if (rc) { CERROR("error to encrypt page: %d\n", rc); @@ -995,7 +995,7 @@ int krb5_encrypt_bulk(struct ll_crypto_cipher *tfm, buf_to_sg(&src, khdr, sizeof(*khdr)); buf_to_sg(&dst, cipher->data + blocksize, sizeof(*khdr)); - rc = ll_crypto_blkcipher_encrypt_iv(&ciph_desc, + rc = crypto_blkcipher_encrypt_iv(&ciph_desc, &dst, &src, sizeof(*khdr)); if (rc) { CERROR("error to encrypt krb5 header: %d\n", rc); @@ -1025,7 +1025,7 @@ int krb5_encrypt_bulk(struct ll_crypto_cipher *tfm, * should have been done by prep_bulk(). */ static -int krb5_decrypt_bulk(struct ll_crypto_cipher *tfm, +int krb5_decrypt_bulk(struct crypto_blkcipher *tfm, struct krb5_header *khdr, struct ptlrpc_bulk_desc *desc, rawobj_t *cipher, @@ -1042,7 +1042,7 @@ int krb5_decrypt_bulk(struct ll_crypto_cipher *tfm, LASSERT(desc->bd_enc_iov); LASSERT(desc->bd_nob_transferred); - blocksize = ll_crypto_blkcipher_blocksize(tfm); + blocksize = crypto_blkcipher_blocksize(tfm); LASSERT(blocksize > 1); LASSERT(cipher->len == blocksize + sizeof(*khdr)); @@ -1059,7 +1059,7 @@ int krb5_decrypt_bulk(struct ll_crypto_cipher *tfm, buf_to_sg(&src, cipher->data, blocksize); buf_to_sg(&dst, plain->data, blocksize); - rc = ll_crypto_blkcipher_decrypt_iv(&ciph_desc, &dst, &src, blocksize); + rc = crypto_blkcipher_decrypt_iv(&ciph_desc, &dst, &src, blocksize); if (rc) { CERROR("error to decrypt confounder: %d\n", rc); return rc; @@ -1102,7 +1102,7 @@ int krb5_decrypt_bulk(struct ll_crypto_cipher *tfm, if (desc->bd_iov[i].kiov_len % blocksize == 0) sg_assign_page(&dst, desc->bd_iov[i].kiov_page); - rc = ll_crypto_blkcipher_decrypt_iv(&ciph_desc, &dst, &src, + rc = crypto_blkcipher_decrypt_iv(&ciph_desc, &dst, &src, src.length); if (rc) { CERROR("error to decrypt page: %d\n", rc); @@ -1142,7 +1142,7 @@ int krb5_decrypt_bulk(struct ll_crypto_cipher *tfm, buf_to_sg(&src, cipher->data + blocksize, sizeof(*khdr)); buf_to_sg(&dst, cipher->data + blocksize, sizeof(*khdr)); - rc = ll_crypto_blkcipher_decrypt_iv(&ciph_desc, + rc = crypto_blkcipher_decrypt_iv(&ciph_desc, &dst, &src, sizeof(*khdr)); if (rc) { CERROR("error to decrypt tail: %d\n", rc); @@ -1177,7 +1177,7 @@ __u32 gss_wrap_kerberos(struct gss_ctx *gctx, LASSERT(ke->ke_conf_size <= GSS_MAX_CIPHER_BLOCK); LASSERT(kctx->kc_keye.kb_tfm == NULL || ke->ke_conf_size >= - ll_crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm)); + crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm)); /* * final token format: @@ -1201,7 +1201,7 @@ __u32 gss_wrap_kerberos(struct gss_ctx *gctx, blocksize = 1; } else { LASSERT(kctx->kc_keye.kb_tfm); - blocksize = ll_crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); + blocksize = crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); } LASSERT(blocksize <= ke->ke_conf_size); @@ -1248,7 +1248,7 @@ __u32 gss_wrap_kerberos(struct gss_ctx *gctx, if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) { rawobj_t arc4_keye; - struct ll_crypto_cipher *arc4_tfm; + struct crypto_blkcipher *arc4_tfm; if (krb5_make_checksum(ENCTYPE_ARCFOUR_HMAC, &kctx->kc_keyi, NULL, 1, &cksum, 0, NULL, &arc4_keye)) { @@ -1256,13 +1256,13 @@ __u32 gss_wrap_kerberos(struct gss_ctx *gctx, GOTO(arc4_out, rc = -EACCES); } - arc4_tfm = ll_crypto_alloc_blkcipher("ecb(arc4)", 0, 0); + arc4_tfm = crypto_alloc_blkcipher("ecb(arc4)", 0, 0); if (IS_ERR(arc4_tfm)) { CERROR("failed to alloc tfm arc4 in ECB mode\n"); GOTO(arc4_out_key, rc = -EACCES); } - if (ll_crypto_blkcipher_setkey(arc4_tfm, arc4_keye.data, + if (crypto_blkcipher_setkey(arc4_tfm, arc4_keye.data, arc4_keye.len)) { CERROR("failed to set arc4 key, len %d\n", arc4_keye.len); @@ -1272,7 +1272,7 @@ __u32 gss_wrap_kerberos(struct gss_ctx *gctx, rc = krb5_encrypt_rawobjs(arc4_tfm, 1, 3, data_desc, &cipher, 1); arc4_out_tfm: - ll_crypto_free_blkcipher(arc4_tfm); + crypto_free_blkcipher(arc4_tfm); arc4_out_key: rawobj_free(&arc4_keye); arc4_out: @@ -1310,7 +1310,7 @@ __u32 gss_prep_bulk_kerberos(struct gss_ctx *gctx, LASSERT(desc->bd_enc_iov); LASSERT(kctx->kc_keye.kb_tfm); - blocksize = ll_crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); + blocksize = crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); for (i = 0; i < desc->bd_iov_count; i++) { LASSERT(desc->bd_enc_iov[i].kiov_page); @@ -1371,7 +1371,7 @@ __u32 gss_wrap_bulk_kerberos(struct gss_ctx *gctx, blocksize = 1; } else { LASSERT(kctx->kc_keye.kb_tfm); - blocksize = ll_crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); + blocksize = crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); } /* @@ -1481,7 +1481,7 @@ __u32 gss_unwrap_kerberos(struct gss_ctx *gctx, blocksize = 1; } else { LASSERT(kctx->kc_keye.kb_tfm); - blocksize = ll_crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); + blocksize = crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); } /* expected token layout: @@ -1521,7 +1521,7 @@ __u32 gss_unwrap_kerberos(struct gss_ctx *gctx, if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) { rawobj_t arc4_keye; - struct ll_crypto_cipher *arc4_tfm; + struct crypto_blkcipher *arc4_tfm; cksum.data = token->data + token->len - ke->ke_hash_size; cksum.len = ke->ke_hash_size; @@ -1532,13 +1532,13 @@ __u32 gss_unwrap_kerberos(struct gss_ctx *gctx, GOTO(arc4_out, rc = -EACCES); } - arc4_tfm = ll_crypto_alloc_blkcipher("ecb(arc4)", 0, 0); + arc4_tfm = crypto_alloc_blkcipher("ecb(arc4)", 0, 0); if (IS_ERR(arc4_tfm)) { CERROR("failed to alloc tfm arc4 in ECB mode\n"); GOTO(arc4_out_key, rc = -EACCES); } - if (ll_crypto_blkcipher_setkey(arc4_tfm, + if (crypto_blkcipher_setkey(arc4_tfm, arc4_keye.data, arc4_keye.len)) { CERROR("failed to set arc4 key, len %d\n", arc4_keye.len); @@ -1548,7 +1548,7 @@ __u32 gss_unwrap_kerberos(struct gss_ctx *gctx, rc = krb5_encrypt_rawobjs(arc4_tfm, 1, 1, &cipher_in, &plain_out, 0); arc4_out_tfm: - ll_crypto_free_blkcipher(arc4_tfm); + crypto_free_blkcipher(arc4_tfm); arc4_out_key: rawobj_free(&arc4_keye); arc4_out: @@ -1647,7 +1647,7 @@ __u32 gss_unwrap_bulk_kerberos(struct gss_ctx *gctx, LBUG(); } else { LASSERT(kctx->kc_keye.kb_tfm); - blocksize = ll_crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); + blocksize = crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); } LASSERT(sizeof(*khdr) >= blocksize && sizeof(*khdr) % blocksize == 0); diff --git a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_pipefs.c b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_pipefs.c index 3df7257b7fa0..c624518c181a 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_pipefs.c +++ b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_pipefs.c @@ -262,7 +262,6 @@ void gss_sec_ctx_replace_pf(struct gss_sec *gsec, struct hlist_node *next; HLIST_HEAD(freelist); unsigned int hash; - ENTRY; gsec_pf = container_of(gsec, struct gss_sec_pipefs, gsp_base); @@ -287,7 +286,6 @@ void gss_sec_ctx_replace_pf(struct gss_sec *gsec, spin_unlock(&gsec->gs_base.ps_lock); ctx_list_destroy_pf(&freelist); - EXIT; } static @@ -297,23 +295,22 @@ int gss_install_rvs_cli_ctx_pf(struct gss_sec *gsec, struct vfs_cred vcred; struct ptlrpc_cli_ctx *cli_ctx; int rc; - ENTRY; vcred.vc_uid = 0; vcred.vc_gid = 0; cli_ctx = ctx_create_pf(&gsec->gs_base, &vcred); if (!cli_ctx) - RETURN(-ENOMEM); + return -ENOMEM; rc = gss_copy_rvc_cli_ctx(cli_ctx, svc_ctx); if (rc) { ctx_destroy_pf(cli_ctx->cc_sec, cli_ctx); - RETURN(rc); + return rc; } gss_sec_ctx_replace_pf(gsec, cli_ctx); - RETURN(0); + return 0; } static @@ -324,7 +321,6 @@ void gss_ctx_cache_gc_pf(struct gss_sec_pipefs *gsec_pf, struct ptlrpc_cli_ctx *ctx; struct hlist_node *next; int i; - ENTRY; sec = &gsec_pf->gsp_base.gs_base; @@ -337,7 +333,6 @@ void gss_ctx_cache_gc_pf(struct gss_sec_pipefs *gsec_pf, } sec->ps_gc_next = cfs_time_current_sec() + sec->ps_gc_interval; - EXIT; } static @@ -347,7 +342,6 @@ struct ptlrpc_sec* gss_sec_create_pf(struct obd_import *imp, { struct gss_sec_pipefs *gsec_pf; int alloc_size, hash_size, i; - ENTRY; #define GSS_SEC_PIPEFS_CTX_HASH_SIZE (32) @@ -362,7 +356,7 @@ struct ptlrpc_sec* gss_sec_create_pf(struct obd_import *imp, OBD_ALLOC(gsec_pf, alloc_size); if (!gsec_pf) - RETURN(NULL); + return NULL; gsec_pf->gsp_chash_size = hash_size; for (i = 0; i < hash_size; i++) @@ -380,13 +374,13 @@ struct ptlrpc_sec* gss_sec_create_pf(struct obd_import *imp, goto err_destroy; } - RETURN(&gsec_pf->gsp_base.gs_base); + return &gsec_pf->gsp_base.gs_base; err_destroy: gss_sec_destroy_common(&gsec_pf->gsp_base); err_free: OBD_FREE(gsec_pf, alloc_size); - RETURN(NULL); + return NULL; } static @@ -423,7 +417,6 @@ struct ptlrpc_cli_ctx * gss_sec_lookup_ctx_pf(struct ptlrpc_sec *sec, struct hlist_node *next; HLIST_HEAD(freelist); unsigned int hash, gc = 0, found = 0; - ENTRY; might_sleep(); @@ -473,7 +466,7 @@ retry: /* don't allocate for reverse sec */ if (sec_is_reverse(sec)) { spin_unlock(&sec->ps_lock); - RETURN(NULL); + return NULL; } if (new) { @@ -504,7 +497,7 @@ retry: } ctx_list_destroy_pf(&freelist); - RETURN(ctx); + return ctx; } static @@ -545,7 +538,6 @@ int gss_sec_flush_ctx_cache_pf(struct ptlrpc_sec *sec, struct hlist_node *next; HLIST_HEAD(freelist); int i, busy = 0; - ENTRY; might_sleep_if(grace); @@ -584,7 +576,7 @@ int gss_sec_flush_ctx_cache_pf(struct ptlrpc_sec *sec, spin_unlock(&sec->ps_lock); ctx_list_destroy_pf(&freelist); - RETURN(busy); + return busy; } /**************************************** @@ -704,11 +696,9 @@ void upcall_msg_delist(struct gss_upcall_msg *msg) static void gss_release_msg(struct gss_upcall_msg *gmsg) { - ENTRY; LASSERT(atomic_read(&gmsg->gum_refcount) > 0); if (!atomic_dec_and_test(&gmsg->gum_refcount)) { - EXIT; return; } @@ -721,7 +711,6 @@ void gss_release_msg(struct gss_upcall_msg *gmsg) LASSERT(list_empty(&gmsg->gum_list)); LASSERT(list_empty(&gmsg->gum_base.list)); OBD_FREE_PTR(gmsg); - EXIT; } static @@ -809,19 +798,18 @@ ssize_t gss_pipe_upcall(struct file *filp, struct rpc_pipe_msg *msg, char *data = (char *)msg->data + msg->copied; ssize_t mlen = msg->len; ssize_t left; - ENTRY; if (mlen > buflen) mlen = buflen; left = copy_to_user(dst, data, mlen); if (left < 0) { msg->errno = left; - RETURN(left); + return left; } mlen -= left; msg->copied += mlen; msg->errno = 0; - RETURN(mlen); + return mlen; } static @@ -835,14 +823,13 @@ ssize_t gss_pipe_downcall(struct file *filp, const char *src, size_t mlen) int datalen; int timeout, rc; __u32 mechidx, seq, gss_err; - ENTRY; mechidx = (__u32) (long) rpci->private; LASSERT(mechidx < MECH_MAX); OBD_ALLOC(buf, mlen); if (!buf) - RETURN(-ENOMEM); + return -ENOMEM; if (copy_from_user(buf, src, mlen)) { CERROR("failed copy user space data\n"); @@ -940,7 +927,7 @@ out_free: * hack pipefs: always return asked length unless all following * downcalls might be messed up. */ rc = mlen; - RETURN(rc); + return rc; } static @@ -949,13 +936,11 @@ 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; - ENTRY; LASSERT(list_empty(&msg->list)); /* normally errno is >= 0 */ if (msg->errno >= 0) { - EXIT; return; } @@ -980,7 +965,6 @@ void gss_pipe_destroy_msg(struct rpc_pipe_msg *msg) } gss_msg_fail_ctx(gmsg); gss_release_msg(gmsg); - EXIT; } static @@ -988,7 +972,6 @@ void gss_pipe_release(struct inode *inode) { struct rpc_inode *rpci = RPC_I(inode); __u32 idx; - ENTRY; idx = (__u32) (long) rpci->private; LASSERT(idx < MECH_MAX); @@ -1020,7 +1003,6 @@ void gss_pipe_release(struct inode *inode) upcall_list_lock(idx); } upcall_list_unlock(idx); - EXIT; } static struct rpc_pipe_ops gss_upcall_ops = { @@ -1041,7 +1023,6 @@ int gss_ctx_refresh_pf(struct ptlrpc_cli_ctx *ctx) struct gss_sec *gsec; struct gss_upcall_msg *gmsg; int rc = 0; - ENTRY; might_sleep(); @@ -1052,14 +1033,14 @@ int gss_ctx_refresh_pf(struct ptlrpc_cli_ctx *ctx) imp = ctx->cc_sec->ps_import; if (!imp->imp_connection) { CERROR("import has no connection set\n"); - RETURN(-EINVAL); + return -EINVAL; } gsec = container_of(ctx->cc_sec, struct gss_sec, gs_base); OBD_ALLOC_PTR(gmsg); if (!gmsg) - RETURN(-ENOMEM); + return -ENOMEM; /* initialize pipefs base msg */ INIT_LIST_HEAD(&gmsg->gum_base.list); @@ -1107,10 +1088,10 @@ int gss_ctx_refresh_pf(struct ptlrpc_cli_ctx *ctx) goto err_free; } - RETURN(0); + return 0; err_free: OBD_FREE_PTR(gmsg); - RETURN(rc); + return rc; } static diff --git a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_rawobj.c b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_rawobj.c index 474ecf805307..fb298aef66eb 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_rawobj.c +++ b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_rawobj.c @@ -65,7 +65,7 @@ int rawobj_alloc(rawobj_t *obj, char *buf, int len) OBD_ALLOC_LARGE(obj->data, len); if (!obj->data) { obj->len = 0; - RETURN(-ENOMEM); + return -ENOMEM; } memcpy(obj->data, buf, len); } else diff --git a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_svc_upcall.c b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_svc_upcall.c index 31b50ea19c25..5b5365b4629f 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/gss/gss_svc_upcall.c +++ b/drivers/staging/lustre/lustre/ptlrpc/gss/gss_svc_upcall.c @@ -259,8 +259,6 @@ static int rsi_parse(struct cache_detail *cd, char *mesg, int mlen) struct rsi rsii, *rsip = NULL; time_t expiry; int status = -EINVAL; - ENTRY; - memset(&rsii, 0, sizeof(rsii)); @@ -341,7 +339,7 @@ out: if (status) CERROR("rsi parse error %d\n", status); - RETURN(status); + return status; } static struct cache_detail rsi_cache = { @@ -662,7 +660,6 @@ static void rsc_flush(rsc_entry_match *match, long data) struct cache_head **ch; struct rsc *rscp; int n; - ENTRY; write_lock(&rsc_cache.hash_lock); for (n = 0; n < RSC_HASHMAX; n++) { @@ -684,7 +681,6 @@ static void rsc_flush(rsc_entry_match *match, long data) } } write_unlock(&rsc_cache.hash_lock); - EXIT; } static int match_uid(struct rsc *rscp, long uid) @@ -744,7 +740,6 @@ int gss_svc_upcall_install_rvs_ctx(struct obd_import *imp, unsigned long ctx_expiry; __u32 major; int rc; - ENTRY; memset(&rsci, 0, sizeof(rsci)); @@ -792,7 +787,7 @@ out: if (rc) CERROR("create reverse svc ctx: idx "LPX64", rc %d\n", gsec->gs_rvs_hdl, rc); - RETURN(rc); + return rc; } int gss_svc_upcall_expire_rvs_ctx(rawobj_t *handle) @@ -855,7 +850,6 @@ int gss_svc_upcall_handle_init(struct ptlrpc_request *req, struct gss_rep_header *rephdr; int first_check = 1; int rc = SECSVC_DROP; - ENTRY; memset(&rsikey, 0, sizeof(rsikey)); rsikey.lustre_svc = lustre_svc; @@ -1016,7 +1010,7 @@ out: COMPAT_RSC_PUT(&rsci->h, &rsc_cache); } - RETURN(rc); + return rc; } struct gss_svc_ctx *gss_svc_upcall_get_ctx(struct ptlrpc_request *req, diff --git a/drivers/staging/lustre/lustre/ptlrpc/gss/lproc_gss.c b/drivers/staging/lustre/lustre/ptlrpc/gss/lproc_gss.c index 340400089a5a..de100a14ab52 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/gss/lproc_gss.c +++ b/drivers/staging/lustre/lustre/ptlrpc/gss/lproc_gss.c @@ -199,15 +199,17 @@ int gss_init_lproc(void) gss_proc_root = lprocfs_register("gss", sptlrpc_proc_root, gss_lprocfs_vars, NULL); if (IS_ERR(gss_proc_root)) { + rc = PTR_ERR(gss_proc_root); gss_proc_root = NULL; - GOTO(err_out, rc = PTR_ERR(gss_proc_root)); + GOTO(err_out, rc); } gss_proc_lk = lprocfs_register("lgss_keyring", gss_proc_root, gss_lk_lprocfs_vars, NULL); if (IS_ERR(gss_proc_lk)) { + rc = PTR_ERR(gss_proc_lk); gss_proc_lk = NULL; - GOTO(err_out, rc = PTR_ERR(gss_proc_root)); + GOTO(err_out, rc); } return 0; diff --git a/drivers/staging/lustre/lustre/ptlrpc/gss/sec_gss.c b/drivers/staging/lustre/lustre/ptlrpc/gss/sec_gss.c index ebca858ca183..b42ddda9ee25 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/gss/sec_gss.c +++ b/drivers/staging/lustre/lustre/ptlrpc/gss/sec_gss.c @@ -280,11 +280,10 @@ __u32 gss_unseal_msg(struct gss_ctx *mechctx, __u8 *clear_buf; int clear_buflen; __u32 major; - ENTRY; if (msgbuf->lm_bufcount != 2) { CERROR("invalid bufcount %d\n", msgbuf->lm_bufcount); - RETURN(GSS_S_FAILURE); + return GSS_S_FAILURE; } /* allocate a temporary clear text buffer, same sized as token, @@ -292,7 +291,7 @@ __u32 gss_unseal_msg(struct gss_ctx *mechctx, clear_buflen = lustre_msg_buflen(msgbuf, 1); OBD_ALLOC_LARGE(clear_buf, clear_buflen); if (!clear_buf) - RETURN(GSS_S_FAILURE); + return GSS_S_FAILURE; /* buffer objects */ hdrobj.len = lustre_msg_buflen(msgbuf, 0); @@ -317,7 +316,7 @@ __u32 gss_unseal_msg(struct gss_ctx *mechctx, major = GSS_S_COMPLETE; out_free: OBD_FREE_LARGE(clear_buf, clear_buflen); - RETURN(major); + return major; } /******************************************** @@ -646,7 +645,6 @@ int gss_cli_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct gss_cli_ctx *gctx = ctx2gctx(ctx); __u32 flags = 0, seq, svc; int rc; - ENTRY; LASSERT(req->rq_reqbuf); LASSERT(req->rq_reqbuf->lm_bufcount >= 2); @@ -654,7 +652,7 @@ int gss_cli_ctx_sign(struct ptlrpc_cli_ctx *ctx, /* nothing to do for context negotiation RPCs */ if (req->rq_ctx_init) - RETURN(0); + return 0; svc = SPTLRPC_FLVR_SVC(req->rq_flvr.sf_rpc); if (req->rq_pack_bulk) @@ -670,7 +668,7 @@ redo: flags, gctx->gc_proc, seq, svc, &gctx->gc_handle); if (rc < 0) - RETURN(rc); + return rc; /* gss_sign_msg() msg might take long time to finish, in which period * more rpcs could be wrapped up and sent out. if we found too many @@ -689,7 +687,7 @@ redo: } req->rq_reqdata_len = rc; - RETURN(0); + return 0; } static @@ -765,7 +763,6 @@ int gss_cli_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct lustre_msg *msg = req->rq_repdata; __u32 major; int pack_bulk, swabbed, rc = 0; - ENTRY; LASSERT(req->rq_cli_ctx == ctx); LASSERT(msg); @@ -777,12 +774,12 @@ int gss_cli_ctx_verify(struct ptlrpc_cli_ctx *ctx, if (req->rq_ctx_init && !req->rq_early) { req->rq_repmsg = lustre_msg_buf(msg, 1, 0); req->rq_replen = msg->lm_buflens[1]; - RETURN(0); + return 0; } if (msg->lm_bufcount < 2 || msg->lm_bufcount > 4) { CERROR("unexpected bufcount %u\n", msg->lm_bufcount); - RETURN(-EPROTO); + return -EPROTO; } swabbed = ptlrpc_rep_need_swab(req); @@ -790,7 +787,7 @@ int gss_cli_ctx_verify(struct ptlrpc_cli_ctx *ctx, ghdr = gss_swab_header(msg, 0, swabbed); if (ghdr == NULL) { CERROR("can't decode gss header\n"); - RETURN(-EPROTO); + return -EPROTO; } /* sanity checks */ @@ -800,7 +797,7 @@ int gss_cli_ctx_verify(struct ptlrpc_cli_ctx *ctx, if (ghdr->gh_version != reqhdr->gh_version) { CERROR("gss version %u mismatch, expect %u\n", ghdr->gh_version, reqhdr->gh_version); - RETURN(-EPROTO); + return -EPROTO; } switch (ghdr->gh_proc) { @@ -810,19 +807,19 @@ int gss_cli_ctx_verify(struct ptlrpc_cli_ctx *ctx, if (!req->rq_early && !equi(req->rq_pack_bulk == 1, pack_bulk)){ CERROR("%s bulk flag in reply\n", req->rq_pack_bulk ? "missing" : "unexpected"); - RETURN(-EPROTO); + return -EPROTO; } if (ghdr->gh_seq != reqhdr->gh_seq) { CERROR("seqnum %u mismatch, expect %u\n", ghdr->gh_seq, reqhdr->gh_seq); - RETURN(-EPROTO); + return -EPROTO; } if (ghdr->gh_svc != reqhdr->gh_svc) { CERROR("svc %u mismatch, expect %u\n", ghdr->gh_svc, reqhdr->gh_svc); - RETURN(-EPROTO); + return -EPROTO; } if (swabbed) @@ -831,7 +828,7 @@ int gss_cli_ctx_verify(struct ptlrpc_cli_ctx *ctx, major = gss_verify_msg(msg, gctx->gc_mechctx, reqhdr->gh_svc); if (major != GSS_S_COMPLETE) { CERROR("failed to verify reply: %x\n", major); - RETURN(-EPERM); + return -EPERM; } if (req->rq_early && reqhdr->gh_svc == SPTLRPC_SVC_NULL) { @@ -843,7 +840,7 @@ int gss_cli_ctx_verify(struct ptlrpc_cli_ctx *ctx, if (cksum != msg->lm_cksum) { CWARN("early reply checksum mismatch: " "%08x != %08x\n", cksum, msg->lm_cksum); - RETURN(-EPROTO); + return -EPROTO; } } @@ -852,13 +849,13 @@ int gss_cli_ctx_verify(struct ptlrpc_cli_ctx *ctx, if (msg->lm_bufcount < 3) { CERROR("Invalid reply bufcount %u\n", msg->lm_bufcount); - RETURN(-EPROTO); + return -EPROTO; } rc = bulk_sec_desc_unpack(msg, 2, swabbed); if (rc) { CERROR("unpack bulk desc: %d\n", rc); - RETURN(rc); + return rc; } } @@ -878,7 +875,7 @@ int gss_cli_ctx_verify(struct ptlrpc_cli_ctx *ctx, rc = -EPROTO; } - RETURN(rc); + return rc; } int gss_cli_ctx_seal(struct ptlrpc_cli_ctx *ctx, @@ -889,7 +886,6 @@ int gss_cli_ctx_seal(struct ptlrpc_cli_ctx *ctx, struct gss_header *ghdr; __u32 buflens[2], major; int wiresize, rc; - ENTRY; LASSERT(req->rq_clrbuf); LASSERT(req->rq_cli_ctx == ctx); @@ -915,7 +911,7 @@ int gss_cli_ctx_seal(struct ptlrpc_cli_ctx *ctx, } else { OBD_ALLOC_LARGE(req->rq_reqbuf, wiresize); if (!req->rq_reqbuf) - RETURN(-ENOMEM); + return -ENOMEM; req->rq_reqbuf_len = wiresize; } @@ -969,7 +965,7 @@ redo: /* now set the final wire data length */ req->rq_reqdata_len = lustre_shrink_msg(req->rq_reqbuf, 1, token.len,0); - RETURN(0); + return 0; err_free: if (!req->rq_pool) { @@ -977,7 +973,7 @@ err_free: req->rq_reqbuf = NULL; req->rq_reqbuf_len = 0; } - RETURN(rc); + return rc; } int gss_cli_ctx_unseal(struct ptlrpc_cli_ctx *ctx, @@ -988,7 +984,6 @@ int gss_cli_ctx_unseal(struct ptlrpc_cli_ctx *ctx, struct lustre_msg *msg = req->rq_repdata; int msglen, pack_bulk, swabbed, rc; __u32 major; - ENTRY; LASSERT(req->rq_cli_ctx == ctx); LASSERT(req->rq_ctx_init == 0); @@ -1000,14 +995,14 @@ int gss_cli_ctx_unseal(struct ptlrpc_cli_ctx *ctx, ghdr = gss_swab_header(msg, 0, swabbed); if (ghdr == NULL) { CERROR("can't decode gss header\n"); - RETURN(-EPROTO); + return -EPROTO; } /* sanity checks */ if (ghdr->gh_version != PTLRPC_GSS_VERSION) { CERROR("gss version %u mismatch, expect %u\n", ghdr->gh_version, PTLRPC_GSS_VERSION); - RETURN(-EPROTO); + return -EPROTO; } switch (ghdr->gh_proc) { @@ -1017,7 +1012,7 @@ int gss_cli_ctx_unseal(struct ptlrpc_cli_ctx *ctx, if (!req->rq_early && !equi(req->rq_pack_bulk == 1, pack_bulk)){ CERROR("%s bulk flag in reply\n", req->rq_pack_bulk ? "missing" : "unexpected"); - RETURN(-EPROTO); + return -EPROTO; } if (swabbed) @@ -1038,25 +1033,25 @@ int gss_cli_ctx_unseal(struct ptlrpc_cli_ctx *ctx, swabbed = __lustre_unpack_msg(msg, msglen); if (swabbed < 0) { CERROR("Failed to unpack after decryption\n"); - RETURN(-EPROTO); + return -EPROTO; } if (msg->lm_bufcount < 1) { CERROR("Invalid reply buffer: empty\n"); - RETURN(-EPROTO); + return -EPROTO; } if (pack_bulk) { if (msg->lm_bufcount < 2) { CERROR("bufcount %u: missing bulk sec desc\n", msg->lm_bufcount); - RETURN(-EPROTO); + return -EPROTO; } /* bulk checksum is the last segment */ if (bulk_sec_desc_unpack(msg, msg->lm_bufcount - 1, swabbed)) - RETURN(-EPROTO); + return -EPROTO; } req->rq_repmsg = lustre_msg_buf(msg, 0, 0); @@ -1077,7 +1072,7 @@ int gss_cli_ctx_unseal(struct ptlrpc_cli_ctx *ctx, rc = -EPERM; } - RETURN(rc); + return rc; } /********************************************* @@ -1148,7 +1143,6 @@ int gss_sec_create_common(struct gss_sec *gsec, void gss_sec_destroy_common(struct gss_sec *gsec) { struct ptlrpc_sec *sec = &gsec->gs_base; - ENTRY; LASSERT(sec->ps_import); LASSERT(atomic_read(&sec->ps_refcount) == 0); @@ -1163,8 +1157,6 @@ void gss_sec_destroy_common(struct gss_sec *gsec) if (SPTLRPC_FLVR_BULK_SVC(sec->ps_flvr.sf_rpc) == SPTLRPC_BULK_SVC_PRIV) sptlrpc_enc_pool_del_user(); - - EXIT; } void gss_sec_kill(struct ptlrpc_sec *sec) @@ -1260,7 +1252,6 @@ int gss_alloc_reqbuf_intg(struct ptlrpc_sec *sec, int bufsize, txtsize; int bufcnt = 2; __u32 buflens[5]; - ENTRY; /* * on-wire data layout: @@ -1312,7 +1303,7 @@ int gss_alloc_reqbuf_intg(struct ptlrpc_sec *sec, OBD_ALLOC_LARGE(req->rq_reqbuf, bufsize); if (!req->rq_reqbuf) - RETURN(-ENOMEM); + return -ENOMEM; req->rq_reqbuf_len = bufsize; } else { @@ -1331,7 +1322,7 @@ int gss_alloc_reqbuf_intg(struct ptlrpc_sec *sec, if (req->rq_pack_udesc) sptlrpc_pack_user_desc(req->rq_reqbuf, 2); - RETURN(0); + return 0; } static @@ -1342,7 +1333,6 @@ int gss_alloc_reqbuf_priv(struct ptlrpc_sec *sec, __u32 ibuflens[3], wbuflens[2]; int ibufcnt; int clearsize, wiresize; - ENTRY; LASSERT(req->rq_clrbuf == NULL); LASSERT(req->rq_clrbuf_len == 0); @@ -1399,7 +1389,7 @@ int gss_alloc_reqbuf_priv(struct ptlrpc_sec *sec, OBD_ALLOC_LARGE(req->rq_clrbuf, clearsize); if (!req->rq_clrbuf) - RETURN(-ENOMEM); + return -ENOMEM; } req->rq_clrbuf_len = clearsize; @@ -1409,7 +1399,7 @@ int gss_alloc_reqbuf_priv(struct ptlrpc_sec *sec, if (req->rq_pack_udesc) sptlrpc_pack_user_desc(req->rq_clrbuf, 1); - RETURN(0); + return 0; } /* @@ -1442,7 +1432,6 @@ void gss_free_reqbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req) { int privacy; - ENTRY; LASSERT(!req->rq_pool || req->rq_reqbuf); privacy = SPTLRPC_FLVR_SVC(req->rq_flvr.sf_rpc) == SPTLRPC_SVC_PRIV; @@ -1471,8 +1460,6 @@ release_reqbuf: req->rq_reqbuf = NULL; req->rq_reqbuf_len = 0; } - - EXIT; } static int do_alloc_repbuf(struct ptlrpc_request *req, int bufsize) @@ -1578,7 +1565,6 @@ int gss_alloc_repbuf(struct ptlrpc_sec *sec, int msgsize) { int svc = SPTLRPC_FLVR_SVC(req->rq_flvr.sf_rpc); - ENTRY; LASSERT(!req->rq_pack_bulk || (req->rq_bulk_read || req->rq_bulk_write)); @@ -1697,7 +1683,7 @@ int gss_enlarge_reqbuf_intg(struct ptlrpc_sec *sec, OBD_ALLOC_LARGE(newbuf, newbuf_size); if (newbuf == NULL) - RETURN(-ENOMEM); + return -ENOMEM; memcpy(newbuf, req->rq_reqbuf, req->rq_reqbuf_len); @@ -1717,7 +1703,7 @@ int gss_enlarge_reqbuf_intg(struct ptlrpc_sec *sec, _sptlrpc_enlarge_msg_inplace(req->rq_reqmsg, segment, newsize); req->rq_reqlen = newmsg_size; - RETURN(0); + return 0; } static @@ -1786,7 +1772,7 @@ int gss_enlarge_reqbuf_priv(struct ptlrpc_sec *sec, OBD_ALLOC_LARGE(newclrbuf, newclrbuf_size); if (newclrbuf == NULL) - RETURN(-ENOMEM); + return -ENOMEM; memcpy(newclrbuf, req->rq_clrbuf, req->rq_clrbuf_len); @@ -1806,7 +1792,7 @@ int gss_enlarge_reqbuf_priv(struct ptlrpc_sec *sec, _sptlrpc_enlarge_msg_inplace(req->rq_reqmsg, segment, newsize); req->rq_reqlen = newmsg_size; - RETURN(0); + return 0; } int gss_enlarge_reqbuf(struct ptlrpc_sec *sec, @@ -1891,7 +1877,6 @@ int gss_svc_sign(struct ptlrpc_request *req, { __u32 flags = 0; int rc; - ENTRY; LASSERT(rs->rs_msg == lustre_msg_buf(rs->rs_repbuf, 1, 0)); @@ -1906,7 +1891,7 @@ int gss_svc_sign(struct ptlrpc_request *req, LUSTRE_SP_ANY, flags, PTLRPC_GSS_PROC_DATA, grctx->src_wirectx.gw_seq, svc, NULL); if (rc < 0) - RETURN(rc); + return rc; rs->rs_repdata_len = rc; @@ -1923,7 +1908,7 @@ int gss_svc_sign(struct ptlrpc_request *req, req->rq_reply_off = 0; } - RETURN(0); + return 0; } int gss_pack_err_notify(struct ptlrpc_request *req, __u32 major, __u32 minor) @@ -1933,10 +1918,9 @@ int gss_pack_err_notify(struct ptlrpc_request *req, __u32 major, __u32 minor) struct gss_err_header *ghdr; int replen = sizeof(struct ptlrpc_body); int rc; - ENTRY; //if (OBD_FAIL_CHECK_ORSET(OBD_FAIL_SVCGSS_ERR_NOTIFY, OBD_FAIL_ONCE)) - // RETURN(-EINVAL); + // return -EINVAL; grctx->src_err_notify = 1; grctx->src_reserve_len = 0; @@ -1944,7 +1928,7 @@ int gss_pack_err_notify(struct ptlrpc_request *req, __u32 major, __u32 minor) rc = lustre_pack_reply_v2(req, 1, &replen, NULL, 0); if (rc) { CERROR("could not pack reply, err %d\n", rc); - RETURN(rc); + return rc; } /* gss hdr */ @@ -1963,7 +1947,7 @@ int gss_pack_err_notify(struct ptlrpc_request *req, __u32 major, __u32 minor) CDEBUG(D_SEC, "prepare gss error notify(0x%x/0x%x) to %s\n", major, minor, libcfs_nid2str(req->rq_peer.nid)); - RETURN(0); + return 0; } static @@ -1978,7 +1962,6 @@ int gss_svc_handle_init(struct ptlrpc_request *req, __u32 lustre_svc; __u32 *secdata, seclen; int swabbed, rc; - ENTRY; CDEBUG(D_SEC, "processing gss init(%d) request from %s\n", gw->gw_proc, libcfs_nid2str(req->rq_peer.nid)); @@ -1987,18 +1970,18 @@ int gss_svc_handle_init(struct ptlrpc_request *req, if (gw->gw_flags & LUSTRE_GSS_PACK_BULK) { CERROR("unexpected bulk flag\n"); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } if (gw->gw_proc == PTLRPC_GSS_PROC_INIT && gw->gw_handle.len != 0) { CERROR("proc %u: invalid handle length %u\n", gw->gw_proc, gw->gw_handle.len); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } if (reqbuf->lm_bufcount < 3 || reqbuf->lm_bufcount > 4){ CERROR("Invalid bufcount %d\n", reqbuf->lm_bufcount); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } swabbed = ptlrpc_req_need_swab(req); @@ -2009,7 +1992,7 @@ int gss_svc_handle_init(struct ptlrpc_request *req, if (seclen < 4 + 4) { CERROR("sec size %d too small\n", seclen); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } /* lustre svc type */ @@ -2020,7 +2003,7 @@ int gss_svc_handle_init(struct ptlrpc_request *req, * because touched internal structure of obd_uuid */ if (rawobj_extract(&uuid_obj, &secdata, &seclen)) { CERROR("failed to extract target uuid\n"); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } uuid_obj.data[uuid_obj.len - 1] = '\0'; @@ -2030,25 +2013,25 @@ int gss_svc_handle_init(struct ptlrpc_request *req, CERROR("target '%s' is not available for context init (%s)\n", uuid->uuid, target == NULL ? "no target" : (target->obd_stopping ? "stopping" : "not set up")); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } /* extract reverse handle */ if (rawobj_extract(&rvs_hdl, &secdata, &seclen)) { CERROR("failed extract reverse handle\n"); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } /* extract token */ if (rawobj_extract(&in_token, &secdata, &seclen)) { CERROR("can't extract token\n"); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } rc = gss_svc_upcall_handle_init(req, grctx, gw, target, lustre_svc, &rvs_hdl, &in_token); if (rc != SECSVC_OK) - RETURN(rc); + return rc; if (grctx->src_ctx->gsc_usr_mds || grctx->src_ctx->gsc_usr_oss || grctx->src_ctx->gsc_usr_root) @@ -2064,11 +2047,11 @@ int gss_svc_handle_init(struct ptlrpc_request *req, if (gw->gw_flags & LUSTRE_GSS_PACK_USER) { if (reqbuf->lm_bufcount < 4) { CERROR("missing user descriptor\n"); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } if (sptlrpc_unpack_user_desc(reqbuf, 2, swabbed)) { CERROR("Mal-formed user descriptor\n"); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } req->rq_pack_udesc = 1; @@ -2078,7 +2061,7 @@ int gss_svc_handle_init(struct ptlrpc_request *req, req->rq_reqmsg = lustre_msg_buf(reqbuf, 1, 0); req->rq_reqlen = lustre_msg_buflen(reqbuf, 1); - RETURN(rc); + return rc; } /* @@ -2094,13 +2077,12 @@ int gss_svc_verify_request(struct ptlrpc_request *req, struct lustre_msg *msg = req->rq_reqbuf; int offset = 2; int swabbed; - ENTRY; *major = GSS_S_COMPLETE; if (msg->lm_bufcount < 2) { CERROR("Too few segments (%u) in request\n", msg->lm_bufcount); - RETURN(-EINVAL); + return -EINVAL; } if (gw->gw_svc == SPTLRPC_SVC_NULL) @@ -2109,20 +2091,20 @@ int gss_svc_verify_request(struct ptlrpc_request *req, if (gss_check_seq_num(&gctx->gsc_seqdata, gw->gw_seq, 0)) { CERROR("phase 0: discard replayed req: seq %u\n", gw->gw_seq); *major = GSS_S_DUPLICATE_TOKEN; - RETURN(-EACCES); + return -EACCES; } *major = gss_verify_msg(msg, gctx->gsc_mechctx, gw->gw_svc); if (*major != GSS_S_COMPLETE) { CERROR("failed to verify request: %x\n", *major); - RETURN(-EACCES); + return -EACCES; } if (gctx->gsc_reverse == 0 && gss_check_seq_num(&gctx->gsc_seqdata, gw->gw_seq, 1)) { CERROR("phase 1+: discard replayed req: seq %u\n", gw->gw_seq); *major = GSS_S_DUPLICATE_TOKEN; - RETURN(-EACCES); + return -EACCES; } verified: @@ -2132,12 +2114,12 @@ verified: if (gw->gw_flags & LUSTRE_GSS_PACK_USER) { if (msg->lm_bufcount < (offset + 1)) { CERROR("no user desc included\n"); - RETURN(-EINVAL); + return -EINVAL; } if (sptlrpc_unpack_user_desc(msg, offset, swabbed)) { CERROR("Mal-formed user descriptor\n"); - RETURN(-EINVAL); + return -EINVAL; } req->rq_pack_udesc = 1; @@ -2149,11 +2131,11 @@ verified: if (gw->gw_flags & LUSTRE_GSS_PACK_BULK) { if (msg->lm_bufcount < (offset + 1)) { CERROR("missing bulk sec descriptor\n"); - RETURN(-EINVAL); + return -EINVAL; } if (bulk_sec_desc_unpack(msg, offset, swabbed)) - RETURN(-EINVAL); + return -EINVAL; req->rq_pack_bulk = 1; grctx->src_reqbsd = lustre_msg_buf(msg, offset, 0); @@ -2162,7 +2144,7 @@ verified: req->rq_reqmsg = lustre_msg_buf(msg, 1, 0); req->rq_reqlen = msg->lm_buflens[1]; - RETURN(0); + return 0; } static @@ -2174,48 +2156,47 @@ int gss_svc_unseal_request(struct ptlrpc_request *req, struct gss_svc_ctx *gctx = grctx->src_ctx; struct lustre_msg *msg = req->rq_reqbuf; int swabbed, msglen, offset = 1; - ENTRY; if (gss_check_seq_num(&gctx->gsc_seqdata, gw->gw_seq, 0)) { CERROR("phase 0: discard replayed req: seq %u\n", gw->gw_seq); *major = GSS_S_DUPLICATE_TOKEN; - RETURN(-EACCES); + return -EACCES; } *major = gss_unseal_msg(gctx->gsc_mechctx, msg, &msglen, req->rq_reqdata_len); if (*major != GSS_S_COMPLETE) { CERROR("failed to unwrap request: %x\n", *major); - RETURN(-EACCES); + return -EACCES; } if (gss_check_seq_num(&gctx->gsc_seqdata, gw->gw_seq, 1)) { CERROR("phase 1+: discard replayed req: seq %u\n", gw->gw_seq); *major = GSS_S_DUPLICATE_TOKEN; - RETURN(-EACCES); + return -EACCES; } swabbed = __lustre_unpack_msg(msg, msglen); if (swabbed < 0) { CERROR("Failed to unpack after decryption\n"); - RETURN(-EINVAL); + return -EINVAL; } req->rq_reqdata_len = msglen; if (msg->lm_bufcount < 1) { CERROR("Invalid buffer: is empty\n"); - RETURN(-EINVAL); + return -EINVAL; } if (gw->gw_flags & LUSTRE_GSS_PACK_USER) { if (msg->lm_bufcount < offset + 1) { CERROR("no user descriptor included\n"); - RETURN(-EINVAL); + return -EINVAL; } if (sptlrpc_unpack_user_desc(msg, offset, swabbed)) { CERROR("Mal-formed user descriptor\n"); - RETURN(-EINVAL); + return -EINVAL; } req->rq_pack_udesc = 1; @@ -2226,11 +2207,11 @@ int gss_svc_unseal_request(struct ptlrpc_request *req, if (gw->gw_flags & LUSTRE_GSS_PACK_BULK) { if (msg->lm_bufcount < offset + 1) { CERROR("no bulk checksum included\n"); - RETURN(-EINVAL); + return -EINVAL; } if (bulk_sec_desc_unpack(msg, offset, swabbed)) - RETURN(-EINVAL); + return -EINVAL; req->rq_pack_bulk = 1; grctx->src_reqbsd = lustre_msg_buf(msg, offset, 0); @@ -2239,7 +2220,7 @@ int gss_svc_unseal_request(struct ptlrpc_request *req, req->rq_reqmsg = lustre_msg_buf(req->rq_reqbuf, 0, 0); req->rq_reqlen = req->rq_reqbuf->lm_buflens[0]; - RETURN(0); + return 0; } static @@ -2249,7 +2230,6 @@ int gss_svc_handle_data(struct ptlrpc_request *req, struct gss_svc_reqctx *grctx = gss_svc_ctx2reqctx(req->rq_svc_ctx); __u32 major = 0; int rc = 0; - ENTRY; grctx->src_ctx = gss_svc_upcall_get_ctx(req, gw); if (!grctx->src_ctx) { @@ -2272,7 +2252,7 @@ int gss_svc_handle_data(struct ptlrpc_request *req, } if (rc == 0) - RETURN(SECSVC_OK); + return SECSVC_OK; CERROR("svc %u failed: major 0x%08x: req xid "LPU64" ctx %p idx " LPX64"(%u->%s)\n", gw->gw_svc, major, req->rq_xid, @@ -2283,9 +2263,9 @@ error: * might happen after server reboot, to allow recovery. */ if ((major == GSS_S_NO_CONTEXT || major == GSS_S_BAD_SIG) && gss_pack_err_notify(req, major, 0) == 0) - RETURN(SECSVC_COMPLETE); + return SECSVC_COMPLETE; - RETURN(SECSVC_DROP); + return SECSVC_DROP; } static @@ -2294,7 +2274,6 @@ int gss_svc_handle_destroy(struct ptlrpc_request *req, { struct gss_svc_reqctx *grctx = gss_svc_ctx2reqctx(req->rq_svc_ctx); __u32 major; - ENTRY; req->rq_ctx_fini = 1; req->rq_no_reply = 1; @@ -2302,16 +2281,16 @@ int gss_svc_handle_destroy(struct ptlrpc_request *req, grctx->src_ctx = gss_svc_upcall_get_ctx(req, gw); if (!grctx->src_ctx) { CDEBUG(D_SEC, "invalid gss context handle for destroy.\n"); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } if (gw->gw_svc != SPTLRPC_SVC_INTG) { CERROR("svc %u is not supported in destroy.\n", gw->gw_svc); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } if (gss_svc_verify_request(req, grctx, gw, &major)) - RETURN(SECSVC_DROP); + return SECSVC_DROP; CWARN("destroy svc ctx %p idx "LPX64" (%u->%s)\n", grctx->src_ctx, gss_handle_to_u64(&gw->gw_handle), @@ -2322,19 +2301,19 @@ int gss_svc_handle_destroy(struct ptlrpc_request *req, if (gw->gw_flags & LUSTRE_GSS_PACK_USER) { if (req->rq_reqbuf->lm_bufcount < 4) { CERROR("missing user descriptor, ignore it\n"); - RETURN(SECSVC_OK); + return SECSVC_OK; } if (sptlrpc_unpack_user_desc(req->rq_reqbuf, 2, ptlrpc_req_need_swab(req))) { CERROR("Mal-formed user descriptor, ignore it\n"); - RETURN(SECSVC_OK); + return SECSVC_OK; } req->rq_pack_udesc = 1; req->rq_user_desc = lustre_msg_buf(req->rq_reqbuf, 2, 0); } - RETURN(SECSVC_OK); + return SECSVC_OK; } int gss_svc_accept(struct ptlrpc_sec_policy *policy, struct ptlrpc_request *req) @@ -2343,14 +2322,13 @@ int gss_svc_accept(struct ptlrpc_sec_policy *policy, struct ptlrpc_request *req) struct gss_svc_reqctx *grctx; struct gss_wire_ctx *gw; int swabbed, rc; - ENTRY; LASSERT(req->rq_reqbuf); LASSERT(req->rq_svc_ctx == NULL); if (req->rq_reqbuf->lm_bufcount < 2) { CERROR("buf count only %d\n", req->rq_reqbuf->lm_bufcount); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } swabbed = ptlrpc_req_need_swab(req); @@ -2358,14 +2336,14 @@ int gss_svc_accept(struct ptlrpc_sec_policy *policy, struct ptlrpc_request *req) ghdr = gss_swab_header(req->rq_reqbuf, 0, swabbed); if (ghdr == NULL) { CERROR("can't decode gss header\n"); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } /* sanity checks */ if (ghdr->gh_version != PTLRPC_GSS_VERSION) { CERROR("gss version %u, expect %u\n", ghdr->gh_version, PTLRPC_GSS_VERSION); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } req->rq_sp_from = ghdr->gh_sp; @@ -2373,7 +2351,7 @@ int gss_svc_accept(struct ptlrpc_sec_policy *policy, struct ptlrpc_request *req) /* alloc grctx data */ OBD_ALLOC_PTR(grctx); if (!grctx) - RETURN(SECSVC_DROP); + return SECSVC_DROP; grctx->src_base.sc_policy = sptlrpc_policy_get(policy); atomic_set(&grctx->src_base.sc_refcount, 1); @@ -2428,16 +2406,14 @@ int gss_svc_accept(struct ptlrpc_sec_policy *policy, struct ptlrpc_request *req) break; } - RETURN(rc); + return rc; } void gss_svc_invalidate_ctx(struct ptlrpc_svc_ctx *svc_ctx) { struct gss_svc_reqctx *grctx; - ENTRY; if (svc_ctx == NULL) { - EXIT; return; } @@ -2446,8 +2422,6 @@ void gss_svc_invalidate_ctx(struct ptlrpc_svc_ctx *svc_ctx) CWARN("gss svc invalidate ctx %p(%u)\n", grctx->src_ctx, grctx->src_ctx->gsc_uid); gss_svc_upcall_destroy_ctx(grctx->src_ctx); - - EXIT; } static inline @@ -2496,13 +2470,12 @@ int gss_svc_alloc_rs(struct ptlrpc_request *req, int msglen) __u32 ibuflens[2], buflens[4]; int ibufcnt = 0, bufcnt; int txtsize, wmsg_size, rs_size; - ENTRY; LASSERT(msglen % 8 == 0); if (req->rq_pack_bulk && !req->rq_bulk_read && !req->rq_bulk_write) { CERROR("client request bulk sec on non-bulk rpc\n"); - RETURN(-EPROTO); + return -EPROTO; } svc = SPTLRPC_FLVR_SVC(req->rq_flvr.sf_rpc); @@ -2575,7 +2548,7 @@ int gss_svc_alloc_rs(struct ptlrpc_request *req, int msglen) } else { OBD_ALLOC_LARGE(rs, rs_size); if (rs == NULL) - RETURN(-ENOMEM); + return -ENOMEM; rs->rs_size = rs_size; } @@ -2605,7 +2578,7 @@ int gss_svc_alloc_rs(struct ptlrpc_request *req, int msglen) LASSERT(rs->rs_msg); req->rq_reply_state = rs; - RETURN(0); + return 0; } static int gss_svc_seal(struct ptlrpc_request *req, @@ -2619,7 +2592,6 @@ static int gss_svc_seal(struct ptlrpc_request *req, int token_buflen; __u32 buflens[2], major; int msglen, rc; - ENTRY; /* get clear data length. note embedded lustre_msg might * have been shrinked */ @@ -2647,7 +2619,7 @@ static int gss_svc_seal(struct ptlrpc_request *req, token_buflen = gss_mech_payload(gctx->gsc_mechctx, msglen, 1); OBD_ALLOC_LARGE(token_buf, token_buflen); if (token_buf == NULL) - RETURN(-ENOMEM); + return -ENOMEM; hdrobj.len = PTLRPC_GSS_HEADER_SIZE; hdrobj.data = (__u8 *) ghdr; @@ -2703,7 +2675,7 @@ static int gss_svc_seal(struct ptlrpc_request *req, rc = 0; out_free: OBD_FREE_LARGE(token_buf, token_buflen); - RETURN(rc); + return rc; } int gss_svc_authorize(struct ptlrpc_request *req) @@ -2712,7 +2684,6 @@ int gss_svc_authorize(struct ptlrpc_request *req) struct gss_svc_reqctx *grctx = gss_svc_ctx2reqctx(req->rq_svc_ctx); struct gss_wire_ctx *gw = &grctx->src_wirectx; int early, rc; - ENTRY; early = (req->rq_packed_final == 0); @@ -2720,7 +2691,7 @@ int gss_svc_authorize(struct ptlrpc_request *req) LASSERT(rs->rs_repdata_len != 0); req->rq_reply_off = gss_at_reply_off_integ; - RETURN(0); + return 0; } /* early reply could happen in many cases */ @@ -2728,7 +2699,7 @@ int gss_svc_authorize(struct ptlrpc_request *req) gw->gw_proc != PTLRPC_GSS_PROC_DATA && gw->gw_proc != PTLRPC_GSS_PROC_DESTROY) { CERROR("proc %d not support\n", gw->gw_proc); - RETURN(-EINVAL); + return -EINVAL; } LASSERT(grctx->src_ctx); @@ -2749,7 +2720,7 @@ int gss_svc_authorize(struct ptlrpc_request *req) rc = 0; out: - RETURN(rc); + return rc; } void gss_svc_free_rs(struct ptlrpc_reply_state *rs) diff --git a/drivers/staging/lustre/lustre/ptlrpc/import.c b/drivers/staging/lustre/lustre/ptlrpc/import.c index 47a3c0512739..5ca69aec72e1 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/import.c +++ b/drivers/staging/lustre/lustre/ptlrpc/import.c @@ -195,7 +195,6 @@ int ptlrpc_set_import_discon(struct obd_import *imp, __u32 conn_cnt) /* Must be called with imp_lock held! */ static void ptlrpc_deactivate_and_unlock_import(struct obd_import *imp) { - ENTRY; LASSERT(spin_is_locked(&imp->imp_lock)); CDEBUG(D_HA, "setting import %s INVALID\n", obd2cli_tgt(imp->imp_obd)); @@ -205,8 +204,6 @@ static void ptlrpc_deactivate_and_unlock_import(struct obd_import *imp) ptlrpc_abort_inflight(imp); obd_import_event(imp->imp_obd, imp, IMP_EVENT_INACTIVE); - - EXIT; } /* @@ -394,8 +391,6 @@ EXPORT_SYMBOL(ptlrpc_activate_import); void ptlrpc_fail_import(struct obd_import *imp, __u32 conn_cnt) { - ENTRY; - LASSERT(!imp->imp_dlm_fake); if (ptlrpc_set_import_discon(imp, conn_cnt)) { @@ -417,7 +412,6 @@ void ptlrpc_fail_import(struct obd_import *imp, __u32 conn_cnt) ptlrpc_pinger_wake_up(); } - EXIT; } EXPORT_SYMBOL(ptlrpc_fail_import); @@ -461,7 +455,6 @@ static int import_select_connection(struct obd_import *imp) struct obd_export *dlmexp; char *target_start; int target_len, tried_all = 1; - ENTRY; spin_lock(&imp->imp_lock); @@ -469,7 +462,7 @@ static int import_select_connection(struct obd_import *imp) CERROR("%s: no connections available\n", imp->imp_obd->obd_name); spin_unlock(&imp->imp_lock); - RETURN(-EINVAL); + return -EINVAL; } list_for_each_entry(conn, &imp->imp_conn_list, oic_item) { @@ -558,7 +551,7 @@ static int import_select_connection(struct obd_import *imp) spin_unlock(&imp->imp_lock); - RETURN(0); + return 0; } /* @@ -602,21 +595,20 @@ int ptlrpc_connect_import(struct obd_import *imp) (char *)&imp->imp_connect_data }; struct ptlrpc_connect_async_args *aa; int rc; - ENTRY; spin_lock(&imp->imp_lock); if (imp->imp_state == LUSTRE_IMP_CLOSED) { spin_unlock(&imp->imp_lock); CERROR("can't connect to a closed import\n"); - RETURN(-EINVAL); + return -EINVAL; } else if (imp->imp_state == LUSTRE_IMP_FULL) { spin_unlock(&imp->imp_lock); CERROR("already connected\n"); - RETURN(0); + return 0; } else if (imp->imp_state == LUSTRE_IMP_CONNECTING) { spin_unlock(&imp->imp_lock); CERROR("already connecting\n"); - RETURN(-EALREADY); + return -EALREADY; } IMPORT_SET_STATE_NOLOCK(imp, LUSTRE_IMP_CONNECTING); @@ -716,7 +708,7 @@ out: IMPORT_SET_STATE(imp, LUSTRE_IMP_DISCON); } - RETURN(rc); + return rc; } EXPORT_SYMBOL(ptlrpc_connect_import); @@ -756,13 +748,12 @@ static int ptlrpc_connect_interpret(const struct lu_env *env, struct obd_connect_data *ocd; struct obd_export *exp; int ret; - ENTRY; spin_lock(&imp->imp_lock); if (imp->imp_state == LUSTRE_IMP_CLOSED) { imp->imp_connect_tried = 1; spin_unlock(&imp->imp_lock); - RETURN(0); + return 0; } if (rc) { @@ -984,7 +975,7 @@ finish: imp->imp_connection->c_remote_uuid.uuid); ptlrpc_connect_import(imp); imp->imp_connect_tried = 1; - RETURN(0); + return 0; } } else { @@ -1137,7 +1128,7 @@ out: /* reply message might not be ready */ if (request->rq_repmsg == NULL) - RETURN(-EPROTO); + return -EPROTO; ocd = req_capsule_server_get(&request->rq_pill, &RMF_CONNECT_DATA); @@ -1161,7 +1152,7 @@ out: ptlrpc_deactivate_import(imp); IMPORT_SET_STATE(imp, LUSTRE_IMP_CLOSED); } - RETURN(-EPROTO); + return -EPROTO; } ptlrpc_maybe_ping_import_soon(imp); @@ -1172,7 +1163,7 @@ out: } wake_up_all(&imp->imp_recovery_waitq); - RETURN(rc); + return rc; } /** @@ -1183,7 +1174,6 @@ static int completed_replay_interpret(const struct lu_env *env, struct ptlrpc_request *req, void * data, int rc) { - ENTRY; atomic_dec(&req->rq_import->imp_replay_inflight); if (req->rq_status == 0 && !req->rq_import->imp_vbr_failed) { @@ -1202,7 +1192,7 @@ static int completed_replay_interpret(const struct lu_env *env, ptlrpc_connect_import(req->rq_import); } - RETURN(0); + return 0; } /** @@ -1212,10 +1202,9 @@ static int completed_replay_interpret(const struct lu_env *env, static int signal_completed_replay(struct obd_import *imp) { struct ptlrpc_request *req; - ENTRY; if (unlikely(OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_FINISH_REPLAY))) - RETURN(0); + return 0; LASSERT(atomic_read(&imp->imp_replay_inflight) == 0); atomic_inc(&imp->imp_replay_inflight); @@ -1224,7 +1213,7 @@ static int signal_completed_replay(struct obd_import *imp) OBD_PING); if (req == NULL) { atomic_dec(&imp->imp_replay_inflight); - RETURN(-ENOMEM); + return -ENOMEM; } ptlrpc_request_set_replen(req); @@ -1236,7 +1225,7 @@ static int signal_completed_replay(struct obd_import *imp) req->rq_interpret_reply = completed_replay_interpret; ptlrpcd_add_req(req, PDL_POLICY_ROUND, -1); - RETURN(0); + return 0; } /** @@ -1248,8 +1237,6 @@ static int ptlrpc_invalidate_import_thread(void *data) { struct obd_import *imp = data; - ENTRY; - unshare_fs_struct(); CDEBUG(D_HA, "thread invalidate import %s to %s@%s\n", @@ -1267,7 +1254,7 @@ static int ptlrpc_invalidate_import_thread(void *data) ptlrpc_import_recovery_state_machine(imp); class_import_put(imp); - RETURN(0); + return 0; } /** @@ -1297,7 +1284,6 @@ int ptlrpc_import_recovery_state_machine(struct obd_import *imp) char *target_start; int target_len; - ENTRY; if (imp->imp_state == LUSTRE_IMP_EVICTED) { deuuidify(obd2cli_tgt(imp->imp_obd), NULL, &target_start, &target_len); @@ -1319,7 +1305,7 @@ int ptlrpc_import_recovery_state_machine(struct obd_import *imp) spin_unlock(&imp->imp_lock); { - task_t *task; + struct task_struct *task; /* bug 17802: XXX client_disconnect_export vs connect request * race. if client will evicted at this time, we start * invalidate thread without reference to import and import can @@ -1334,7 +1320,7 @@ int ptlrpc_import_recovery_state_machine(struct obd_import *imp) } else { rc = 0; } - RETURN(rc); + return rc; } } @@ -1393,7 +1379,7 @@ int ptlrpc_import_recovery_state_machine(struct obd_import *imp) } out: - RETURN(rc); + return rc; } int ptlrpc_disconnect_import(struct obd_import *imp, int noclose) @@ -1401,7 +1387,6 @@ int ptlrpc_disconnect_import(struct obd_import *imp, int noclose) struct ptlrpc_request *req; int rq_opc, rc = 0; int nowait = imp->imp_obd->obd_force; - ENTRY; if (nowait) GOTO(set_state, rc); @@ -1413,7 +1398,7 @@ int ptlrpc_disconnect_import(struct obd_import *imp, int noclose) default: CERROR("don't know how to disconnect from %s (connect_op %d)\n", obd2cli_tgt(imp->imp_obd), imp->imp_connect_op); - RETURN(-EINVAL); + return -EINVAL; } if (ptlrpc_import_in_recovery(imp)) { @@ -1476,21 +1461,17 @@ out: memset(&imp->imp_remote_handle, 0, sizeof(imp->imp_remote_handle)); spin_unlock(&imp->imp_lock); - RETURN(rc); + return rc; } EXPORT_SYMBOL(ptlrpc_disconnect_import); void ptlrpc_cleanup_imp(struct obd_import *imp) { - ENTRY; - spin_lock(&imp->imp_lock); IMPORT_SET_STATE_NOLOCK(imp, LUSTRE_IMP_CLOSED); imp->imp_generation++; spin_unlock(&imp->imp_lock); ptlrpc_abort_inflight(imp); - - EXIT; } EXPORT_SYMBOL(ptlrpc_cleanup_imp); diff --git a/drivers/staging/lustre/lustre/ptlrpc/llog_client.c b/drivers/staging/lustre/lustre/ptlrpc/llog_client.c index 367ca8ef7d60..379e59477ea2 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/llog_client.c +++ b/drivers/staging/lustre/lustre/ptlrpc/llog_client.c @@ -85,7 +85,6 @@ static int llog_client_open(const struct lu_env *env, struct llog_ctxt *ctxt = lgh->lgh_ctxt; struct ptlrpc_request *req = NULL; int rc; - ENTRY; LLOG_CLIENT_ENTRY(ctxt, imp); @@ -133,7 +132,6 @@ static int llog_client_open(const struct lu_env *env, lgh->lgh_id = body->lgd_logid; lgh->lgh_ctxt = ctxt; - EXIT; out: LLOG_CLIENT_EXIT(ctxt, imp); ptlrpc_req_finished(req); @@ -147,7 +145,6 @@ static int llog_client_destroy(const struct lu_env *env, struct ptlrpc_request *req = NULL; struct llogd_body *body; int rc; - ENTRY; LLOG_CLIENT_ENTRY(loghandle->lgh_ctxt, imp); req = ptlrpc_request_alloc_pack(imp, &RQF_LLOG_ORIGIN_HANDLE_DESTROY, @@ -170,7 +167,7 @@ static int llog_client_destroy(const struct lu_env *env, ptlrpc_req_finished(req); err_exit: LLOG_CLIENT_EXIT(loghandle->lgh_ctxt, imp); - RETURN(rc); + return rc; } @@ -184,7 +181,6 @@ static int llog_client_next_block(const struct lu_env *env, struct llogd_body *body; void *ptr; int rc; - ENTRY; LLOG_CLIENT_ENTRY(loghandle->lgh_ctxt, imp); req = ptlrpc_request_alloc_pack(imp, &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK, @@ -221,7 +217,6 @@ static int llog_client_next_block(const struct lu_env *env, *cur_offset = body->lgd_cur_offset; memcpy(buf, ptr, len); - EXIT; out: ptlrpc_req_finished(req); err_exit: @@ -238,7 +233,6 @@ static int llog_client_prev_block(const struct lu_env *env, struct llogd_body *body; void *ptr; int rc; - ENTRY; LLOG_CLIENT_ENTRY(loghandle->lgh_ctxt, imp); req = ptlrpc_request_alloc_pack(imp, &RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK, @@ -270,7 +264,6 @@ static int llog_client_prev_block(const struct lu_env *env, GOTO(out, rc =-EFAULT); memcpy(buf, ptr, len); - EXIT; out: ptlrpc_req_finished(req); err_exit: @@ -287,7 +280,6 @@ static int llog_client_read_header(const struct lu_env *env, struct llog_log_hdr *hdr; struct llog_rec_hdr *llh_hdr; int rc; - ENTRY; LLOG_CLIENT_ENTRY(handle->lgh_ctxt, imp); req = ptlrpc_request_alloc_pack(imp,&RQF_LLOG_ORIGIN_HANDLE_READ_HEADER, @@ -326,7 +318,6 @@ static int llog_client_read_header(const struct lu_env *env, CERROR("you may need to re-run lconf --write_conf.\n"); rc = -EIO; } - EXIT; out: ptlrpc_req_finished(req); err_exit: diff --git a/drivers/staging/lustre/lustre/ptlrpc/llog_net.c b/drivers/staging/lustre/lustre/ptlrpc/llog_net.c index a81f557d7794..17c06a32df62 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/llog_net.c +++ b/drivers/staging/lustre/lustre/ptlrpc/llog_net.c @@ -57,7 +57,6 @@ int llog_initiator_connect(struct llog_ctxt *ctxt) { struct obd_import *new_imp; - ENTRY; LASSERT(ctxt); new_imp = ctxt->loc_obd->u.cli.cl_import; @@ -70,6 +69,6 @@ int llog_initiator_connect(struct llog_ctxt *ctxt) ctxt->loc_imp = class_import_get(new_imp); } mutex_unlock(&ctxt->loc_mutex); - RETURN(0); + return 0; } EXPORT_SYMBOL(llog_initiator_connect); diff --git a/drivers/staging/lustre/lustre/ptlrpc/llog_server.c b/drivers/staging/lustre/lustre/ptlrpc/llog_server.c index bc1fcd8c7e73..af9d2ac391ef 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/llog_server.c +++ b/drivers/staging/lustre/lustre/ptlrpc/llog_server.c @@ -71,11 +71,9 @@ int llog_origin_handle_open(struct ptlrpc_request *req) char *name = NULL; int rc; - ENTRY; - body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); if (body == NULL) - RETURN(-EFAULT); + return -EFAULT; if (ostid_id(&body->lgd_logid.lgl_oi) > 0) logid = &body->lgd_logid; @@ -83,7 +81,7 @@ int llog_origin_handle_open(struct ptlrpc_request *req) if (req_capsule_field_present(&req->rq_pill, &RMF_NAME, RCL_CLIENT)) { name = req_capsule_client_get(&req->rq_pill, &RMF_NAME); if (name == NULL) - RETURN(-EFAULT); + return -EFAULT; CDEBUG(D_INFO, "%s: opening log %s\n", obd->obd_name, name); } @@ -91,7 +89,7 @@ int llog_origin_handle_open(struct ptlrpc_request *req) if (ctxt == NULL) { CDEBUG(D_WARNING, "%s: no ctxt. group=%p idx=%d name=%s\n", obd->obd_name, &obd->obd_olg, body->lgd_ctxt_idx, name); - RETURN(-ENODEV); + return -ENODEV; } disk_obd = ctxt->loc_exp->exp_obd; push_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL); @@ -108,7 +106,6 @@ int llog_origin_handle_open(struct ptlrpc_request *req) body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY); body->lgd_logid = loghandle->lgh_id; - EXIT; out_close: llog_origin_close(req->rq_svc_thread->t_env, loghandle); out_pop: @@ -127,11 +124,9 @@ int llog_origin_handle_destroy(struct ptlrpc_request *req) struct llog_ctxt *ctxt; int rc; - ENTRY; - body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); if (body == NULL) - RETURN(-EFAULT); + return -EFAULT; if (ostid_id(&body->lgd_logid.lgl_oi) > 0) logid = &body->lgd_logid; @@ -142,7 +137,7 @@ int llog_origin_handle_destroy(struct ptlrpc_request *req) ctxt = llog_get_context(req->rq_export->exp_obd, body->lgd_ctxt_idx); if (ctxt == NULL) - RETURN(-ENODEV); + return -ENODEV; disk_obd = ctxt->loc_exp->exp_obd; push_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL); @@ -153,7 +148,7 @@ int llog_origin_handle_destroy(struct ptlrpc_request *req) rc = llog_erase(req->rq_svc_thread->t_env, ctxt, logid, NULL); pop_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL); llog_ctxt_put(ctxt); - RETURN(rc); + return rc; } EXPORT_SYMBOL(llog_origin_handle_destroy); @@ -169,15 +164,13 @@ int llog_origin_handle_next_block(struct ptlrpc_request *req) void *ptr; int rc; - ENTRY; - body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); if (body == NULL) - RETURN(-EFAULT); + return -EFAULT; ctxt = llog_get_context(req->rq_export->exp_obd, body->lgd_ctxt_idx); if (ctxt == NULL) - RETURN(-ENODEV); + return -ENODEV; disk_obd = ctxt->loc_exp->exp_obd; push_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL); @@ -208,7 +201,6 @@ int llog_origin_handle_next_block(struct ptlrpc_request *req) &repbody->lgd_cur_offset, ptr, LLOG_CHUNK_SIZE); if (rc) GOTO(out_close, rc); - EXIT; out_close: llog_origin_close(req->rq_svc_thread->t_env, loghandle); out_pop: @@ -230,15 +222,13 @@ int llog_origin_handle_prev_block(struct ptlrpc_request *req) void *ptr; int rc; - ENTRY; - body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); if (body == NULL) - RETURN(-EFAULT); + return -EFAULT; ctxt = llog_get_context(req->rq_export->exp_obd, body->lgd_ctxt_idx); if (ctxt == NULL) - RETURN(-ENODEV); + return -ENODEV; disk_obd = ctxt->loc_exp->exp_obd; push_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL); @@ -269,7 +259,6 @@ int llog_origin_handle_prev_block(struct ptlrpc_request *req) if (rc) GOTO(out_close, rc); - EXIT; out_close: llog_origin_close(req->rq_svc_thread->t_env, loghandle); out_pop: @@ -290,15 +279,13 @@ int llog_origin_handle_read_header(struct ptlrpc_request *req) __u32 flags; int rc; - ENTRY; - body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); if (body == NULL) - RETURN(-EFAULT); + return -EFAULT; ctxt = llog_get_context(req->rq_export->exp_obd, body->lgd_ctxt_idx); if (ctxt == NULL) - RETURN(-ENODEV); + return -ENODEV; disk_obd = ctxt->loc_exp->exp_obd; push_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL); @@ -324,7 +311,6 @@ int llog_origin_handle_read_header(struct ptlrpc_request *req) hdr = req_capsule_server_get(&req->rq_pill, &RMF_LLOG_LOG_HDR); *hdr = *loghandle->lgh_hdr; - EXIT; out_close: llog_origin_close(req->rq_svc_thread->t_env, loghandle); out_pop: @@ -336,9 +322,8 @@ EXPORT_SYMBOL(llog_origin_handle_read_header); int llog_origin_handle_close(struct ptlrpc_request *req) { - ENTRY; /* Nothing to do */ - RETURN(0); + return 0; } EXPORT_SYMBOL(llog_origin_handle_close); @@ -352,20 +337,19 @@ int llog_origin_handle_cancel(struct ptlrpc_request *req) struct llog_handle *cathandle; struct inode *inode; void *handle; - ENTRY; logcookies = req_capsule_client_get(&req->rq_pill, &RMF_LOGCOOKIES); num_cookies = req_capsule_get_size(&req->rq_pill, &RMF_LOGCOOKIES, RCL_CLIENT) / sizeof(*logcookies); if (logcookies == NULL || num_cookies == 0) { DEBUG_REQ(D_HA, req, "No llog cookies sent"); - RETURN(-EFAULT); + return -EFAULT; } ctxt = llog_get_context(req->rq_export->exp_obd, logcookies->lgc_subsys); if (ctxt == NULL) - RETURN(-ENODEV); + return -ENODEV; disk_obd = ctxt->loc_exp->exp_obd; push_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL); diff --git a/drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c b/drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c index 3e7325499d01..bea44a3d4a2f 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c +++ b/drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c @@ -302,7 +302,7 @@ ptlrpc_lprocfs_req_history_max_seq_write(struct file *file, const char *buffer, * hose a kernel by allowing the request history to grow too * far. */ bufpages = (svc->srv_buf_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; - if (val > num_physpages/(2 * bufpages)) + if (val > totalram_pages / (2 * bufpages)) return -ERANGE; spin_lock(&svc->srv_lock); @@ -480,7 +480,6 @@ static int ptlrpc_lprocfs_nrs_seq_show(struct seq_file *m, void *n) bool hp = false; int i; int rc = 0; - ENTRY; /** * Serialize NRS core lprocfs operations with policy registration/ @@ -613,7 +612,7 @@ out: mutex_unlock(&nrs_core.nrs_mutex); - RETURN(rc); + return rc; } /** @@ -638,7 +637,6 @@ static ssize_t ptlrpc_lprocfs_nrs_seq_write(struct file *file, const char *buffe char *cmd_copy = NULL; char *token; int rc = 0; - ENTRY; if (count >= LPROCFS_NRS_WR_MAX_CMD) GOTO(out, rc = -EINVAL); @@ -698,7 +696,7 @@ out: if (cmd_copy) OBD_FREE(cmd_copy, LPROCFS_NRS_WR_MAX_CMD); - RETURN(rc < 0 ? rc : count); + return rc < 0 ? rc : count; } LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs); @@ -1217,13 +1215,12 @@ int lprocfs_wr_ping(struct file *file, const char *buffer, struct obd_device *obd = ((struct seq_file *)file->private_data)->private; struct ptlrpc_request *req; int rc; - ENTRY; LPROCFS_CLIMP_CHECK(obd); req = ptlrpc_prep_ping(obd->u.cli.cl_import); LPROCFS_CLIMP_EXIT(obd); if (req == NULL) - RETURN(-ENOMEM); + return -ENOMEM; req->rq_send_state = LUSTRE_IMP_FULL; @@ -1231,8 +1228,8 @@ int lprocfs_wr_ping(struct file *file, const char *buffer, ptlrpc_req_finished(req); if (rc >= 0) - RETURN(count); - RETURN(rc); + return count; + return rc; } EXPORT_SYMBOL(lprocfs_wr_ping); diff --git a/drivers/staging/lustre/lustre/ptlrpc/niobuf.c b/drivers/staging/lustre/lustre/ptlrpc/niobuf.c index de3f0db0ba47..a0e009717a5a 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/niobuf.c +++ b/drivers/staging/lustre/lustre/ptlrpc/niobuf.c @@ -54,7 +54,6 @@ static int ptl_send_buf (lnet_handle_md_t *mdh, void *base, int len, { int rc; lnet_md_t md; - ENTRY; LASSERT (portal != 0); LASSERT (conn != NULL); @@ -76,7 +75,7 @@ static int ptl_send_buf (lnet_handle_md_t *mdh, void *base, int len, if (unlikely(rc != 0)) { CERROR ("LNetMDBind failed: %d\n", rc); LASSERT (rc == -ENOMEM); - RETURN (-ENOMEM); + return -ENOMEM; } CDEBUG(D_NET, "Sending %d bytes to portal %d, xid "LPD64", offset %u\n", @@ -95,7 +94,7 @@ static int ptl_send_buf (lnet_handle_md_t *mdh, void *base, int len, LASSERTF(rc2 == 0, "rc2 = %d\n", rc2); } - RETURN (0); + return 0; } static void mdunlink_iterate_helper(lnet_handle_md_t *bd_mds, int count) @@ -122,10 +121,9 @@ int ptlrpc_register_bulk(struct ptlrpc_request *req) __u64 xid; lnet_handle_me_t me_h; lnet_md_t md; - ENTRY; if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_BULK_GET_NET)) - RETURN(0); + return 0; /* NB no locking required until desc is on the network */ LASSERT(desc->bd_nob > 0); @@ -207,7 +205,7 @@ int ptlrpc_register_bulk(struct ptlrpc_request *req) LASSERT(desc->bd_md_count >= 0); mdunlink_iterate_helper(desc->bd_mds, desc->bd_md_max_brw); req->rq_status = -ENOMEM; - RETURN(-ENOMEM); + return -ENOMEM; } /* Set rq_xid to matchbits of the final bulk so that server can @@ -231,7 +229,7 @@ int ptlrpc_register_bulk(struct ptlrpc_request *req) desc->bd_iov_count, desc->bd_nob, desc->bd_last_xid, req->rq_xid, desc->bd_portal); - RETURN(0); + return 0; } EXPORT_SYMBOL(ptlrpc_register_bulk); @@ -247,7 +245,6 @@ int ptlrpc_unregister_bulk(struct ptlrpc_request *req, int async) wait_queue_head_t *wq; struct l_wait_info lwi; int rc; - ENTRY; LASSERT(!in_interrupt()); /* might sleep */ @@ -257,7 +254,7 @@ int ptlrpc_unregister_bulk(struct ptlrpc_request *req, int async) req->rq_bulk_deadline = cfs_time_current_sec() + LONG_UNLINK; if (ptlrpc_client_bulk_active(req) == 0) /* completed or */ - RETURN(1); /* never registered */ + return 1; /* never registered */ LASSERT(desc->bd_req == req); /* bd_req NULL until registered */ @@ -268,14 +265,14 @@ int ptlrpc_unregister_bulk(struct ptlrpc_request *req, int async) mdunlink_iterate_helper(desc->bd_mds, desc->bd_md_max_brw); if (ptlrpc_client_bulk_active(req) == 0) /* completed or */ - RETURN(1); /* never registered */ + return 1; /* never registered */ /* Move to "Unregistering" phase as bulk was not unlinked yet. */ ptlrpc_rqphase_move(req, RQ_PHASE_UNREGISTERING); /* Do not wait for unlink to finish. */ if (async) - RETURN(0); + return 0; if (req->rq_set != NULL) wq = &req->rq_set->set_waitq; @@ -290,14 +287,14 @@ int ptlrpc_unregister_bulk(struct ptlrpc_request *req, int async) rc = l_wait_event(*wq, !ptlrpc_client_bulk_active(req), &lwi); if (rc == 0) { ptlrpc_rqphase_move(req, req->rq_next_phase); - RETURN(1); + return 1; } LASSERT(rc == -ETIMEDOUT); DEBUG_REQ(D_WARNING, req, "Unexpectedly long timeout: desc %p", desc); } - RETURN(0); + return 0; } EXPORT_SYMBOL(ptlrpc_unregister_bulk); @@ -400,7 +397,8 @@ int ptlrpc_send_reply(struct ptlrpc_request *req, int flags) req->rq_type = PTL_RPC_MSG_REPLY; lustre_msg_set_type(req->rq_repmsg, req->rq_type); - lustre_msg_set_status(req->rq_repmsg, req->rq_status); + lustre_msg_set_status(req->rq_repmsg, + ptlrpc_status_hton(req->rq_status)); lustre_msg_set_opc(req->rq_repmsg, req->rq_reqmsg ? lustre_msg_get_opc(req->rq_reqmsg) : 0); @@ -455,15 +453,14 @@ EXPORT_SYMBOL(ptlrpc_reply); int ptlrpc_send_error(struct ptlrpc_request *req, int may_be_difficult) { int rc; - ENTRY; if (req->rq_no_reply) - RETURN(0); + return 0; if (!req->rq_repmsg) { rc = lustre_pack_reply(req, 1, NULL, NULL); if (rc) - RETURN(rc); + return rc; } if (req->rq_status != -ENOSPC && req->rq_status != -EACCES && @@ -472,7 +469,7 @@ int ptlrpc_send_error(struct ptlrpc_request *req, int may_be_difficult) req->rq_type = PTL_RPC_MSG_ERR; rc = ptlrpc_send_reply(req, may_be_difficult); - RETURN(rc); + return rc; } EXPORT_SYMBOL(ptlrpc_send_error); @@ -497,10 +494,9 @@ int ptl_send_rpc(struct ptlrpc_request *request, int noreply) lnet_handle_me_t reply_me_h; lnet_md_t reply_md; struct obd_device *obd = request->rq_import->imp_obd; - ENTRY; if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_DROP_RPC)) - RETURN(0); + return 0; LASSERT(request->rq_type == PTL_RPC_MSG_REQUEST); LASSERT(request->rq_wait_ctx == 0); @@ -516,7 +512,7 @@ int ptl_send_rpc(struct ptlrpc_request *request, int noreply) /* this prevents us from waiting in ptlrpc_queue_wait */ request->rq_err = 1; request->rq_status = -ENODEV; - RETURN(-ENODEV); + return -ENODEV; } connection = request->rq_import->imp_connection; diff --git a/drivers/staging/lustre/lustre/ptlrpc/nrs.c b/drivers/staging/lustre/lustre/ptlrpc/nrs.c index 1996431e35ff..0abcd6d82273 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/nrs.c +++ b/drivers/staging/lustre/lustre/ptlrpc/nrs.c @@ -81,17 +81,16 @@ static int nrs_policy_ctl_locked(struct ptlrpc_nrs_policy *policy, * policy->pol_private will be NULL in such a case. */ if (policy->pol_state == NRS_POL_STATE_STOPPED) - RETURN(-ENODEV); + return -ENODEV; - RETURN(policy->pol_desc->pd_ops->op_policy_ctl != NULL ? + return policy->pol_desc->pd_ops->op_policy_ctl != NULL ? policy->pol_desc->pd_ops->op_policy_ctl(policy, opc, arg) : - -ENOSYS); + -ENOSYS; } static void nrs_policy_stop0(struct ptlrpc_nrs_policy *policy) { struct ptlrpc_nrs *nrs = policy->pol_nrs; - ENTRY; if (policy->pol_desc->pd_ops->op_policy_stop != NULL) { spin_unlock(&nrs->nrs_lock); @@ -111,24 +110,21 @@ static void nrs_policy_stop0(struct ptlrpc_nrs_policy *policy) if (atomic_dec_and_test(&policy->pol_desc->pd_refs)) module_put(policy->pol_desc->pd_owner); - - EXIT; } static int nrs_policy_stop_locked(struct ptlrpc_nrs_policy *policy) { struct ptlrpc_nrs *nrs = policy->pol_nrs; - ENTRY; if (nrs->nrs_policy_fallback == policy && !nrs->nrs_stopping) - RETURN(-EPERM); + return -EPERM; if (policy->pol_state == NRS_POL_STATE_STARTING) - RETURN(-EAGAIN); + return -EAGAIN; /* In progress or already stopped */ if (policy->pol_state != NRS_POL_STATE_STARTED) - RETURN(0); + return 0; policy->pol_state = NRS_POL_STATE_STOPPING; @@ -145,7 +141,7 @@ static int nrs_policy_stop_locked(struct ptlrpc_nrs_policy *policy) if (policy->pol_ref == 1) nrs_policy_stop0(policy); - RETURN(0); + return 0; } /** @@ -158,15 +154,8 @@ static int nrs_policy_stop_locked(struct ptlrpc_nrs_policy *policy) static void nrs_policy_stop_primary(struct ptlrpc_nrs *nrs) { struct ptlrpc_nrs_policy *tmp = nrs->nrs_policy_primary; - ENTRY; if (tmp == NULL) { - /** - * XXX: This should really be RETURN_EXIT, but the latter does - * not currently print anything out, and possibly should be - * fixed to do so. - */ - EXIT; return; } @@ -177,7 +166,6 @@ static void nrs_policy_stop_primary(struct ptlrpc_nrs *nrs) if (tmp->pol_ref == 0) nrs_policy_stop0(tmp); - EXIT; } /** @@ -203,19 +191,18 @@ static int nrs_policy_start_locked(struct ptlrpc_nrs_policy *policy) { struct ptlrpc_nrs *nrs = policy->pol_nrs; int rc = 0; - ENTRY; /** * Don't allow multiple starting which is too complex, and has no real * benefit. */ if (nrs->nrs_policy_starting) - RETURN(-EAGAIN); + return -EAGAIN; LASSERT(policy->pol_state != NRS_POL_STATE_STARTING); if (policy->pol_state == NRS_POL_STATE_STOPPING) - RETURN(-EAGAIN); + return -EAGAIN; if (policy->pol_flags & PTLRPC_NRS_FL_FALLBACK) { /** @@ -226,7 +213,7 @@ static int nrs_policy_start_locked(struct ptlrpc_nrs_policy *policy) */ if (policy == nrs->nrs_policy_fallback) { nrs_policy_stop_primary(nrs); - RETURN(0); + return 0; } /** @@ -241,10 +228,10 @@ static int nrs_policy_start_locked(struct ptlrpc_nrs_policy *policy) * Shouldn't start primary policy if w/o fallback policy. */ if (nrs->nrs_policy_fallback == NULL) - RETURN(-EPERM); + return -EPERM; if (policy->pol_state == NRS_POL_STATE_STARTED) - RETURN(0); + return 0; } /** @@ -256,7 +243,7 @@ static int nrs_policy_start_locked(struct ptlrpc_nrs_policy *policy) atomic_dec(&policy->pol_desc->pd_refs); CERROR("NRS: cannot get module for policy %s; is it alive?\n", policy->pol_desc->pd_name); - RETURN(-ENODEV); + return -ENODEV; } /** @@ -303,7 +290,7 @@ static int nrs_policy_start_locked(struct ptlrpc_nrs_policy *policy) out: nrs->nrs_policy_starting = 0; - RETURN(rc); + return rc; } /** @@ -644,7 +631,6 @@ static int nrs_policy_ctl(struct ptlrpc_nrs *nrs, char *name, { struct ptlrpc_nrs_policy *policy; int rc = 0; - ENTRY; spin_lock(&nrs->nrs_lock); @@ -674,7 +660,7 @@ out: spin_unlock(&nrs->nrs_lock); - RETURN(rc); + return rc; } /** @@ -690,7 +676,6 @@ out: static int nrs_policy_unregister(struct ptlrpc_nrs *nrs, char *name) { struct ptlrpc_nrs_policy *policy = NULL; - ENTRY; spin_lock(&nrs->nrs_lock); @@ -699,7 +684,7 @@ static int nrs_policy_unregister(struct ptlrpc_nrs *nrs, char *name) spin_unlock(&nrs->nrs_lock); CERROR("Can't find NRS policy %s\n", name); - RETURN(-ENOENT); + return -ENOENT; } if (policy->pol_ref > 1) { @@ -708,7 +693,7 @@ static int nrs_policy_unregister(struct ptlrpc_nrs *nrs, char *name) nrs_policy_put_locked(policy); spin_unlock(&nrs->nrs_lock); - RETURN(-EBUSY); + return -EBUSY; } LASSERT(policy->pol_req_queued == 0); @@ -731,7 +716,7 @@ static int nrs_policy_unregister(struct ptlrpc_nrs *nrs, char *name) LASSERT(policy->pol_private == NULL); OBD_FREE_PTR(policy); - RETURN(0); + return 0; } /** @@ -751,7 +736,6 @@ static int nrs_policy_register(struct ptlrpc_nrs *nrs, struct ptlrpc_nrs_policy *tmp; struct ptlrpc_service_part *svcpt = nrs->nrs_svcpt; int rc; - ENTRY; LASSERT(svcpt != NULL); LASSERT(desc->pd_ops != NULL); @@ -764,7 +748,7 @@ static int nrs_policy_register(struct ptlrpc_nrs *nrs, OBD_CPT_ALLOC_GFP(policy, svcpt->scp_service->srv_cptable, svcpt->scp_cpt, sizeof(*policy), __GFP_IO); if (policy == NULL) - RETURN(-ENOMEM); + return -ENOMEM; policy->pol_nrs = nrs; policy->pol_desc = desc; @@ -777,7 +761,7 @@ static int nrs_policy_register(struct ptlrpc_nrs *nrs, rc = nrs_policy_init(policy); if (rc != 0) { OBD_FREE_PTR(policy); - RETURN(rc); + return rc; } spin_lock(&nrs->nrs_lock); @@ -793,7 +777,7 @@ static int nrs_policy_register(struct ptlrpc_nrs *nrs, nrs_policy_fini(policy); OBD_FREE_PTR(policy); - RETURN(-EEXIST); + return -EEXIST; } list_add_tail(&policy->pol_list, &nrs->nrs_policy_list); @@ -807,7 +791,7 @@ static int nrs_policy_register(struct ptlrpc_nrs *nrs, if (rc != 0) (void) nrs_policy_unregister(nrs, policy->pol_desc->pd_name); - RETURN(rc); + return rc; } /** @@ -844,7 +828,6 @@ static void ptlrpc_nrs_req_add_nolock(struct ptlrpc_request *req) static void ptlrpc_nrs_hpreq_add_nolock(struct ptlrpc_request *req) { int opc = lustre_msg_get_opc(req->rq_reqmsg); - ENTRY; spin_lock(&req->rq_lock); req->rq_hp = 1; @@ -852,7 +835,6 @@ static void ptlrpc_nrs_hpreq_add_nolock(struct ptlrpc_request *req) if (opc != OBD_PING) DEBUG_REQ(D_NET, req, "high priority req"); spin_unlock(&req->rq_lock); - EXIT; } /** @@ -891,7 +873,6 @@ static int nrs_register_policies_locked(struct ptlrpc_nrs *nrs) struct ptlrpc_service_part *svcpt = nrs->nrs_svcpt; struct ptlrpc_service *svc = svcpt->scp_service; int rc = -EINVAL; - ENTRY; LASSERT(mutex_is_locked(&nrs_core.nrs_mutex)); @@ -912,7 +893,7 @@ static int nrs_register_policies_locked(struct ptlrpc_nrs *nrs) } } - RETURN(rc); + return rc; } /** @@ -950,7 +931,7 @@ static int nrs_svcpt_setup_locked0(struct ptlrpc_nrs *nrs, rc = nrs_register_policies_locked(nrs); - RETURN(rc); + return rc; } /** @@ -966,7 +947,6 @@ static int nrs_svcpt_setup_locked(struct ptlrpc_service_part *svcpt) { struct ptlrpc_nrs *nrs; int rc; - ENTRY; LASSERT(mutex_is_locked(&nrs_core.nrs_mutex)); @@ -994,7 +974,7 @@ static int nrs_svcpt_setup_locked(struct ptlrpc_service_part *svcpt) rc = nrs_svcpt_setup_locked0(nrs, svcpt); out: - RETURN(rc); + return rc; } /** @@ -1012,7 +992,6 @@ static void nrs_svcpt_cleanup_locked(struct ptlrpc_service_part *svcpt) struct ptlrpc_nrs_policy *tmp; int rc; bool hp = false; - ENTRY; LASSERT(mutex_is_locked(&nrs_core.nrs_mutex)); @@ -1036,8 +1015,6 @@ again: if (hp) OBD_FREE_PTR(nrs); - - EXIT; } /** @@ -1051,13 +1028,12 @@ again: static struct ptlrpc_nrs_pol_desc *nrs_policy_find_desc_locked(const char *name) { struct ptlrpc_nrs_pol_desc *tmp; - ENTRY; list_for_each_entry(tmp, &nrs_core.nrs_policies, pd_list) { if (strncmp(tmp->pd_name, name, NRS_POL_NAME_MAX) == 0) - RETURN(tmp); + return tmp; } - RETURN(NULL); + return NULL; } /** @@ -1079,7 +1055,6 @@ static int nrs_policy_unregister_locked(struct ptlrpc_nrs_pol_desc *desc) struct ptlrpc_service_part *svcpt; int i; int rc = 0; - ENTRY; LASSERT(mutex_is_locked(&nrs_core.nrs_mutex)); LASSERT(mutex_is_locked(&ptlrpc_all_services_mutex)); @@ -1107,7 +1082,7 @@ again: "partition %d of service %s: %d\n", desc->pd_name, svcpt->scp_cpt, svcpt->scp_service->srv_name, rc); - RETURN(rc); + return rc; } if (!hp && nrs_svc_has_hp(svc)) { @@ -1120,7 +1095,7 @@ again: desc->pd_ops->op_lprocfs_fini(svc); } - RETURN(rc); + return rc; } /** @@ -1143,7 +1118,6 @@ int ptlrpc_nrs_policy_register(struct ptlrpc_nrs_pol_conf *conf) struct ptlrpc_service *svc; struct ptlrpc_nrs_pol_desc *desc; int rc = 0; - ENTRY; LASSERT(conf != NULL); LASSERT(conf->nc_ops != NULL); @@ -1171,7 +1145,7 @@ int ptlrpc_nrs_policy_register(struct ptlrpc_nrs_pol_conf *conf) "policy flags; external policies cannot act as fallback " "policies, or be started immediately upon registration " "without interaction with lprocfs\n", conf->nc_name); - RETURN(-EINVAL); + return -EINVAL; } mutex_lock(&nrs_core.nrs_mutex); @@ -1274,7 +1248,7 @@ internal: fail: mutex_unlock(&nrs_core.nrs_mutex); - RETURN(rc); + return rc; } EXPORT_SYMBOL(ptlrpc_nrs_policy_register); @@ -1296,14 +1270,13 @@ int ptlrpc_nrs_policy_unregister(struct ptlrpc_nrs_pol_conf *conf) { struct ptlrpc_nrs_pol_desc *desc; int rc; - ENTRY; LASSERT(conf != NULL); if (conf->nc_flags & PTLRPC_NRS_FL_FALLBACK) { CERROR("Unable to unregister a fallback policy, unless the " "PTLRPC service is stopping.\n"); - RETURN(-EPERM); + return -EPERM; } conf->nc_name[NRS_POL_NAME_MAX - 1] = '\0'; @@ -1341,7 +1314,7 @@ fail: not_exist: mutex_unlock(&nrs_core.nrs_mutex); - RETURN(rc); + return rc; } EXPORT_SYMBOL(ptlrpc_nrs_policy_unregister); @@ -1396,7 +1369,7 @@ failed: mutex_unlock(&nrs_core.nrs_mutex); - RETURN(rc); + return rc; } /** @@ -1630,7 +1603,6 @@ void ptlrpc_nrs_req_hp_move(struct ptlrpc_request *req) struct ptlrpc_nrs_request *nrq = &req->rq_nrq; struct ptlrpc_nrs_resource *res1[NRS_RES_MAX]; struct ptlrpc_nrs_resource *res2[NRS_RES_MAX]; - ENTRY; /** * Obtain the high-priority NRS head resources. @@ -1660,7 +1632,6 @@ out: * returned false. */ nrs_resource_put_safe(res1); - EXIT; } /** @@ -1696,7 +1667,6 @@ int ptlrpc_nrs_policy_control(const struct ptlrpc_service *svc, struct ptlrpc_service_part *svcpt; int i; int rc = 0; - ENTRY; LASSERT(opc != PTLRPC_NRS_CTL_INVALID); @@ -1728,7 +1698,7 @@ int ptlrpc_nrs_policy_control(const struct ptlrpc_service *svc, } } out: - RETURN(rc); + return rc; } @@ -1745,7 +1715,6 @@ extern struct ptlrpc_nrs_pol_conf nrs_conf_fifo; int ptlrpc_nrs_init(void) { int rc; - ENTRY; mutex_init(&nrs_core.nrs_mutex); INIT_LIST_HEAD(&nrs_core.nrs_policies); @@ -1755,7 +1724,7 @@ int ptlrpc_nrs_init(void) GOTO(fail, rc); - RETURN(rc); + return rc; fail: /** * Since no PTLRPC services have been started at this point, all we need @@ -1763,7 +1732,7 @@ fail: */ ptlrpc_nrs_fini(); - RETURN(rc); + return rc; } /** diff --git a/drivers/staging/lustre/lustre/ptlrpc/pack_generic.c b/drivers/staging/lustre/lustre/ptlrpc/pack_generic.c index 1437636dfe28..cd2611a3b53d 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/pack_generic.c +++ b/drivers/staging/lustre/lustre/ptlrpc/pack_generic.c @@ -115,7 +115,7 @@ int lustre_msg_check_version(struct lustre_msg *msg, __u32 version) EXPORT_SYMBOL(lustre_msg_check_version); /* early reply size */ -int lustre_msg_early_size() +int lustre_msg_early_size(void) { static int size = 0; if (!size) { @@ -329,7 +329,6 @@ int lustre_pack_reply_v2(struct ptlrpc_request *req, int count, { struct ptlrpc_reply_state *rs; int msg_len, rc; - ENTRY; LASSERT(req->rq_reply_state == NULL); @@ -342,7 +341,7 @@ int lustre_pack_reply_v2(struct ptlrpc_request *req, int count, msg_len = lustre_msg_size_v2(count, lens); rc = sptlrpc_svc_alloc_rs(req, msg_len); if (rc) - RETURN(rc); + return rc; rs = req->rq_reply_state; atomic_set(&rs->rs_refcount, 1); /* 1 ref for rq_reply_state */ @@ -363,7 +362,7 @@ int lustre_pack_reply_v2(struct ptlrpc_request *req, int count, PTLRPC_RS_DEBUG_LRU_ADD(rs); - RETURN(0); + return 0; } EXPORT_SYMBOL(lustre_pack_reply_v2); @@ -574,7 +573,6 @@ static int lustre_unpack_msg_v2(struct lustre_msg_v2 *m, int len) int __lustre_unpack_msg(struct lustre_msg *m, int len) { int required_len, rc; - ENTRY; /* We can provide a slightly better error log, if we check the * message magic and version first. In the future, struct @@ -588,12 +586,12 @@ int __lustre_unpack_msg(struct lustre_msg *m, int len) /* can't even look inside the message */ CERROR("message length %d too small for magic/version check\n", len); - RETURN(-EINVAL); + return -EINVAL; } rc = lustre_unpack_msg_v2(m, len); - RETURN(rc); + return rc; } EXPORT_SYMBOL(__lustre_unpack_msg); @@ -642,6 +640,9 @@ static inline int lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request *req, return -EINVAL; } + if (!inout) + pb->pb_status = ptlrpc_status_ntoh(pb->pb_status); + return 0; } @@ -1613,11 +1614,10 @@ int do_set_info_async(struct obd_import *imp, struct ptlrpc_request *req; char *tmp; int rc; - ENTRY; req = ptlrpc_request_alloc(imp, &RQF_OBD_SET_INFO); if (req == NULL) - RETURN(-ENOMEM); + return -ENOMEM; req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY, RCL_CLIENT, keylen); @@ -1626,7 +1626,7 @@ int do_set_info_async(struct obd_import *imp, rc = ptlrpc_request_pack(req, version, opcode); if (rc) { ptlrpc_request_free(req); - RETURN(rc); + return rc; } tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY); @@ -1644,7 +1644,7 @@ int do_set_info_async(struct obd_import *imp, ptlrpc_req_finished(req); } - RETURN(rc); + return rc; } EXPORT_SYMBOL(do_set_info_async); @@ -2163,7 +2163,6 @@ static void lustre_swab_lmm_oi(struct ost_id *oi) static void lustre_swab_lov_user_md_common(struct lov_user_md_v1 *lum) { - ENTRY; __swab32s(&lum->lmm_magic); __swab32s(&lum->lmm_pattern); lustre_swab_lmm_oi(&lum->lmm_oi); @@ -2171,31 +2170,25 @@ static void lustre_swab_lov_user_md_common(struct lov_user_md_v1 *lum) __swab16s(&lum->lmm_stripe_count); __swab16s(&lum->lmm_stripe_offset); print_lum(lum); - EXIT; } void lustre_swab_lov_user_md_v1(struct lov_user_md_v1 *lum) { - ENTRY; CDEBUG(D_IOCTL, "swabbing lov_user_md v1\n"); lustre_swab_lov_user_md_common(lum); - EXIT; } EXPORT_SYMBOL(lustre_swab_lov_user_md_v1); void lustre_swab_lov_user_md_v3(struct lov_user_md_v3 *lum) { - ENTRY; CDEBUG(D_IOCTL, "swabbing lov_user_md v3\n"); lustre_swab_lov_user_md_common((struct lov_user_md_v1 *)lum); /* lmm_pool_name nothing to do with char */ - EXIT; } EXPORT_SYMBOL(lustre_swab_lov_user_md_v3); void lustre_swab_lov_mds_md(struct lov_mds_md *lmm) { - ENTRY; CDEBUG(D_IOCTL, "swabbing lov_mds_md\n"); __swab32s(&lmm->lmm_magic); __swab32s(&lmm->lmm_pattern); @@ -2203,7 +2196,6 @@ void lustre_swab_lov_mds_md(struct lov_mds_md *lmm) __swab32s(&lmm->lmm_stripe_size); __swab16s(&lmm->lmm_stripe_count); __swab16s(&lmm->lmm_layout_gen); - EXIT; } EXPORT_SYMBOL(lustre_swab_lov_mds_md); @@ -2211,13 +2203,12 @@ void lustre_swab_lov_user_md_objects(struct lov_user_ost_data *lod, int stripe_count) { int i; - ENTRY; + for (i = 0; i < stripe_count; i++) { lustre_swab_ost_id(&(lod[i].l_ost_oi)); __swab32s(&(lod[i].l_ost_gen)); __swab32s(&(lod[i].l_ost_idx)); } - EXIT; } EXPORT_SYMBOL(lustre_swab_lov_user_md_objects); @@ -2459,6 +2450,7 @@ void _debug_req(struct ptlrpc_request *req, rep_ok ? lustre_msg_get_flags(req->rq_repmsg) : -1, req->rq_status, rep_ok ? lustre_msg_get_status(req->rq_repmsg) : -1); + va_end(args); } EXPORT_SYMBOL(_debug_req); diff --git a/drivers/staging/lustre/lustre/ptlrpc/pinger.c b/drivers/staging/lustre/lustre/ptlrpc/pinger.c index ef5269aee0de..5dec771d70ee 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/pinger.c +++ b/drivers/staging/lustre/lustre/ptlrpc/pinger.c @@ -51,7 +51,7 @@ struct mutex pinger_mutex; static LIST_HEAD(pinger_imports); static struct list_head timeout_list = LIST_HEAD_INIT(timeout_list); -int ptlrpc_pinger_suppress_pings() +int ptlrpc_pinger_suppress_pings(void) { return suppress_pings; } @@ -75,11 +75,10 @@ int ptlrpc_obd_ping(struct obd_device *obd) { int rc; struct ptlrpc_request *req; - ENTRY; req = ptlrpc_prep_ping(obd->u.cli.cl_import); if (req == NULL) - RETURN(-ENOMEM); + return -ENOMEM; req->rq_send_state = LUSTRE_IMP_FULL; @@ -87,28 +86,27 @@ int ptlrpc_obd_ping(struct obd_device *obd) ptlrpc_req_finished(req); - RETURN(rc); + return rc; } EXPORT_SYMBOL(ptlrpc_obd_ping); int ptlrpc_ping(struct obd_import *imp) { struct ptlrpc_request *req; - ENTRY; req = ptlrpc_prep_ping(imp); if (req == NULL) { CERROR("OOM trying to ping %s->%s\n", imp->imp_obd->obd_uuid.uuid, obd2cli_tgt(imp->imp_obd)); - RETURN(-ENOMEM); + return -ENOMEM; } DEBUG_REQ(D_INFO, req, "pinging %s->%s", imp->imp_obd->obd_uuid.uuid, obd2cli_tgt(imp->imp_obd)); ptlrpcd_add_req(req, PDL_POLICY_ROUND, -1); - RETURN(0); + return 0; } void ptlrpc_update_next_ping(struct obd_import *imp, int soon) @@ -297,7 +295,6 @@ static void ptlrpc_pinger_process_import(struct obd_import *imp, static int ptlrpc_pinger_main(void *arg) { struct ptlrpc_thread *thread = (struct ptlrpc_thread *)arg; - ENTRY; /* Record that the thread is running */ thread_set_flags(thread, SVC_RUNNING); @@ -353,7 +350,6 @@ static int ptlrpc_pinger_main(void *arg) thread_is_event(thread), &lwi); if (thread_test_and_clear_flags(thread, SVC_STOPPING)) { - EXIT; break; } else { /* woken after adding import to reset timer */ @@ -369,37 +365,32 @@ static int ptlrpc_pinger_main(void *arg) return 0; } -static struct ptlrpc_thread *pinger_thread = NULL; +static struct ptlrpc_thread pinger_thread; int ptlrpc_start_pinger(void) { struct l_wait_info lwi = { 0 }; int rc; - ENTRY; - if (pinger_thread != NULL) - RETURN(-EALREADY); + if (!thread_is_init(&pinger_thread) && + !thread_is_stopped(&pinger_thread)) + return -EALREADY; - OBD_ALLOC_PTR(pinger_thread); - if (pinger_thread == NULL) - RETURN(-ENOMEM); - init_waitqueue_head(&pinger_thread->t_ctl_waitq); + init_waitqueue_head(&pinger_thread.t_ctl_waitq); init_waitqueue_head(&suspend_timeouts_waitq); - strcpy(pinger_thread->t_name, "ll_ping"); + strcpy(pinger_thread.t_name, "ll_ping"); /* CLONE_VM and CLONE_FILES just avoid a needless copy, because we * just drop the VM and FILES in cfs_daemonize_ctxt() right away. */ - rc = PTR_ERR(kthread_run(ptlrpc_pinger_main, - pinger_thread, pinger_thread->t_name)); + rc = PTR_ERR(kthread_run(ptlrpc_pinger_main, &pinger_thread, + "%s", pinger_thread.t_name)); if (IS_ERR_VALUE(rc)) { CERROR("cannot start thread: %d\n", rc); - OBD_FREE(pinger_thread, sizeof(*pinger_thread)); - pinger_thread = NULL; - RETURN(rc); + return rc; } - l_wait_event(pinger_thread->t_ctl_waitq, - thread_is_running(pinger_thread), &lwi); + l_wait_event(pinger_thread.t_ctl_waitq, + thread_is_running(&pinger_thread), &lwi); if (suppress_pings) CWARN("Pings will be suppressed at the request of the " @@ -408,7 +399,7 @@ int ptlrpc_start_pinger(void) "(Search for the \"suppress_pings\" kernel module " "parameter.)\n"); - RETURN(0); + return 0; } int ptlrpc_pinger_remove_timeouts(void); @@ -417,23 +408,19 @@ int ptlrpc_stop_pinger(void) { struct l_wait_info lwi = { 0 }; int rc = 0; - ENTRY; - if (pinger_thread == NULL) - RETURN(-EALREADY); + if (!thread_is_init(&pinger_thread) && + !thread_is_stopped(&pinger_thread)) + return -EALREADY; ptlrpc_pinger_remove_timeouts(); - mutex_lock(&pinger_mutex); - thread_set_flags(pinger_thread, SVC_STOPPING); - wake_up(&pinger_thread->t_ctl_waitq); - mutex_unlock(&pinger_mutex); + thread_set_flags(&pinger_thread, SVC_STOPPING); + wake_up(&pinger_thread.t_ctl_waitq); - l_wait_event(pinger_thread->t_ctl_waitq, - thread_is_stopped(pinger_thread), &lwi); + l_wait_event(pinger_thread.t_ctl_waitq, + thread_is_stopped(&pinger_thread), &lwi); - OBD_FREE_PTR(pinger_thread); - pinger_thread = NULL; - RETURN(rc); + return rc; } void ptlrpc_pinger_sending_on_import(struct obd_import *imp) @@ -459,9 +446,8 @@ void ptlrpc_pinger_commit_expected(struct obd_import *imp) int ptlrpc_pinger_add_import(struct obd_import *imp) { - ENTRY; if (!list_empty(&imp->imp_pinger_chain)) - RETURN(-EALREADY); + return -EALREADY; mutex_lock(&pinger_mutex); CDEBUG(D_HA, "adding pingable import %s->%s\n", @@ -476,15 +462,14 @@ int ptlrpc_pinger_add_import(struct obd_import *imp) ptlrpc_pinger_wake_up(); mutex_unlock(&pinger_mutex); - RETURN(0); + return 0; } EXPORT_SYMBOL(ptlrpc_pinger_add_import); int ptlrpc_pinger_del_import(struct obd_import *imp) { - ENTRY; if (list_empty(&imp->imp_pinger_chain)) - RETURN(-ENOENT); + return -ENOENT; mutex_lock(&pinger_mutex); list_del_init(&imp->imp_pinger_chain); @@ -494,7 +479,7 @@ int ptlrpc_pinger_del_import(struct obd_import *imp) imp->imp_obd->obd_no_recov = 1; class_import_put(imp); mutex_unlock(&pinger_mutex); - RETURN(0); + return 0; } EXPORT_SYMBOL(ptlrpc_pinger_del_import); @@ -615,10 +600,10 @@ int ptlrpc_pinger_remove_timeouts(void) return 0; } -void ptlrpc_pinger_wake_up() +void ptlrpc_pinger_wake_up(void) { - thread_add_flags(pinger_thread, SVC_EVENT); - wake_up(&pinger_thread->t_ctl_waitq); + thread_add_flags(&pinger_thread, SVC_EVENT); + wake_up(&pinger_thread.t_ctl_waitq); } /* Ping evictor thread */ @@ -659,7 +644,6 @@ static int ping_evictor_main(void *arg) struct obd_export *exp; struct l_wait_info lwi = { 0 }; time_t expire_time; - ENTRY; unshare_fs_struct(); @@ -731,12 +715,12 @@ static int ping_evictor_main(void *arg) } CDEBUG(D_HA, "Exiting Ping Evictor\n"); - RETURN(0); + return 0; } void ping_evictor_start(void) { - task_t *task; + struct task_struct *task; if (++pet_refcount > 1) return; diff --git a/drivers/staging/lustre/lustre/ptlrpc/ptlrpc_module.c b/drivers/staging/lustre/lustre/ptlrpc/ptlrpc_module.c index f6ea80f0b105..419e634854df 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/ptlrpc_module.c +++ b/drivers/staging/lustre/lustre/ptlrpc/ptlrpc_module.c @@ -54,7 +54,6 @@ extern struct mutex ptlrpcd_mutex; __init int ptlrpc_init(void) { int rc, cleanup_phase = 0; - ENTRY; lustre_assert_wire_constants(); #if RS_DEBUG @@ -67,11 +66,11 @@ __init int ptlrpc_init(void) rc = req_layout_init(); if (rc) - RETURN(rc); + return rc; rc = ptlrpc_hr_init(); if (rc) - RETURN(rc); + return rc; cleanup_phase = 1; @@ -110,7 +109,7 @@ __init int ptlrpc_init(void) rc = tgt_mod_init(); if (rc) GOTO(cleanup, rc); - RETURN(0); + return 0; cleanup: switch(cleanup_phase) { @@ -150,5 +149,7 @@ static void __exit ptlrpc_exit(void) MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>"); MODULE_DESCRIPTION("Lustre Request Processor and Lock Management"); MODULE_LICENSE("GPL"); +MODULE_VERSION("1.0.0"); -cfs_module(ptlrpc, "1.0.0", ptlrpc_init, ptlrpc_exit); +module_init(ptlrpc_init); +module_exit(ptlrpc_exit); diff --git a/drivers/staging/lustre/lustre/ptlrpc/ptlrpcd.c b/drivers/staging/lustre/lustre/ptlrpc/ptlrpcd.c index 5a66a1be4228..89c9be96f454 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/ptlrpcd.c +++ b/drivers/staging/lustre/lustre/ptlrpc/ptlrpcd.c @@ -268,7 +268,6 @@ static int ptlrpcd_check(struct lu_env *env, struct ptlrpcd_ctl *pc) struct ptlrpc_request_set *set = pc->pc_set; int rc = 0; int rc2; - ENTRY; if (atomic_read(&set->set_new_count)) { spin_lock(&set->set_new_req_lock); @@ -302,7 +301,7 @@ static int ptlrpcd_check(struct lu_env *env, struct ptlrpcd_ctl *pc) * new modules are loaded, i.e., early during boot up. */ CERROR("Failure to refill session: %d\n", rc2); - RETURN(rc); + return rc; } if (atomic_read(&set->set_remaining)) @@ -368,7 +367,7 @@ static int ptlrpcd_check(struct lu_env *env, struct ptlrpcd_ctl *pc) } } - RETURN(rc); + return rc; } /** @@ -383,7 +382,6 @@ static int ptlrpcd(void *arg) struct ptlrpc_request_set *set = pc->pc_set; struct lu_env env = { .le_ses = NULL }; int rc, exit = 0; - ENTRY; unshare_fs_struct(); #if defined(CONFIG_SMP) @@ -410,7 +408,7 @@ static int ptlrpcd(void *arg) complete(&pc->pc_starting); if (rc != 0) - RETURN(rc); + return rc; /* * This mainloop strongly resembles ptlrpc_set_wait() except that our @@ -501,7 +499,6 @@ static int ptlrpcd_bind(int index, int max) #if defined(CONFIG_NUMA) cpumask_t mask; #endif - ENTRY; LASSERT(index <= max - 1); pc = &ptlrpcds->pd_threads[index]; @@ -596,7 +593,7 @@ static int ptlrpcd_bind(int index, int max) } } - RETURN(rc); + return rc; } @@ -604,7 +601,6 @@ int ptlrpcd_start(int index, int max, const char *name, struct ptlrpcd_ctl *pc) { int rc; int env = 0; - ENTRY; /* * Do not allow start second thread for one pc. @@ -612,14 +608,14 @@ int ptlrpcd_start(int index, int max, const char *name, struct ptlrpcd_ctl *pc) if (test_and_set_bit(LIOD_START, &pc->pc_flags)) { CWARN("Starting second thread (%s) for same pc %p\n", name, pc); - RETURN(0); + return 0; } pc->pc_index = index; init_completion(&pc->pc_starting); init_completion(&pc->pc_finishing); spin_lock_init(&pc->pc_lock); - strncpy(pc->pc_name, name, sizeof(pc->pc_name) - 1); + strlcpy(pc->pc_name, name, sizeof(pc->pc_name)); pc->pc_set = ptlrpc_prep_set(); if (pc->pc_set == NULL) GOTO(out, rc = -ENOMEM); @@ -634,14 +630,15 @@ int ptlrpcd_start(int index, int max, const char *name, struct ptlrpcd_ctl *pc) env = 1; { - task_t *task; + struct task_struct *task; + if (index >= 0) { rc = ptlrpcd_bind(index, max); if (rc < 0) GOTO(out, rc); } - task = kthread_run(ptlrpcd, pc, pc->pc_name); + task = kthread_run(ptlrpcd, pc, "%s", pc->pc_name); if (IS_ERR(task)) GOTO(out, rc = PTR_ERR(task)); @@ -663,31 +660,25 @@ out: clear_bit(LIOD_BIND, &pc->pc_flags); clear_bit(LIOD_START, &pc->pc_flags); } - RETURN(rc); + return rc; } void ptlrpcd_stop(struct ptlrpcd_ctl *pc, int force) { - ENTRY; - if (!test_bit(LIOD_START, &pc->pc_flags)) { CWARN("Thread for pc %p was not started\n", pc); - goto out; + return; } set_bit(LIOD_STOP, &pc->pc_flags); if (force) set_bit(LIOD_FORCE, &pc->pc_flags); wake_up(&pc->pc_set->set_waitq); - -out: - EXIT; } void ptlrpcd_free(struct ptlrpcd_ctl *pc) { struct ptlrpc_request_set *set = pc->pc_set; - ENTRY; if (!test_bit(LIOD_START, &pc->pc_flags)) { CWARN("Thread for pc %p was not started\n", pc); @@ -716,13 +707,11 @@ out: pc->pc_partners = NULL; } pc->pc_npartners = 0; - EXIT; } static void ptlrpcd_fini(void) { int i; - ENTRY; if (ptlrpcds != NULL) { for (i = 0; i < ptlrpcds->pd_nthreads; i++) @@ -734,8 +723,6 @@ static void ptlrpcd_fini(void) OBD_FREE(ptlrpcds, ptlrpcds->pd_size); ptlrpcds = NULL; } - - EXIT; } static int ptlrpcd_init(void) @@ -743,7 +730,6 @@ static int ptlrpcd_init(void) int nthreads = num_online_cpus(); char name[16]; int size, i = -1, j, rc = 0; - ENTRY; if (max_ptlrpcds > 0 && max_ptlrpcds < nthreads) nthreads = max_ptlrpcds; @@ -759,7 +745,7 @@ static int ptlrpcd_init(void) if (ptlrpcds == NULL) GOTO(out, rc = -ENOMEM); - snprintf(name, 15, "ptlrpcd_rcv"); + snprintf(name, sizeof(name), "ptlrpcd_rcv"); set_bit(LIOD_RECOVERY, &ptlrpcds->pd_thread_rcv.pc_flags); rc = ptlrpcd_start(-1, nthreads, name, &ptlrpcds->pd_thread_rcv); if (rc < 0) @@ -778,7 +764,7 @@ static int ptlrpcd_init(void) * unnecessary dependency. But how to distribute async RPCs load * among all the ptlrpc daemons becomes another trouble. */ for (i = 0; i < nthreads; i++) { - snprintf(name, 15, "ptlrpcd_%d", i); + snprintf(name, sizeof(name), "ptlrpcd_%d", i); rc = ptlrpcd_start(i, nthreads, name, &ptlrpcds->pd_threads[i]); if (rc < 0) GOTO(out, rc); @@ -800,19 +786,18 @@ out: ptlrpcds = NULL; } - RETURN(0); + return 0; } int ptlrpcd_addref(void) { int rc = 0; - ENTRY; mutex_lock(&ptlrpcd_mutex); if (++ptlrpcd_users == 1) rc = ptlrpcd_init(); mutex_unlock(&ptlrpcd_mutex); - RETURN(rc); + return rc; } EXPORT_SYMBOL(ptlrpcd_addref); diff --git a/drivers/staging/lustre/lustre/ptlrpc/recover.c b/drivers/staging/lustre/lustre/ptlrpc/recover.c index 2960889834a2..84c39e083ea4 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/recover.c +++ b/drivers/staging/lustre/lustre/ptlrpc/recover.c @@ -60,12 +60,8 @@ */ void ptlrpc_initiate_recovery(struct obd_import *imp) { - ENTRY; - CDEBUG(D_HA, "%s: starting recovery\n", obd2cli_tgt(imp->imp_obd)); ptlrpc_connect_import(imp); - - EXIT; } /** @@ -78,7 +74,6 @@ int ptlrpc_replay_next(struct obd_import *imp, int *inflight) struct list_head *tmp, *pos; struct ptlrpc_request *req = NULL; __u64 last_transno; - ENTRY; *inflight = 0; @@ -137,11 +132,11 @@ int ptlrpc_replay_next(struct obd_import *imp, int *inflight) if (rc) { CERROR("recovery replay error %d for req " LPU64"\n", rc, req->rq_xid); - RETURN(rc); + return rc; } *inflight = 1; } - RETURN(rc); + return rc; } /** @@ -152,8 +147,6 @@ int ptlrpc_resend(struct obd_import *imp) { struct ptlrpc_request *req, *next; - ENTRY; - /* As long as we're in recovery, nothing should be added to the sending * list, so we don't need to hold the lock during this iteration and * resend process. @@ -163,7 +156,7 @@ int ptlrpc_resend(struct obd_import *imp) spin_lock(&imp->imp_lock); if (imp->imp_state != LUSTRE_IMP_RECOVER) { spin_unlock(&imp->imp_lock); - RETURN(-1); + return -1; } list_for_each_entry_safe(req, next, &imp->imp_sending_list, @@ -176,7 +169,7 @@ int ptlrpc_resend(struct obd_import *imp) } spin_unlock(&imp->imp_lock); - RETURN(0); + return 0; } EXPORT_SYMBOL(ptlrpc_resend); @@ -203,7 +196,6 @@ EXPORT_SYMBOL(ptlrpc_wake_delayed); void ptlrpc_request_handle_notconn(struct ptlrpc_request *failed_req) { struct obd_import *imp = failed_req->rq_import; - ENTRY; CDEBUG(D_HA, "import %s of %s@%s abruptly disconnected: reconnecting\n", imp->imp_obd->obd_name, obd2cli_tgt(imp->imp_obd), @@ -230,8 +222,6 @@ void ptlrpc_request_handle_notconn(struct ptlrpc_request *failed_req) if (!failed_req->rq_no_resend) failed_req->rq_resend = 1; spin_unlock(&failed_req->rq_lock); - - EXIT; } /** @@ -246,7 +236,6 @@ int ptlrpc_set_import_active(struct obd_import *imp, int active) struct obd_device *obd = imp->imp_obd; int rc = 0; - ENTRY; LASSERT(obd); /* When deactivating, mark import invalid, and abort in-flight @@ -279,7 +268,7 @@ int ptlrpc_set_import_active(struct obd_import *imp, int active) rc = ptlrpc_recover_import(imp, NULL, 0); } - RETURN(rc); + return rc; } EXPORT_SYMBOL(ptlrpc_set_import_active); @@ -287,7 +276,6 @@ EXPORT_SYMBOL(ptlrpc_set_import_active); int ptlrpc_recover_import(struct obd_import *imp, char *new_uuid, int async) { int rc = 0; - ENTRY; spin_lock(&imp->imp_lock); if (imp->imp_state == LUSTRE_IMP_NEW || imp->imp_deactive || @@ -337,7 +325,6 @@ int ptlrpc_recover_import(struct obd_import *imp, char *new_uuid, int async) CDEBUG(D_HA, "%s: recovery finished\n", obd2cli_tgt(imp->imp_obd)); } - EXIT; out: return rc; diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec.c b/drivers/staging/lustre/lustre/ptlrpc/sec.c index 36e8bed5458a..962b31d163de 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/sec.c +++ b/drivers/staging/lustre/lustre/ptlrpc/sec.c @@ -269,8 +269,8 @@ struct ptlrpc_cli_ctx *get_my_ctx(struct ptlrpc_sec *sec) remove_dead = 0; } } else { - vcred.vc_uid = current_uid(); - vcred.vc_gid = current_gid(); + vcred.vc_uid = from_kuid(&init_user_ns, current_uid()); + vcred.vc_gid = from_kgid(&init_user_ns, current_gid()); } return sec->ps_policy->sp_cops->lookup_ctx(sec, &vcred, @@ -396,14 +396,13 @@ int sptlrpc_req_get_ctx(struct ptlrpc_request *req) struct obd_import *imp = req->rq_import; struct ptlrpc_sec *sec; int rc; - ENTRY; LASSERT(!req->rq_cli_ctx); LASSERT(imp); rc = import_sec_validate_get(imp, &sec); if (rc) - RETURN(rc); + return rc; req->rq_cli_ctx = get_my_ctx(sec); @@ -411,10 +410,10 @@ int sptlrpc_req_get_ctx(struct ptlrpc_request *req) if (!req->rq_cli_ctx) { CERROR("req %p: fail to get context\n", req); - RETURN(-ENOMEM); + return -ENOMEM; } - RETURN(0); + return 0; } /** @@ -428,8 +427,6 @@ int sptlrpc_req_get_ctx(struct ptlrpc_request *req) */ void sptlrpc_req_put_ctx(struct ptlrpc_request *req, int sync) { - ENTRY; - LASSERT(req); LASSERT(req->rq_cli_ctx); @@ -444,7 +441,6 @@ void sptlrpc_req_put_ctx(struct ptlrpc_request *req, int sync) sptlrpc_cli_ctx_put(req->rq_cli_ctx, sync); req->rq_cli_ctx = NULL; - EXIT; } static @@ -520,7 +516,6 @@ int sptlrpc_req_replace_dead_ctx(struct ptlrpc_request *req) struct ptlrpc_cli_ctx *oldctx = req->rq_cli_ctx; struct ptlrpc_cli_ctx *newctx; int rc; - ENTRY; LASSERT(oldctx); @@ -533,7 +528,7 @@ int sptlrpc_req_replace_dead_ctx(struct ptlrpc_request *req) /* restore old ctx */ req->rq_cli_ctx = oldctx; - RETURN(rc); + return rc; } newctx = req->rq_cli_ctx; @@ -560,14 +555,14 @@ int sptlrpc_req_replace_dead_ctx(struct ptlrpc_request *req) /* restore old ctx */ sptlrpc_req_put_ctx(req, 0); req->rq_cli_ctx = oldctx; - RETURN(rc); + return rc; } LASSERT(req->rq_cli_ctx == newctx); } sptlrpc_cli_ctx_put(oldctx, 1); - RETURN(0); + return 0; } EXPORT_SYMBOL(sptlrpc_req_replace_dead_ctx); @@ -639,12 +634,11 @@ int sptlrpc_req_refresh_ctx(struct ptlrpc_request *req, long timeout) struct ptlrpc_sec *sec; struct l_wait_info lwi; int rc; - ENTRY; LASSERT(ctx); if (req->rq_ctx_init || req->rq_ctx_fini) - RETURN(0); + return 0; /* * during the process a request's context might change type even @@ -654,7 +648,7 @@ int sptlrpc_req_refresh_ctx(struct ptlrpc_request *req, long timeout) again: rc = import_sec_validate_get(req->rq_import, &sec); if (rc) - RETURN(rc); + return rc; if (sec->ps_flvr.sf_rpc != req->rq_flvr.sf_rpc) { CDEBUG(D_SEC, "req %p: flavor has changed %x -> %x\n", @@ -666,7 +660,7 @@ again: sptlrpc_sec_put(sec); if (cli_ctx_is_eternal(ctx)) - RETURN(0); + return 0; if (unlikely(test_bit(PTLRPC_CTX_NEW_BIT, &ctx->cc_flags))) { LASSERT(ctx->cc_ops->refresh); @@ -677,7 +671,7 @@ again: LASSERT(ctx->cc_ops->validate); if (ctx->cc_ops->validate(ctx) == 0) { req_off_ctx_list(req, ctx); - RETURN(0); + return 0; } if (unlikely(test_bit(PTLRPC_CTX_ERROR_BIT, &ctx->cc_flags))) { @@ -685,7 +679,7 @@ again: req->rq_err = 1; spin_unlock(&req->rq_lock); req_off_ctx_list(req, ctx); - RETURN(-EPERM); + return -EPERM; } /* @@ -719,7 +713,7 @@ again: unlikely(req->rq_reqmsg) && lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT) { req_off_ctx_list(req, ctx); - RETURN(0); + return 0; } if (unlikely(test_bit(PTLRPC_CTX_DEAD_BIT, &ctx->cc_flags))) { @@ -731,7 +725,7 @@ again: spin_lock(&req->rq_lock); req->rq_err = 1; spin_unlock(&req->rq_lock); - RETURN(-EINTR); + return -EINTR; } rc = sptlrpc_req_replace_dead_ctx(req); @@ -742,7 +736,7 @@ again: spin_lock(&req->rq_lock); req->rq_err = 1; spin_unlock(&req->rq_lock); - RETURN(rc); + return rc; } ctx = req->rq_cli_ctx; @@ -759,7 +753,7 @@ again: spin_unlock(&ctx->cc_lock); if (timeout < 0) - RETURN(-EWOULDBLOCK); + return -EWOULDBLOCK; /* Clear any flags that may be present from previous sends */ LASSERT(req->rq_receiving_reply == 0); @@ -789,7 +783,7 @@ again: req_off_ctx_list(req, ctx); LASSERT(rc != 0); - RETURN(rc); + return rc; } goto again; @@ -889,7 +883,6 @@ int sptlrpc_import_check_ctx(struct obd_import *imp) struct ptlrpc_cli_ctx *ctx; struct ptlrpc_request *req = NULL; int rc; - ENTRY; might_sleep(); @@ -898,22 +891,22 @@ int sptlrpc_import_check_ctx(struct obd_import *imp) sptlrpc_sec_put(sec); if (!ctx) - RETURN(-ENOMEM); + return -ENOMEM; if (cli_ctx_is_eternal(ctx) || ctx->cc_ops->validate(ctx) == 0) { sptlrpc_cli_ctx_put(ctx, 1); - RETURN(0); + return 0; } if (cli_ctx_is_error(ctx)) { sptlrpc_cli_ctx_put(ctx, 1); - RETURN(-EACCES); + return -EACCES; } OBD_ALLOC_PTR(req); if (!req) - RETURN(-ENOMEM); + return -ENOMEM; spin_lock_init(&req->rq_lock); atomic_set(&req->rq_refcount, 10000); @@ -929,7 +922,7 @@ int sptlrpc_import_check_ctx(struct obd_import *imp) sptlrpc_cli_ctx_put(req->rq_cli_ctx, 1); OBD_FREE_PTR(req); - RETURN(rc); + return rc; } /** @@ -941,7 +934,6 @@ int sptlrpc_cli_wrap_request(struct ptlrpc_request *req) { struct ptlrpc_cli_ctx *ctx = req->rq_cli_ctx; int rc = 0; - ENTRY; LASSERT(ctx); LASSERT(ctx->cc_sec); @@ -953,7 +945,7 @@ int sptlrpc_cli_wrap_request(struct ptlrpc_request *req) if (req->rq_bulk) { rc = sptlrpc_cli_wrap_bulk(req, req->rq_bulk); if (rc) - RETURN(rc); + return rc; } switch (SPTLRPC_FLVR_SVC(req->rq_flvr.sf_rpc)) { @@ -977,14 +969,13 @@ int sptlrpc_cli_wrap_request(struct ptlrpc_request *req) LASSERT(req->rq_reqdata_len <= req->rq_reqbuf_len); } - RETURN(rc); + return rc; } static int do_cli_unwrap_reply(struct ptlrpc_request *req) { struct ptlrpc_cli_ctx *ctx = req->rq_cli_ctx; int rc; - ENTRY; LASSERT(ctx); LASSERT(ctx->cc_sec); @@ -1002,13 +993,13 @@ static int do_cli_unwrap_reply(struct ptlrpc_request *req) break; default: CERROR("failed unpack reply: x"LPU64"\n", req->rq_xid); - RETURN(-EPROTO); + return -EPROTO; } if (req->rq_repdata_len < sizeof(struct lustre_msg)) { CERROR("replied data length %d too small\n", req->rq_repdata_len); - RETURN(-EPROTO); + return -EPROTO; } if (SPTLRPC_FLVR_POLICY(req->rq_repdata->lm_secflvr) != @@ -1016,7 +1007,7 @@ static int do_cli_unwrap_reply(struct ptlrpc_request *req) CERROR("reply policy %u doesn't match request policy %u\n", SPTLRPC_FLVR_POLICY(req->rq_repdata->lm_secflvr), SPTLRPC_FLVR_POLICY(req->rq_flvr.sf_rpc)); - RETURN(-EPROTO); + return -EPROTO; } switch (SPTLRPC_FLVR_SVC(req->rq_flvr.sf_rpc)) { @@ -1038,7 +1029,7 @@ static int do_cli_unwrap_reply(struct ptlrpc_request *req) if (SPTLRPC_FLVR_POLICY(req->rq_flvr.sf_rpc) != SPTLRPC_POLICY_NULL && !req->rq_ctx_init) req->rq_rep_swab_mask = 0; - RETURN(rc); + return rc; } /** @@ -1096,11 +1087,10 @@ int sptlrpc_cli_unwrap_early_reply(struct ptlrpc_request *req, char *early_buf; int early_bufsz, early_size; int rc; - ENTRY; OBD_ALLOC_PTR(early_req); if (early_req == NULL) - RETURN(-ENOMEM); + return -ENOMEM; early_size = req->rq_nob_received; early_bufsz = size_roundup_power2(early_size); @@ -1163,7 +1153,7 @@ int sptlrpc_cli_unwrap_early_reply(struct ptlrpc_request *req, LASSERT(early_req->rq_repmsg); *req_ret = early_req; - RETURN(0); + return 0; err_ctx: sptlrpc_cli_ctx_put(early_req->rq_cli_ctx, 1); @@ -1171,7 +1161,7 @@ err_buf: OBD_FREE_LARGE(early_buf, early_bufsz); err_req: OBD_FREE_PTR(early_req); - RETURN(rc); + return rc; } /** @@ -1285,7 +1275,6 @@ struct ptlrpc_sec * sptlrpc_sec_create(struct obd_import *imp, struct ptlrpc_sec_policy *policy; struct ptlrpc_sec *sec; char str[32]; - ENTRY; if (svc_ctx) { LASSERT(imp->imp_dlm_fake == 1); @@ -1308,7 +1297,7 @@ struct ptlrpc_sec * sptlrpc_sec_create(struct obd_import *imp, policy = sptlrpc_wireflavor2policy(sf->sf_rpc); if (!policy) { CERROR("invalid flavor 0x%x\n", sf->sf_rpc); - RETURN(NULL); + return NULL; } } @@ -1324,7 +1313,7 @@ struct ptlrpc_sec * sptlrpc_sec_create(struct obd_import *imp, sptlrpc_policy_put(policy); } - RETURN(sec); + return sec; } struct ptlrpc_sec *sptlrpc_import_sec_ref(struct obd_import *imp) @@ -1406,12 +1395,11 @@ int sptlrpc_import_sec_adapt(struct obd_import *imp, enum lustre_sec_part sp; char str[24]; int rc = 0; - ENTRY; might_sleep(); if (imp == NULL) - RETURN(0); + return 0; conn = imp->imp_connection; @@ -1485,7 +1473,7 @@ int sptlrpc_import_sec_adapt(struct obd_import *imp, mutex_unlock(&imp->imp_sec_mutex); out: sptlrpc_sec_put(sec); - RETURN(rc); + return rc; } void sptlrpc_import_sec_put(struct obd_import *imp) @@ -1523,7 +1511,8 @@ void sptlrpc_import_flush_root_ctx(struct obd_import *imp) void sptlrpc_import_flush_my_ctx(struct obd_import *imp) { - import_flush_ctx_common(imp, current_uid(), 1, 1); + import_flush_ctx_common(imp, from_kuid(&init_user_ns, current_uid()), + 1, 1); } EXPORT_SYMBOL(sptlrpc_import_flush_my_ctx); @@ -1668,17 +1657,16 @@ int sptlrpc_cli_alloc_repbuf(struct ptlrpc_request *req, int msgsize) { struct ptlrpc_cli_ctx *ctx = req->rq_cli_ctx; struct ptlrpc_sec_policy *policy; - ENTRY; LASSERT(ctx); LASSERT(ctx->cc_sec); LASSERT(ctx->cc_sec->ps_policy); if (req->rq_repbuf) - RETURN(0); + return 0; policy = ctx->cc_sec->ps_policy; - RETURN(policy->sp_cops->alloc_repbuf(ctx->cc_sec, req, msgsize)); + return policy->sp_cops->alloc_repbuf(ctx->cc_sec, req, msgsize); } /** @@ -1689,7 +1677,6 @@ void sptlrpc_cli_free_repbuf(struct ptlrpc_request *req) { struct ptlrpc_cli_ctx *ctx = req->rq_cli_ctx; struct ptlrpc_sec_policy *policy; - ENTRY; LASSERT(ctx); LASSERT(ctx->cc_sec); @@ -1703,7 +1690,6 @@ void sptlrpc_cli_free_repbuf(struct ptlrpc_request *req) policy = ctx->cc_sec->ps_policy; policy->sp_cops->free_repbuf(ctx->cc_sec, req); req->rq_repmsg = NULL; - EXIT; } int sptlrpc_cli_install_rvs_ctx(struct obd_import *imp, @@ -2032,7 +2018,6 @@ int sptlrpc_svc_unwrap_request(struct ptlrpc_request *req) struct ptlrpc_sec_policy *policy; struct lustre_msg *msg = req->rq_reqbuf; int rc; - ENTRY; LASSERT(msg); LASSERT(req->rq_reqmsg == NULL); @@ -2050,18 +2035,18 @@ int sptlrpc_svc_unwrap_request(struct ptlrpc_request *req) default: CERROR("error unpacking request from %s x"LPU64"\n", libcfs_id2str(req->rq_peer), req->rq_xid); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } req->rq_flvr.sf_rpc = WIRE_FLVR(msg->lm_secflvr); req->rq_sp_from = LUSTRE_SP_ANY; - req->rq_auth_uid = INVALID_UID; - req->rq_auth_mapped_uid = INVALID_UID; + req->rq_auth_uid = -1; + req->rq_auth_mapped_uid = -1; policy = sptlrpc_wireflavor2policy(req->rq_flvr.sf_rpc); if (!policy) { CERROR("unsupported rpc flavor %x\n", req->rq_flvr.sf_rpc); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } LASSERT(policy->sp_sops->accept); @@ -2079,7 +2064,7 @@ int sptlrpc_svc_unwrap_request(struct ptlrpc_request *req) /* sanity check for the request source */ rc = sptlrpc_svc_check_from(req, rc); - RETURN(rc); + return rc; } /** @@ -2092,7 +2077,6 @@ int sptlrpc_svc_alloc_rs(struct ptlrpc_request *req, int msglen) struct ptlrpc_sec_policy *policy; struct ptlrpc_reply_state *rs; int rc; - ENTRY; LASSERT(req->rq_svc_ctx); LASSERT(req->rq_svc_ctx->sc_policy); @@ -2105,7 +2089,7 @@ int sptlrpc_svc_alloc_rs(struct ptlrpc_request *req, int msglen) /* failed alloc, try emergency pool */ rs = lustre_get_emerg_rs(req->rq_rqbd->rqbd_svcpt); if (rs == NULL) - RETURN(-ENOMEM); + return -ENOMEM; req->rq_reply_state = rs; rc = policy->sp_sops->alloc_rs(req, msglen); @@ -2118,7 +2102,7 @@ int sptlrpc_svc_alloc_rs(struct ptlrpc_request *req, int msglen) LASSERT(rc != 0 || (req->rq_reply_state && req->rq_reply_state->rs_msg)); - RETURN(rc); + return rc; } /** @@ -2131,7 +2115,6 @@ int sptlrpc_svc_wrap_reply(struct ptlrpc_request *req) { struct ptlrpc_sec_policy *policy; int rc; - ENTRY; LASSERT(req->rq_svc_ctx); LASSERT(req->rq_svc_ctx->sc_policy); @@ -2142,7 +2125,7 @@ int sptlrpc_svc_wrap_reply(struct ptlrpc_request *req) rc = policy->sp_sops->authorize(req); LASSERT(rc || req->rq_reply_state->rs_repdata_len); - RETURN(rc); + return rc; } /** @@ -2152,7 +2135,6 @@ void sptlrpc_svc_free_rs(struct ptlrpc_reply_state *rs) { struct ptlrpc_sec_policy *policy; unsigned int prealloc; - ENTRY; LASSERT(rs->rs_svc_ctx); LASSERT(rs->rs_svc_ctx->sc_policy); @@ -2165,7 +2147,6 @@ void sptlrpc_svc_free_rs(struct ptlrpc_reply_state *rs) if (prealloc) lustre_put_emerg_rs(rs); - EXIT; } void sptlrpc_svc_ctx_addref(struct ptlrpc_request *req) @@ -2314,10 +2295,10 @@ int sptlrpc_pack_user_desc(struct lustre_msg *msg, int offset) pud = lustre_msg_buf(msg, offset, 0); - pud->pud_uid = current_uid(); - pud->pud_gid = current_gid(); - pud->pud_fsuid = current_fsuid(); - pud->pud_fsgid = current_fsgid(); + pud->pud_uid = from_kuid(&init_user_ns, current_uid()); + pud->pud_gid = from_kgid(&init_user_ns, current_gid()); + pud->pud_fsuid = from_kuid(&init_user_ns, current_fsuid()); + pud->pud_fsgid = from_kgid(&init_user_ns, current_fsgid()); pud->pud_cap = cfs_curproc_cap_pack(); pud->pud_ngroups = (msg->lm_buflens[offset] - sizeof(*pud)) / 4; diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec_bulk.c b/drivers/staging/lustre/lustre/ptlrpc/sec_bulk.c index bf53f1bc1742..6547f46a7729 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/sec_bulk.c +++ b/drivers/staging/lustre/lustre/ptlrpc/sec_bulk.c @@ -59,8 +59,8 @@ ****************************************/ -#define PTRS_PER_PAGE (PAGE_CACHE_SIZE / sizeof(void *)) -#define PAGES_PER_POOL (PTRS_PER_PAGE) +#define POINTERS_PER_PAGE (PAGE_CACHE_SIZE / sizeof(void *)) +#define PAGES_PER_POOL (POINTERS_PER_PAGE) #define IDLE_IDX_MAX (100) #define IDLE_IDX_WEIGHT (3) @@ -121,13 +121,6 @@ static struct ptlrpc_enc_page_pool { } page_pools; /* - * memory shrinker - */ -const int pools_shrinker_seeks = DEFAULT_SEEKS; -static struct shrinker *pools_shrinker = NULL; - - -/* * /proc/fs/lustre/sptlrpc/encrypt_page_pools */ int sptlrpc_proc_enc_pool_seq_show(struct seq_file *m, void *v) @@ -156,7 +149,7 @@ int sptlrpc_proc_enc_pool_seq_show(struct seq_file *m, void *v) "max waitqueue depth: %u\n" "max wait time: "CFS_TIME_T"/%u\n" , - num_physpages, + totalram_pages, PAGES_PER_POOL, page_pools.epp_max_pages, page_pools.epp_max_pools, @@ -226,30 +219,46 @@ static void enc_pools_release_free_pages(long npages) } /* - * could be called frequently for query (@nr_to_scan == 0). * we try to keep at least PTLRPC_MAX_BRW_PAGES pages in the pool. */ -static int enc_pools_shrink(SHRINKER_ARGS(sc, nr_to_scan, gfp_mask)) +static unsigned long enc_pools_shrink_count(struct shrinker *s, + struct shrink_control *sc) { - if (unlikely(shrink_param(sc, nr_to_scan) != 0)) { + /* + * if no pool access for a long time, we consider it's fully idle. + * a little race here is fine. + */ + if (unlikely(cfs_time_current_sec() - page_pools.epp_last_access > + CACHE_QUIESCENT_PERIOD)) { spin_lock(&page_pools.epp_lock); - shrink_param(sc, nr_to_scan) = min_t(unsigned long, - shrink_param(sc, nr_to_scan), - page_pools.epp_free_pages - - PTLRPC_MAX_BRW_PAGES); - if (shrink_param(sc, nr_to_scan) > 0) { - enc_pools_release_free_pages(shrink_param(sc, - nr_to_scan)); - CDEBUG(D_SEC, "released %ld pages, %ld left\n", - (long)shrink_param(sc, nr_to_scan), - page_pools.epp_free_pages); - - page_pools.epp_st_shrinks++; - page_pools.epp_last_shrink = cfs_time_current_sec(); - } + page_pools.epp_idle_idx = IDLE_IDX_MAX; spin_unlock(&page_pools.epp_lock); } + LASSERT(page_pools.epp_idle_idx <= IDLE_IDX_MAX); + return max((int)page_pools.epp_free_pages - PTLRPC_MAX_BRW_PAGES, 0) * + (IDLE_IDX_MAX - page_pools.epp_idle_idx) / IDLE_IDX_MAX; +} + +/* + * we try to keep at least PTLRPC_MAX_BRW_PAGES pages in the pool. + */ +static unsigned long enc_pools_shrink_scan(struct shrinker *s, + struct shrink_control *sc) +{ + spin_lock(&page_pools.epp_lock); + sc->nr_to_scan = min_t(unsigned long, sc->nr_to_scan, + page_pools.epp_free_pages - PTLRPC_MAX_BRW_PAGES); + if (sc->nr_to_scan > 0) { + enc_pools_release_free_pages(sc->nr_to_scan); + CDEBUG(D_SEC, "released %ld pages, %ld left\n", + (long)sc->nr_to_scan, page_pools.epp_free_pages); + + page_pools.epp_st_shrinks++; + page_pools.epp_last_shrink = cfs_time_current_sec(); + } + spin_unlock(&page_pools.epp_lock); + /* * if no pool access for a long time, we consider it's fully idle. * a little race here is fine. @@ -262,8 +271,7 @@ static int enc_pools_shrink(SHRINKER_ARGS(sc, nr_to_scan, gfp_mask)) } LASSERT(page_pools.epp_idle_idx <= IDLE_IDX_MAX); - return max((int)page_pools.epp_free_pages - PTLRPC_MAX_BRW_PAGES, 0) * - (IDLE_IDX_MAX - page_pools.epp_idle_idx) / IDLE_IDX_MAX; + return sc->nr_to_scan; } static inline @@ -699,13 +707,19 @@ static inline void enc_pools_free(void) sizeof(*page_pools.epp_pools)); } +static struct shrinker pools_shrinker = { + .count_objects = enc_pools_shrink_count, + .scan_objects = enc_pools_shrink_scan, + .seeks = DEFAULT_SEEKS, +}; + int sptlrpc_enc_pool_init(void) { /* * maximum capacity is 1/8 of total physical memory. * is the 1/8 a good number? */ - page_pools.epp_max_pages = num_physpages / 8; + page_pools.epp_max_pages = totalram_pages / 8; page_pools.epp_max_pools = npages_to_npools(page_pools.epp_max_pages); init_waitqueue_head(&page_pools.epp_waitq); @@ -736,12 +750,7 @@ int sptlrpc_enc_pool_init(void) if (page_pools.epp_pools == NULL) return -ENOMEM; - pools_shrinker = set_shrinker(pools_shrinker_seeks, - enc_pools_shrink); - if (pools_shrinker == NULL) { - enc_pools_free(); - return -ENOMEM; - } + register_shrinker(&pools_shrinker); return 0; } @@ -750,11 +759,10 @@ void sptlrpc_enc_pool_fini(void) { unsigned long cleaned, npools; - LASSERT(pools_shrinker); LASSERT(page_pools.epp_pools); LASSERT(page_pools.epp_total_pages == page_pools.epp_free_pages); - remove_shrinker(pools_shrinker); + unregister_shrinker(&pools_shrinker); npools = npages_to_npools(page_pools.epp_total_pages); cleaned = enc_pools_cleanup(page_pools.epp_pools, npools); diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec_config.c b/drivers/staging/lustre/lustre/ptlrpc/sec_config.c index a45a3929b59f..6cc3f23c27cc 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/sec_config.c +++ b/drivers/staging/lustre/lustre/ptlrpc/sec_config.c @@ -195,7 +195,7 @@ int sptlrpc_parse_rule(char *param, struct sptlrpc_rule *rule) flavor = strchr(param, '='); if (flavor == NULL) { CERROR("invalid param, no '='\n"); - RETURN(-EINVAL); + return -EINVAL; } *flavor++ = '\0'; @@ -208,7 +208,7 @@ int sptlrpc_parse_rule(char *param, struct sptlrpc_rule *rule) rule->sr_netid = libcfs_str2net(param); if (rule->sr_netid == LNET_NIDNET(LNET_NID_ANY)) { CERROR("invalid network name: %s\n", param); - RETURN(-EINVAL); + return -EINVAL; } } @@ -228,16 +228,16 @@ int sptlrpc_parse_rule(char *param, struct sptlrpc_rule *rule) rule->sr_to = LUSTRE_SP_MDT; } else { CERROR("invalid rule dir segment: %s\n", dir); - RETURN(-EINVAL); + return -EINVAL; } } /* 2.1 flavor */ rc = sptlrpc_parse_flavor(flavor, &rule->sr_flvr); if (rc) - RETURN(-EINVAL); + return -EINVAL; - RETURN(0); + return 0; } EXPORT_SYMBOL(sptlrpc_parse_rule); @@ -661,18 +661,17 @@ static int __sptlrpc_process_config(struct lustre_cfg *lcfg, char fsname[MTI_NAME_MAXLEN]; struct sptlrpc_rule rule; int rc; - ENTRY; target = lustre_cfg_string(lcfg, 1); if (target == NULL) { CERROR("missing target name\n"); - RETURN(-EINVAL); + return -EINVAL; } param = lustre_cfg_string(lcfg, 2); if (param == NULL) { CERROR("missing parameter\n"); - RETURN(-EINVAL); + return -EINVAL; } CDEBUG(D_SEC, "processing rule: %s.%s\n", target, param); @@ -680,13 +679,13 @@ static int __sptlrpc_process_config(struct lustre_cfg *lcfg, /* parse rule to make sure the format is correct */ if (strncmp(param, PARAM_SRPC_FLVR, sizeof(PARAM_SRPC_FLVR) - 1) != 0) { CERROR("Invalid sptlrpc parameter: %s\n", param); - RETURN(-EINVAL); + return -EINVAL; } param += sizeof(PARAM_SRPC_FLVR) - 1; rc = sptlrpc_parse_rule(param, &rule); if (rc) - RETURN(-EINVAL); + return -EINVAL; if (conf == NULL) { target2fsname(target, fsname, sizeof(fsname)); @@ -708,7 +707,7 @@ static int __sptlrpc_process_config(struct lustre_cfg *lcfg, if (rc == 0) conf->sc_modified++; - RETURN(rc); + return rc; } int sptlrpc_process_config(struct lustre_cfg *lcfg) @@ -905,7 +904,6 @@ EXPORT_SYMBOL(sptlrpc_target_choose_flavor); void sptlrpc_conf_client_adapt(struct obd_device *obd) { struct obd_import *imp; - ENTRY; LASSERT(strcmp(obd->obd_type->typ_name, LUSTRE_MDC_NAME) == 0 || strcmp(obd->obd_type->typ_name, LUSTRE_OSC_NAME) ==0); @@ -924,7 +922,6 @@ void sptlrpc_conf_client_adapt(struct obd_device *obd) } up_read(&obd->u.cli.cl_sem); - EXIT; } EXPORT_SYMBOL(sptlrpc_conf_client_adapt); @@ -1011,11 +1008,10 @@ int sptlrpc_target_local_copy_conf(struct obd_device *obd, struct lvfs_run_ctxt saved; struct dentry *dentry; int rc; - ENTRY; ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT); if (ctxt == NULL) - RETURN(-EINVAL); + return -EINVAL; push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); @@ -1058,7 +1054,7 @@ out_ctx: llog_ctxt_put(ctxt); CDEBUG(D_SEC, "target %s: write local sptlrpc conf: rc = %d\n", obd->obd_name, rc); - RETURN(rc); + return rc; } static int local_read_handler(const struct lu_env *env, @@ -1068,11 +1064,10 @@ static int local_read_handler(const struct lu_env *env, struct sptlrpc_conf *conf = (struct sptlrpc_conf *) data; struct lustre_cfg *lcfg = (struct lustre_cfg *)(rec + 1); int cfg_len, rc; - ENTRY; if (rec->lrh_type != OBD_CFG_REC) { CERROR("unhandled lrh_type: %#x\n", rec->lrh_type); - RETURN(-EINVAL); + return -EINVAL; } cfg_len = rec->lrh_len - sizeof(struct llog_rec_hdr) - @@ -1081,15 +1076,15 @@ static int local_read_handler(const struct lu_env *env, rc = lustre_cfg_sanity_check(lcfg, cfg_len); if (rc) { CERROR("Insane cfg\n"); - RETURN(rc); + return rc; } if (lcfg->lcfg_command != LCFG_SPTLRPC_CONF) { CERROR("invalid command (%x)\n", lcfg->lcfg_command); - RETURN(-EINVAL); + return -EINVAL; } - RETURN(__sptlrpc_process_config(lcfg, conf)); + return __sptlrpc_process_config(lcfg, conf); } static @@ -1100,14 +1095,13 @@ int sptlrpc_target_local_read_conf(struct obd_device *obd, struct llog_ctxt *ctxt; struct lvfs_run_ctxt saved; int rc; - ENTRY; LASSERT(conf->sc_updated == 0 && conf->sc_local == 0); ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT); if (ctxt == NULL) { CERROR("missing llog context\n"); - RETURN(-EINVAL); + return -EINVAL; } push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); @@ -1143,7 +1137,7 @@ out_pop: llog_ctxt_put(ctxt); CDEBUG(D_SEC, "target %s: read local sptlrpc conf: rc = %d\n", obd->obd_name, rc); - RETURN(rc); + return rc; } @@ -1160,7 +1154,6 @@ int sptlrpc_conf_target_get_rules(struct obd_device *obd, enum lustre_sec_part sp_dst; char fsname[MTI_NAME_MAXLEN]; int rc = 0; - ENTRY; if (strcmp(obd->obd_type->typ_name, LUSTRE_MDT_NAME) == 0) { sp_dst = LUSTRE_SP_MDT; @@ -1168,7 +1161,7 @@ int sptlrpc_conf_target_get_rules(struct obd_device *obd, sp_dst = LUSTRE_SP_OST; } else { CERROR("unexpected obd type %s\n", obd->obd_type->typ_name); - RETURN(-EINVAL); + return -EINVAL; } CDEBUG(D_SEC, "get rules for target %s\n", obd->obd_uuid.uuid); @@ -1210,7 +1203,7 @@ int sptlrpc_conf_target_get_rules(struct obd_device *obd, LUSTRE_SP_ANY, sp_dst, rset); out: mutex_unlock(&sptlrpc_conf_lock); - RETURN(rc); + return rc; } EXPORT_SYMBOL(sptlrpc_conf_target_get_rules); diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec_gc.c b/drivers/staging/lustre/lustre/ptlrpc/sec_gc.c index 4c96a14a1bb6..d2eb20eb56db 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/sec_gc.c +++ b/drivers/staging/lustre/lustre/ptlrpc/sec_gc.c @@ -217,7 +217,7 @@ again: int sptlrpc_gc_init(void) { struct l_wait_info lwi = { 0 }; - task_t *task; + struct task_struct *task; mutex_init(&sec_gc_mutex); spin_lock_init(&sec_gc_list_lock); diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec_plain.c b/drivers/staging/lustre/lustre/ptlrpc/sec_plain.c index f552d2f182b1..416401be6d4f 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/sec_plain.c +++ b/drivers/staging/lustre/lustre/ptlrpc/sec_plain.c @@ -192,7 +192,6 @@ int plain_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req) { struct lustre_msg *msg = req->rq_reqbuf; struct plain_header *phdr; - ENTRY; msg->lm_secflvr = req->rq_flvr.sf_rpc; @@ -209,7 +208,7 @@ int plain_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req) req->rq_reqdata_len = lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens); - RETURN(0); + return 0; } static @@ -219,11 +218,10 @@ int plain_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req) struct plain_header *phdr; __u32 cksum; int swabbed; - ENTRY; if (msg->lm_bufcount != PLAIN_PACK_SEGMENTS) { CERROR("unexpected reply buf count %u\n", msg->lm_bufcount); - RETURN(-EPROTO); + return -EPROTO; } swabbed = ptlrpc_rep_need_swab(req); @@ -231,24 +229,24 @@ int plain_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req) phdr = lustre_msg_buf(msg, PLAIN_PACK_HDR_OFF, sizeof(*phdr)); if (phdr == NULL) { CERROR("missing plain header\n"); - RETURN(-EPROTO); + return -EPROTO; } if (phdr->ph_ver != 0) { CERROR("Invalid header version\n"); - RETURN(-EPROTO); + return -EPROTO; } /* expect no user desc in reply */ if (phdr->ph_flags & PLAIN_FL_USER) { CERROR("Unexpected udesc flag in reply\n"); - RETURN(-EPROTO); + return -EPROTO; } if (phdr->ph_bulk_hash_alg != req->rq_flvr.u_bulk.hash.hash_alg) { CERROR("reply bulk flavor %u != %u\n", phdr->ph_bulk_hash_alg, req->rq_flvr.u_bulk.hash.hash_alg); - RETURN(-EPROTO); + return -EPROTO; } if (unlikely(req->rq_early)) { @@ -262,7 +260,7 @@ int plain_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req) CDEBUG(D_SEC, "early reply checksum mismatch: %08x != %08x\n", cpu_to_le32(cksum), msg->lm_cksum); - RETURN(-EINVAL); + return -EINVAL; } } else { /* whether we sent with bulk or not, we expect the same @@ -272,18 +270,18 @@ int plain_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req) phdr->ph_flags & PLAIN_FL_BULK)) { CERROR("%s bulk checksum in reply\n", req->rq_pack_bulk ? "Missing" : "Unexpected"); - RETURN(-EPROTO); + return -EPROTO; } if (phdr->ph_flags & PLAIN_FL_BULK) { if (plain_unpack_bsd(msg, swabbed)) - RETURN(-EPROTO); + return -EPROTO; } } req->rq_repmsg = lustre_msg_buf(msg, PLAIN_PACK_MSG_OFF, 0); req->rq_replen = lustre_msg_buflen(msg, PLAIN_PACK_MSG_OFF); - RETURN(0); + return 0; } static @@ -307,10 +305,10 @@ int plain_cli_wrap_bulk(struct ptlrpc_cli_ctx *ctx, bsd->bsd_svc = SPTLRPC_FLVR_BULK_SVC(req->rq_flvr.sf_rpc); if (bsd->bsd_svc == SPTLRPC_BULK_SVC_NULL) - RETURN(0); + return 0; if (req->rq_bulk_read) - RETURN(0); + return 0; rc = plain_generate_bulk_csum(desc, req->rq_flvr.u_bulk.hash.hash_alg, token); @@ -417,7 +415,6 @@ static void plain_destroy_sec(struct ptlrpc_sec *sec) { struct plain_sec *plsec = sec2plsec(sec); - ENTRY; LASSERT(sec->ps_policy == &plain_policy); LASSERT(sec->ps_import); @@ -428,7 +425,6 @@ void plain_destroy_sec(struct ptlrpc_sec *sec) class_import_put(sec->ps_import); OBD_FREE_PTR(plsec); - EXIT; } static @@ -445,13 +441,12 @@ struct ptlrpc_sec *plain_create_sec(struct obd_import *imp, struct plain_sec *plsec; struct ptlrpc_sec *sec; struct ptlrpc_cli_ctx *ctx; - ENTRY; LASSERT(SPTLRPC_FLVR_POLICY(sf->sf_rpc) == SPTLRPC_POLICY_PLAIN); OBD_ALLOC_PTR(plsec); if (plsec == NULL) - RETURN(NULL); + return NULL; /* * initialize plain_sec @@ -476,12 +471,12 @@ struct ptlrpc_sec *plain_create_sec(struct obd_import *imp, ctx = plain_sec_install_ctx(plsec); if (ctx == NULL) { plain_destroy_sec(sec); - RETURN(NULL); + return NULL; } sptlrpc_cli_ctx_put(ctx, 1); } - RETURN(sec); + return sec; } static @@ -491,7 +486,6 @@ struct ptlrpc_cli_ctx *plain_lookup_ctx(struct ptlrpc_sec *sec, { struct plain_sec *plsec = sec2plsec(sec); struct ptlrpc_cli_ctx *ctx; - ENTRY; read_lock(&plsec->pls_lock); ctx = plsec->pls_ctx; @@ -502,7 +496,7 @@ struct ptlrpc_cli_ctx *plain_lookup_ctx(struct ptlrpc_sec *sec, if (unlikely(ctx == NULL)) ctx = plain_sec_install_ctx(plsec); - RETURN(ctx); + return ctx; } static @@ -526,11 +520,10 @@ int plain_flush_ctx_cache(struct ptlrpc_sec *sec, { struct plain_sec *plsec = sec2plsec(sec); struct ptlrpc_cli_ctx *ctx; - ENTRY; /* do nothing unless caller want to flush for 'all' */ if (uid != -1) - RETURN(0); + return 0; write_lock(&plsec->pls_lock); ctx = plsec->pls_ctx; @@ -539,7 +532,7 @@ int plain_flush_ctx_cache(struct ptlrpc_sec *sec, if (ctx) sptlrpc_cli_ctx_put(ctx, 1); - RETURN(0); + return 0; } static @@ -549,7 +542,6 @@ int plain_alloc_reqbuf(struct ptlrpc_sec *sec, { __u32 buflens[PLAIN_PACK_SEGMENTS] = { 0, }; int alloc_len; - ENTRY; buflens[PLAIN_PACK_HDR_OFF] = sizeof(struct plain_header); buflens[PLAIN_PACK_MSG_OFF] = msgsize; @@ -570,7 +562,7 @@ int plain_alloc_reqbuf(struct ptlrpc_sec *sec, alloc_len = size_roundup_power2(alloc_len); OBD_ALLOC_LARGE(req->rq_reqbuf, alloc_len); if (!req->rq_reqbuf) - RETURN(-ENOMEM); + return -ENOMEM; req->rq_reqbuf_len = alloc_len; } else { @@ -585,20 +577,18 @@ int plain_alloc_reqbuf(struct ptlrpc_sec *sec, if (req->rq_pack_udesc) sptlrpc_pack_user_desc(req->rq_reqbuf, PLAIN_PACK_USER_OFF); - RETURN(0); + return 0; } static void plain_free_reqbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req) { - ENTRY; if (!req->rq_pool) { OBD_FREE_LARGE(req->rq_reqbuf, req->rq_reqbuf_len); req->rq_reqbuf = NULL; req->rq_reqbuf_len = 0; } - EXIT; } static @@ -608,7 +598,6 @@ int plain_alloc_repbuf(struct ptlrpc_sec *sec, { __u32 buflens[PLAIN_PACK_SEGMENTS] = { 0, }; int alloc_len; - ENTRY; buflens[PLAIN_PACK_HDR_OFF] = sizeof(struct plain_header); buflens[PLAIN_PACK_MSG_OFF] = msgsize; @@ -627,21 +616,19 @@ int plain_alloc_repbuf(struct ptlrpc_sec *sec, OBD_ALLOC_LARGE(req->rq_repbuf, alloc_len); if (!req->rq_repbuf) - RETURN(-ENOMEM); + return -ENOMEM; req->rq_repbuf_len = alloc_len; - RETURN(0); + return 0; } static void plain_free_repbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req) { - ENTRY; OBD_FREE_LARGE(req->rq_repbuf, req->rq_repbuf_len); req->rq_repbuf = NULL; req->rq_repbuf_len = 0; - EXIT; } static @@ -652,7 +639,6 @@ int plain_enlarge_reqbuf(struct ptlrpc_sec *sec, struct lustre_msg *newbuf; int oldsize; int newmsg_size, newbuf_size; - ENTRY; LASSERT(req->rq_reqbuf); LASSERT(req->rq_reqbuf_len >= req->rq_reqlen); @@ -681,7 +667,7 @@ int plain_enlarge_reqbuf(struct ptlrpc_sec *sec, OBD_ALLOC_LARGE(newbuf, newbuf_size); if (newbuf == NULL) - RETURN(-ENOMEM); + return -ENOMEM; memcpy(newbuf, req->rq_reqbuf, req->rq_reqbuf_len); @@ -697,7 +683,7 @@ int plain_enlarge_reqbuf(struct ptlrpc_sec *sec, _sptlrpc_enlarge_msg_inplace(req->rq_reqmsg, segment, newsize); req->rq_reqlen = newmsg_size; - RETURN(0); + return 0; } /**************************************** @@ -715,7 +701,6 @@ int plain_accept(struct ptlrpc_request *req) struct lustre_msg *msg = req->rq_reqbuf; struct plain_header *phdr; int swabbed; - ENTRY; LASSERT(SPTLRPC_FLVR_POLICY(req->rq_flvr.sf_rpc) == SPTLRPC_POLICY_PLAIN); @@ -725,12 +710,12 @@ int plain_accept(struct ptlrpc_request *req) SPTLRPC_FLVR_BULK_TYPE(req->rq_flvr.sf_rpc) != SPTLRPC_FLVR_BULK_TYPE(SPTLRPC_FLVR_PLAIN)) { CERROR("Invalid rpc flavor %x\n", req->rq_flvr.sf_rpc); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } if (msg->lm_bufcount < PLAIN_PACK_SEGMENTS) { CERROR("unexpected request buf count %u\n", msg->lm_bufcount); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } swabbed = ptlrpc_req_need_swab(req); @@ -738,17 +723,17 @@ int plain_accept(struct ptlrpc_request *req) phdr = lustre_msg_buf(msg, PLAIN_PACK_HDR_OFF, sizeof(*phdr)); if (phdr == NULL) { CERROR("missing plain header\n"); - RETURN(-EPROTO); + return -EPROTO; } if (phdr->ph_ver != 0) { CERROR("Invalid header version\n"); - RETURN(-EPROTO); + return -EPROTO; } if (phdr->ph_bulk_hash_alg >= BULK_HASH_ALG_MAX) { CERROR("invalid hash algorithm: %u\n", phdr->ph_bulk_hash_alg); - RETURN(-EPROTO); + return -EPROTO; } req->rq_sp_from = phdr->ph_sp; @@ -758,7 +743,7 @@ int plain_accept(struct ptlrpc_request *req) if (sptlrpc_unpack_user_desc(msg, PLAIN_PACK_USER_OFF, swabbed)) { CERROR("Mal-formed user descriptor\n"); - RETURN(SECSVC_DROP); + return SECSVC_DROP; } req->rq_pack_udesc = 1; @@ -767,7 +752,7 @@ int plain_accept(struct ptlrpc_request *req) if (phdr->ph_flags & PLAIN_FL_BULK) { if (plain_unpack_bsd(msg, swabbed)) - RETURN(SECSVC_DROP); + return SECSVC_DROP; req->rq_pack_bulk = 1; } @@ -778,7 +763,7 @@ int plain_accept(struct ptlrpc_request *req) req->rq_svc_ctx = &plain_svc_ctx; atomic_inc(&req->rq_svc_ctx->sc_refcount); - RETURN(SECSVC_OK); + return SECSVC_OK; } static @@ -787,7 +772,6 @@ int plain_alloc_rs(struct ptlrpc_request *req, int msgsize) struct ptlrpc_reply_state *rs; __u32 buflens[PLAIN_PACK_SEGMENTS] = { 0, }; int rs_size = sizeof(*rs); - ENTRY; LASSERT(msgsize % 8 == 0); @@ -807,7 +791,7 @@ int plain_alloc_rs(struct ptlrpc_request *req, int msgsize) } else { OBD_ALLOC_LARGE(rs, rs_size); if (rs == NULL) - RETURN(-ENOMEM); + return -ENOMEM; rs->rs_size = rs_size; } @@ -821,20 +805,17 @@ int plain_alloc_rs(struct ptlrpc_request *req, int msgsize) rs->rs_msg = lustre_msg_buf_v2(rs->rs_repbuf, PLAIN_PACK_MSG_OFF, 0); req->rq_reply_state = rs; - RETURN(0); + return 0; } static void plain_free_rs(struct ptlrpc_reply_state *rs) { - ENTRY; - LASSERT(atomic_read(&rs->rs_svc_ctx->sc_refcount) > 1); atomic_dec(&rs->rs_svc_ctx->sc_refcount); if (!rs->rs_prealloc) OBD_FREE_LARGE(rs, rs->rs_size); - EXIT; } static @@ -844,7 +825,6 @@ int plain_authorize(struct ptlrpc_request *req) struct lustre_msg_v2 *msg = rs->rs_repbuf; struct plain_header *phdr; int len; - ENTRY; LASSERT(rs); LASSERT(msg); @@ -882,7 +862,7 @@ int plain_authorize(struct ptlrpc_request *req) req->rq_reply_off = 0; } - RETURN(0); + return 0; } static diff --git a/drivers/staging/lustre/lustre/ptlrpc/service.c b/drivers/staging/lustre/lustre/ptlrpc/service.c index 1667b8e86012..acf75f3873d1 100644 --- a/drivers/staging/lustre/lustre/ptlrpc/service.c +++ b/drivers/staging/lustre/lustre/ptlrpc/service.c @@ -369,7 +369,6 @@ static void rs_batch_fini(struct rs_batch *b) void ptlrpc_dispatch_difficult_reply(struct ptlrpc_reply_state *rs) { struct ptlrpc_hr_thread *hrt; - ENTRY; LASSERT(list_empty(&rs->rs_list)); @@ -380,28 +379,23 @@ void ptlrpc_dispatch_difficult_reply(struct ptlrpc_reply_state *rs) spin_unlock(&hrt->hrt_lock); wake_up(&hrt->hrt_waitq); - EXIT; } void ptlrpc_schedule_difficult_reply(struct ptlrpc_reply_state *rs) { - ENTRY; - LASSERT(spin_is_locked(&rs->rs_svcpt->scp_rep_lock)); LASSERT(spin_is_locked(&rs->rs_lock)); LASSERT (rs->rs_difficult); rs->rs_scheduled_ever = 1; /* flag any notification attempt */ if (rs->rs_scheduled) { /* being set up or already notified */ - EXIT; return; } rs->rs_scheduled = 1; list_del_init(&rs->rs_list); ptlrpc_dispatch_difficult_reply(rs); - EXIT; } EXPORT_SYMBOL(ptlrpc_schedule_difficult_reply); @@ -409,7 +403,6 @@ void ptlrpc_commit_replies(struct obd_export *exp) { struct ptlrpc_reply_state *rs, *nxt; DECLARE_RS_BATCH(batch); - ENTRY; rs_batch_init(&batch); /* Find any replies that have been committed and get their service @@ -429,7 +422,6 @@ void ptlrpc_commit_replies(struct obd_export *exp) } spin_unlock(&exp->exp_uncommitted_replies_lock); rs_batch_fini(&batch); - EXIT; } EXPORT_SYMBOL(ptlrpc_commit_replies); @@ -551,6 +543,7 @@ ptlrpc_server_nthreads_check(struct ptlrpc_service *svc, if (tc->tc_thr_factor != 0) { int factor = tc->tc_thr_factor; const int fade = 4; + cpumask_t mask; /* * User wants to increase number of threads with for @@ -564,7 +557,8 @@ ptlrpc_server_nthreads_check(struct ptlrpc_service *svc, * have too many threads no matter how many cores/HTs * there are. */ - if (cfs_cpu_ht_nsiblings(0) > 1) { /* weight is # of HTs */ + cpumask_copy(&mask, topology_thread_cpumask(0)); + if (cpus_weight(mask) > 1) { /* weight is # of HTs */ /* depress thread factor for hyper-thread */ factor = factor - (factor >> 1) + (factor >> 3); } @@ -689,7 +683,7 @@ ptlrpc_service_part_init(struct ptlrpc_service *svc, */ struct ptlrpc_service * ptlrpc_register_service(struct ptlrpc_service_conf *conf, - proc_dir_entry_t *proc_entry) + struct proc_dir_entry *proc_entry) { struct ptlrpc_service_cpt_conf *cconf = &conf->psc_cpt; struct ptlrpc_service *service; @@ -700,7 +694,6 @@ ptlrpc_register_service(struct ptlrpc_service_conf *conf, int cpt; int rc; int i; - ENTRY; LASSERT(conf->psc_buf.bc_nbufs > 0); LASSERT(conf->psc_buf.bc_buf_size >= @@ -724,7 +717,7 @@ ptlrpc_register_service(struct ptlrpc_service_conf *conf, if (rc != 0) { CERROR("%s: invalid CPT pattern string: %s", conf->psc_name, cconf->cc_pattern); - RETURN(ERR_PTR(-EINVAL)); + return ERR_PTR(-EINVAL); } rc = cfs_expr_list_values(el, ncpts, &cpts); @@ -734,7 +727,7 @@ ptlrpc_register_service(struct ptlrpc_service_conf *conf, conf->psc_name, cconf->cc_pattern, rc); if (cpts != NULL) OBD_FREE(cpts, sizeof(*cpts) * ncpts); - RETURN(ERR_PTR(rc < 0 ? rc : -EINVAL)); + return ERR_PTR(rc < 0 ? rc : -EINVAL); } ncpts = rc; } @@ -744,7 +737,7 @@ ptlrpc_register_service(struct ptlrpc_service_conf *conf, if (service == NULL) { if (cpts != NULL) OBD_FREE(cpts, sizeof(*cpts) * ncpts); - RETURN(ERR_PTR(-ENOMEM)); + return ERR_PTR(-ENOMEM); } service->srv_cptable = cptable; @@ -823,10 +816,10 @@ ptlrpc_register_service(struct ptlrpc_service_conf *conf, GOTO(failed, rc); } - RETURN(service); + return service; failed: ptlrpc_unregister_service(service); - RETURN(ERR_PTR(rc)); + return ERR_PTR(rc); } EXPORT_SYMBOL(ptlrpc_register_service); @@ -1035,8 +1028,6 @@ static void ptlrpc_update_export_timer(struct obd_export *exp, long extra_delay) struct obd_export *oldest_exp; time_t oldest_time, new_time; - ENTRY; - LASSERT(exp); /* Compensate for slow machines, etc, by faking our request time @@ -1048,7 +1039,7 @@ static void ptlrpc_update_export_timer(struct obd_export *exp, long extra_delay) /* Do not pay attention on 1sec or smaller renewals. */ new_time = cfs_time_current_sec() + extra_delay; if (exp->exp_last_request_time + 1 /*second */ >= new_time) - RETURN_EXIT; + return; exp->exp_last_request_time = new_time; CDEBUG(D_HA, "updating export %s at "CFS_TIME_T" exp %p\n", @@ -1063,7 +1054,7 @@ static void ptlrpc_update_export_timer(struct obd_export *exp, long extra_delay) if (list_empty(&exp->exp_obd_chain_timed)) { /* this one is not timed */ spin_unlock(&exp->exp_obd->obd_dev_lock); - RETURN_EXIT; + return; } list_move_tail(&exp->exp_obd_chain_timed, @@ -1076,7 +1067,6 @@ static void ptlrpc_update_export_timer(struct obd_export *exp, long extra_delay) if (exp->exp_obd->obd_recovering) { /* be nice to everyone during recovery */ - EXIT; return; } @@ -1105,8 +1095,6 @@ static void ptlrpc_update_export_timer(struct obd_export *exp, long extra_delay) exp->exp_obd->obd_eviction_timer = 0; } } - - EXIT; } /** @@ -1259,7 +1247,6 @@ static int ptlrpc_at_send_early_reply(struct ptlrpc_request *req) cfs_duration_t olddl = req->rq_deadline - cfs_time_current_sec(); time_t newdl; int rc; - ENTRY; /* deadline is when the client expects us to reply, margin is the difference between clients' and servers' expectations */ @@ -1270,7 +1257,7 @@ static int ptlrpc_at_send_early_reply(struct ptlrpc_request *req) at_get(&svcpt->scp_at_estimate), at_extra); if (AT_OFF) - RETURN(0); + return 0; if (olddl < 0) { DEBUG_REQ(D_WARNING, req, "Already past deadline (%+lds), " @@ -1278,13 +1265,13 @@ static int ptlrpc_at_send_early_reply(struct ptlrpc_request *req) "at_early_margin (%d)?", olddl, at_early_margin); /* Return an error so we're not re-added to the timed list. */ - RETURN(-ETIMEDOUT); + return -ETIMEDOUT; } if ((lustre_msghdr_get_flags(req->rq_reqmsg) & MSGHDR_AT_SUPPORT) == 0){ DEBUG_REQ(D_INFO, req, "Wanted to ask client for more time, " "but no AT support"); - RETURN(-ENOSYS); + return -ENOSYS; } if (req->rq_export && @@ -1314,18 +1301,18 @@ static int ptlrpc_at_send_early_reply(struct ptlrpc_request *req) olddl, req->rq_arrival_time.tv_sec + at_get(&svcpt->scp_at_estimate) - cfs_time_current_sec()); - RETURN(-ETIMEDOUT); + return -ETIMEDOUT; } } newdl = cfs_time_current_sec() + at_get(&svcpt->scp_at_estimate); OBD_ALLOC(reqcopy, sizeof *reqcopy); if (reqcopy == NULL) - RETURN(-ENOMEM); + return -ENOMEM; OBD_ALLOC_LARGE(reqmsg, req->rq_reqlen); if (!reqmsg) { OBD_FREE(reqcopy, sizeof *reqcopy); - RETURN(-ENOMEM); + return -ENOMEM; } *reqcopy = *req; @@ -1384,7 +1371,7 @@ out: sptlrpc_svc_ctx_decref(reqcopy); OBD_FREE_LARGE(reqmsg, req->rq_reqlen); OBD_FREE(reqcopy, sizeof *reqcopy); - RETURN(rc); + return rc; } /* Send early replies to everybody expiring within at_early_margin @@ -1399,19 +1386,18 @@ static int ptlrpc_at_check_timed(struct ptlrpc_service_part *svcpt) time_t now = cfs_time_current_sec(); cfs_duration_t delay; int first, counter = 0; - ENTRY; spin_lock(&svcpt->scp_at_lock); if (svcpt->scp_at_check == 0) { spin_unlock(&svcpt->scp_at_lock); - RETURN(0); + return 0; } delay = cfs_time_sub(cfs_time_current(), svcpt->scp_at_checktime); svcpt->scp_at_check = 0; if (array->paa_count == 0) { spin_unlock(&svcpt->scp_at_lock); - RETURN(0); + return 0; } /* The timer went off, but maybe the nearest rpc already completed. */ @@ -1420,7 +1406,7 @@ static int ptlrpc_at_check_timed(struct ptlrpc_service_part *svcpt) /* We've still got plenty of time. Reset the timer. */ ptlrpc_at_set_timer(svcpt); spin_unlock(&svcpt->scp_at_lock); - RETURN(0); + return 0; } /* We're close to a timeout, and we don't know how much longer the @@ -1490,7 +1476,7 @@ static int ptlrpc_at_check_timed(struct ptlrpc_service_part *svcpt) ptlrpc_server_drop_request(rq); } - RETURN(1); /* return "did_something" for liblustre */ + return 1; /* return "did_something" for liblustre */ } /** @@ -1501,12 +1487,11 @@ static int ptlrpc_server_hpreq_init(struct ptlrpc_service_part *svcpt, struct ptlrpc_request *req) { int rc = 0; - ENTRY; if (svcpt->scp_service->srv_ops.so_hpreq_handler) { rc = svcpt->scp_service->srv_ops.so_hpreq_handler(req); if (rc < 0) - RETURN(rc); + return rc; LASSERT(rc == 0); } if (req->rq_export && req->rq_ops) { @@ -1527,7 +1512,7 @@ static int ptlrpc_server_hpreq_init(struct ptlrpc_service_part *svcpt, * ost_brw_write(). */ if (rc < 0) - RETURN(rc); + return rc; LASSERT(rc == 0 || rc == 1); } @@ -1539,13 +1524,12 @@ static int ptlrpc_server_hpreq_init(struct ptlrpc_service_part *svcpt, ptlrpc_nrs_req_initialize(svcpt, req, rc); - RETURN(rc); + return rc; } /** Remove the request from the export list. */ static void ptlrpc_server_hpreq_fini(struct ptlrpc_request *req) { - ENTRY; if (req->rq_export && req->rq_ops) { /* refresh lock timeout again so that client has more * room to send lock cancel RPC. */ @@ -1556,7 +1540,6 @@ static void ptlrpc_server_hpreq_fini(struct ptlrpc_request *req) list_del_init(&req->rq_exp_list); spin_unlock_bh(&req->rq_export->exp_rpc_lock); } - EXIT; } static int ptlrpc_hpreq_check(struct ptlrpc_request *req) @@ -1587,15 +1570,14 @@ static int ptlrpc_server_request_add(struct ptlrpc_service_part *svcpt, struct ptlrpc_request *req) { int rc; - ENTRY; rc = ptlrpc_server_hpreq_init(svcpt, req); if (rc < 0) - RETURN(rc); + return rc; ptlrpc_nrs_req_add(svcpt, req, !!rc); - RETURN(0); + return 0; } /** @@ -1701,7 +1683,6 @@ static struct ptlrpc_request * ptlrpc_server_request_get(struct ptlrpc_service_part *svcpt, bool force) { struct ptlrpc_request *req = NULL; - ENTRY; spin_lock(&svcpt->scp_req_lock); @@ -1722,7 +1703,7 @@ ptlrpc_server_request_get(struct ptlrpc_service_part *svcpt, bool force) } spin_unlock(&svcpt->scp_req_lock); - RETURN(NULL); + return NULL; got_request: svcpt->scp_nreqs_active++; @@ -1734,7 +1715,7 @@ got_request: if (likely(req->rq_export)) class_export_rpc_inc(req->rq_export); - RETURN(req); + return req; } /** @@ -1751,12 +1732,11 @@ ptlrpc_server_handle_req_in(struct ptlrpc_service_part *svcpt, struct ptlrpc_request *req; __u32 deadline; int rc; - ENTRY; spin_lock(&svcpt->scp_lock); if (list_empty(&svcpt->scp_req_incoming)) { spin_unlock(&svcpt->scp_lock); - RETURN(0); + return 0; } req = list_entry(svcpt->scp_req_incoming.next, @@ -1875,12 +1855,12 @@ ptlrpc_server_handle_req_in(struct ptlrpc_service_part *svcpt, GOTO(err_req, rc); wake_up(&svcpt->scp_waitq); - RETURN(1); + return 1; err_req: ptlrpc_server_finish_request(svcpt, req); - RETURN(1); + return 1; } /** @@ -1898,11 +1878,10 @@ ptlrpc_server_handle_request(struct ptlrpc_service_part *svcpt, long timediff; int rc; int fail_opc = 0; - ENTRY; request = ptlrpc_server_request_get(svcpt, false); if (request == NULL) - RETURN(0); + return 0; if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_HPREQ_NOTIMEOUT)) fail_opc = OBD_FAIL_PTLRPC_HPREQ_NOTIMEOUT; @@ -2041,7 +2020,7 @@ put_conn: out_req: ptlrpc_server_finish_active_request(svcpt, request); - RETURN(1); + return 1; } /** @@ -2055,7 +2034,6 @@ ptlrpc_handle_rs(struct ptlrpc_reply_state *rs) struct obd_export *exp; int nlocks; int been_handled; - ENTRY; exp = rs->rs_export; @@ -2141,12 +2119,12 @@ ptlrpc_handle_rs(struct ptlrpc_reply_state *rs) if (atomic_dec_and_test(&svcpt->scp_nreps_difficult) && svc->srv_is_stopping) wake_up_all(&svcpt->scp_waitq); - RETURN(1); + return 1; } /* still on the net; callback will schedule */ spin_unlock(&rs->rs_lock); - RETURN(1); + return 1; } @@ -2252,7 +2230,9 @@ ptlrpc_wait_event(struct ptlrpc_service_part *svcpt, struct l_wait_info lwi = LWI_TIMEOUT(svcpt->scp_rqbd_timeout, ptlrpc_retry_rqbds, svcpt); + /* XXX: Add this back when libcfs watchdog is merged upstream lc_watchdog_disable(thread->t_watchdog); + */ cond_resched(); @@ -2266,8 +2246,10 @@ ptlrpc_wait_event(struct ptlrpc_service_part *svcpt, if (ptlrpc_thread_stopping(thread)) return -EINTR; + /* lc_watchdog_touch(thread->t_watchdog, ptlrpc_server_get_timeout(svcpt)); + */ return 0; } @@ -2284,11 +2266,10 @@ static int ptlrpc_main(void *arg) struct ptlrpc_service *svc = svcpt->scp_service; struct ptlrpc_reply_state *rs; #ifdef WITH_GROUP_INFO - group_info_t *ginfo = NULL; + struct group_info *ginfo = NULL; #endif struct lu_env *env; int counter = 0, rc = 0; - ENTRY; thread->t_pid = current_pid(); unshare_fs_struct(); @@ -2370,8 +2351,10 @@ static int ptlrpc_main(void *arg) /* wake up our creator in case he's still waiting. */ wake_up(&thread->t_ctl_waitq); + /* thread->t_watchdog = lc_watchdog_add(ptlrpc_server_get_timeout(svcpt), NULL, NULL); + */ spin_lock(&svcpt->scp_rep_lock); list_add(&rs->rs_list, &svcpt->scp_rep_idle); @@ -2426,8 +2409,10 @@ static int ptlrpc_main(void *arg) } } + /* lc_watchdog_delete(thread->t_watchdog); thread->t_watchdog = NULL; + */ out_srv_fini: /* @@ -2550,7 +2535,6 @@ static int ptlrpc_start_hr_threads(void) struct ptlrpc_hr_partition *hrp; int i; int j; - ENTRY; cfs_percpt_for_each(hrp, i, ptlrpc_hr.hr_partitions) { int rc = 0; @@ -2573,9 +2557,9 @@ static int ptlrpc_start_hr_threads(void) CERROR("Reply handling thread %d:%d Failed on starting: " "rc = %d\n", i, j, rc); ptlrpc_stop_hr_threads(); - RETURN(rc); + return rc; } - RETURN(0); + return 0; } static void ptlrpc_svcpt_stop_threads(struct ptlrpc_service_part *svcpt) @@ -2584,8 +2568,6 @@ static void ptlrpc_svcpt_stop_threads(struct ptlrpc_service_part *svcpt) struct ptlrpc_thread *thread; LIST_HEAD (zombie); - ENTRY; - CDEBUG(D_INFO, "Stopping threads for service %s\n", svcpt->scp_service->srv_name); @@ -2625,7 +2607,6 @@ static void ptlrpc_svcpt_stop_threads(struct ptlrpc_service_part *svcpt) list_del(&thread->t_link); OBD_FREE_PTR(thread); } - EXIT; } /** @@ -2635,14 +2616,11 @@ void ptlrpc_stop_all_threads(struct ptlrpc_service *svc) { struct ptlrpc_service_part *svcpt; int i; - ENTRY; ptlrpc_service_for_each_part(svcpt, i, svc) { if (svcpt->scp_service != NULL) ptlrpc_svcpt_stop_threads(svcpt); } - - EXIT; } EXPORT_SYMBOL(ptlrpc_stop_all_threads); @@ -2651,7 +2629,6 @@ int ptlrpc_start_threads(struct ptlrpc_service *svc) int rc = 0; int i; int j; - ENTRY; /* We require 2 threads min, see note in ptlrpc_server_handle_request */ LASSERT(svc->srv_nthrs_cpt_init >= PTLRPC_NTHRS_INIT); @@ -2669,12 +2646,12 @@ int ptlrpc_start_threads(struct ptlrpc_service *svc) } } - RETURN(0); + return 0; failed: CERROR("cannot start %s thread #%d_%d: rc %d\n", svc->srv_thread_name, i, j, rc); ptlrpc_stop_all_threads(svc); - RETURN(rc); + return rc; } EXPORT_SYMBOL(ptlrpc_start_threads); @@ -2684,7 +2661,6 @@ int ptlrpc_start_thread(struct ptlrpc_service_part *svcpt, int wait) struct ptlrpc_thread *thread; struct ptlrpc_service *svc; int rc; - ENTRY; LASSERT(svcpt != NULL); @@ -2696,23 +2672,23 @@ int ptlrpc_start_thread(struct ptlrpc_service_part *svcpt, int wait) again: if (unlikely(svc->srv_is_stopping)) - RETURN(-ESRCH); + return -ESRCH; if (!ptlrpc_threads_increasable(svcpt) || (OBD_FAIL_CHECK(OBD_FAIL_TGT_TOOMANY_THREADS) && svcpt->scp_nthrs_running == svc->srv_nthrs_cpt_init - 1)) - RETURN(-EMFILE); + return -EMFILE; OBD_CPT_ALLOC_PTR(thread, svc->srv_cptable, svcpt->scp_cpt); if (thread == NULL) - RETURN(-ENOMEM); + return -ENOMEM; init_waitqueue_head(&thread->t_ctl_waitq); spin_lock(&svcpt->scp_lock); if (!ptlrpc_threads_increasable(svcpt)) { spin_unlock(&svcpt->scp_lock); OBD_FREE_PTR(thread); - RETURN(-EMFILE); + return -EMFILE; } if (svcpt->scp_nthrs_starting != 0) { @@ -2730,7 +2706,7 @@ int ptlrpc_start_thread(struct ptlrpc_service_part *svcpt, int wait) CDEBUG(D_INFO, "Creating thread %s #%d race, retry later\n", svc->srv_thread_name, svcpt->scp_thr_nextid); - RETURN(-EAGAIN); + return -EAGAIN; } svcpt->scp_nthrs_starting++; @@ -2742,46 +2718,55 @@ int ptlrpc_start_thread(struct ptlrpc_service_part *svcpt, int wait) spin_unlock(&svcpt->scp_lock); if (svcpt->scp_cpt >= 0) { - snprintf(thread->t_name, PTLRPC_THR_NAME_LEN, "%s%02d_%03d", + snprintf(thread->t_name, sizeof(thread->t_name), "%s%02d_%03d", svc->srv_thread_name, svcpt->scp_cpt, thread->t_id); } else { - snprintf(thread->t_name, PTLRPC_THR_NAME_LEN, "%s_%04d", + snprintf(thread->t_name, sizeof(thread->t_name), "%s_%04d", svc->srv_thread_name, thread->t_id); } CDEBUG(D_RPCTRACE, "starting thread '%s'\n", thread->t_name); - rc = PTR_ERR(kthread_run(ptlrpc_main, thread, thread->t_name)); + rc = PTR_ERR(kthread_run(ptlrpc_main, thread, "%s", thread->t_name)); if (IS_ERR_VALUE(rc)) { CERROR("cannot start thread '%s': rc %d\n", thread->t_name, rc); spin_lock(&svcpt->scp_lock); - list_del(&thread->t_link); --svcpt->scp_nthrs_starting; - spin_unlock(&svcpt->scp_lock); - - OBD_FREE(thread, sizeof(*thread)); - RETURN(rc); + if (thread_is_stopping(thread)) { + /* this ptlrpc_thread is being hanled + * by ptlrpc_svcpt_stop_threads now + */ + thread_add_flags(thread, SVC_STOPPED); + wake_up(&thread->t_ctl_waitq); + spin_unlock(&svcpt->scp_lock); + } else { + list_del(&thread->t_link); + spin_unlock(&svcpt->scp_lock); + OBD_FREE_PTR(thread); + } + return rc; } if (!wait) - RETURN(0); + return 0; l_wait_event(thread->t_ctl_waitq, thread_is_running(thread) || thread_is_stopped(thread), &lwi); rc = thread_is_stopped(thread) ? thread->t_id : 0; - RETURN(rc); + return rc; } int ptlrpc_hr_init(void) { + cpumask_t mask; struct ptlrpc_hr_partition *hrp; struct ptlrpc_hr_thread *hrt; int rc; int i; int j; - ENTRY; + int weight; memset(&ptlrpc_hr, 0, sizeof(ptlrpc_hr)); ptlrpc_hr.hr_cpt_table = cfs_cpt_table; @@ -2789,10 +2774,13 @@ int ptlrpc_hr_init(void) ptlrpc_hr.hr_partitions = cfs_percpt_alloc(ptlrpc_hr.hr_cpt_table, sizeof(*hrp)); if (ptlrpc_hr.hr_partitions == NULL) - RETURN(-ENOMEM); + return -ENOMEM; init_waitqueue_head(&ptlrpc_hr.hr_waitq); + cpumask_copy(&mask, topology_thread_cpumask(0)); + weight = cpus_weight(mask); + cfs_percpt_for_each(hrp, i, ptlrpc_hr.hr_partitions) { hrp->hrp_cpt = i; @@ -2800,7 +2788,7 @@ int ptlrpc_hr_init(void) atomic_set(&hrp->hrp_nstopped, 0); hrp->hrp_nthrs = cfs_cpt_weight(ptlrpc_hr.hr_cpt_table, i); - hrp->hrp_nthrs /= cfs_cpu_ht_nsiblings(0); + hrp->hrp_nthrs /= weight; LASSERT(hrp->hrp_nthrs > 0); OBD_CPT_ALLOC(hrp->hrp_thrs, ptlrpc_hr.hr_cpt_table, i, @@ -2823,7 +2811,7 @@ int ptlrpc_hr_init(void) out: if (rc != 0) ptlrpc_hr_fini(); - RETURN(rc); + return rc; } void ptlrpc_hr_fini(void) @@ -3045,8 +3033,6 @@ ptlrpc_service_free(struct ptlrpc_service *svc) int ptlrpc_unregister_service(struct ptlrpc_service *service) { - ENTRY; - CDEBUG(D_NET, "%s: tearing down\n", service->srv_name); service->srv_is_stopping = 1; @@ -3066,7 +3052,7 @@ int ptlrpc_unregister_service(struct ptlrpc_service *service) ptlrpc_service_free(service); - RETURN(0); + return 0; } EXPORT_SYMBOL(ptlrpc_unregister_service); |