X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fptlrpc%2Flproc_ptlrpc.c;h=b42c41b2109b221575d371cba03f58d09ff51afa;hb=408c61bd36c1cf41a432e152de9891bcd0c3e49f;hp=7303382238fbc873f4c2f97a6b02237dfe1c3b75;hpb=aba694d9e9112867b04cd30a083cee0da5c8754f;p=fs%2Flustre-release.git diff --git a/lustre/ptlrpc/lproc_ptlrpc.c b/lustre/ptlrpc/lproc_ptlrpc.c index 7303382..b42c41b 100644 --- a/lustre/ptlrpc/lproc_ptlrpc.c +++ b/lustre/ptlrpc/lproc_ptlrpc.c @@ -26,7 +26,7 @@ * GPL HEADER END */ /* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. */ /* @@ -93,12 +93,14 @@ struct ll_rpc_opcode { { MDS_SETXATTR, "mds_setxattr" }, { MDS_WRITEPAGE, "mds_writepage" }, { MDS_IS_SUBDIR, "mds_is_subdir" }, + { MDS_GET_INFO, "mds_get_info" }, { LDLM_ENQUEUE, "ldlm_enqueue" }, { LDLM_CONVERT, "ldlm_convert" }, { LDLM_CANCEL, "ldlm_cancel" }, { LDLM_BL_CALLBACK, "ldlm_bl_callback" }, { LDLM_CP_CALLBACK, "ldlm_cp_callback" }, { LDLM_GL_CALLBACK, "ldlm_gl_callback" }, + { LDLM_SET_INFO, "ldlm_set_info" }, { MGS_CONNECT, "mgs_connect" }, { MGS_DISCONNECT, "mgs_disconnect" }, { MGS_EXCEPTION, "mgs_exception" }, @@ -282,12 +284,87 @@ ptlrpc_lprocfs_write_req_history_max(struct file *file, const char *buffer, * hose a kernel by allowing the request history to grow too * far. */ bufpages = (svc->srv_buf_size + CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT; - if (val > num_physpages/(2 * bufpages)) + if (val > cfs_num_physpages/(2 * bufpages)) return -ERANGE; - spin_lock(&svc->srv_lock); + cfs_spin_lock(&svc->srv_lock); svc->srv_max_history_rqbds = val; - spin_unlock(&svc->srv_lock); + cfs_spin_unlock(&svc->srv_lock); + + return count; +} + +static int +ptlrpc_lprocfs_rd_threads_min(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct ptlrpc_service *svc = data; + + return snprintf(page, count, "%d\n", svc->srv_threads_min); +} + +static int +ptlrpc_lprocfs_wr_threads_min(struct file *file, const char *buffer, + unsigned long count, void *data) +{ + struct ptlrpc_service *svc = data; + int val; + int rc = lprocfs_write_helper(buffer, count, &val); + + if (rc < 0) + return rc; + + if (val < 2) + return -ERANGE; + + if (val > svc->srv_threads_max) + return -ERANGE; + + cfs_spin_lock(&svc->srv_lock); + svc->srv_threads_min = val; + cfs_spin_unlock(&svc->srv_lock); + + return count; +} + +static int +ptlrpc_lprocfs_rd_threads_started(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct ptlrpc_service *svc = data; + + return snprintf(page, count, "%d\n", svc->srv_threads_running); +} + +static int +ptlrpc_lprocfs_rd_threads_max(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct ptlrpc_service *svc = data; + + return snprintf(page, count, "%d\n", svc->srv_threads_max); +} + +static int +ptlrpc_lprocfs_wr_threads_max(struct file *file, const char *buffer, + unsigned long count, void *data) +{ + struct ptlrpc_service *svc = data; + int val; + int rc = lprocfs_write_helper(buffer, count, &val); + + if (rc < 0) + return rc; + + if (val < 2) + return -ERANGE; + + if (val < svc->srv_threads_min) + return -ERANGE; + + cfs_spin_lock(&svc->srv_lock); + svc->srv_threads_max = val; + cfs_spin_unlock(&svc->srv_lock); return count; } @@ -302,7 +379,7 @@ ptlrpc_lprocfs_svc_req_history_seek(struct ptlrpc_service *svc, struct ptlrpc_srh_iterator *srhi, __u64 seq) { - struct list_head *e; + cfs_list_t *e; struct ptlrpc_request *req; if (srhi->srhi_req != NULL && @@ -315,7 +392,7 @@ ptlrpc_lprocfs_svc_req_history_seek(struct ptlrpc_service *svc, * be near the head), we shouldn't have to do long * re-scans */ LASSERT (srhi->srhi_seq == srhi->srhi_req->rq_history_seq); - LASSERT (!list_empty(&svc->srv_request_history)); + LASSERT (!cfs_list_empty(&svc->srv_request_history)); e = &srhi->srhi_req->rq_history_list; } else { /* search from start */ @@ -323,7 +400,7 @@ ptlrpc_lprocfs_svc_req_history_seek(struct ptlrpc_service *svc, } while (e != &svc->srv_request_history) { - req = list_entry(e, struct ptlrpc_request, rq_history_list); + req = cfs_list_entry(e, struct ptlrpc_request, rq_history_list); if (req->rq_history_seq >= seq) { srhi->srhi_seq = req->rq_history_seq; @@ -350,9 +427,9 @@ ptlrpc_lprocfs_svc_req_history_start(struct seq_file *s, loff_t *pos) srhi->srhi_seq = 0; srhi->srhi_req = NULL; - spin_lock(&svc->srv_lock); + cfs_spin_lock(&svc->srv_lock); rc = ptlrpc_lprocfs_svc_req_history_seek(svc, srhi, *pos); - spin_unlock(&svc->srv_lock); + cfs_spin_unlock(&svc->srv_lock); if (rc == 0) { *pos = srhi->srhi_seq; @@ -380,9 +457,9 @@ ptlrpc_lprocfs_svc_req_history_next(struct seq_file *s, struct ptlrpc_srh_iterator *srhi = iter; int rc; - spin_lock(&svc->srv_lock); + cfs_spin_lock(&svc->srv_lock); rc = ptlrpc_lprocfs_svc_req_history_seek(svc, srhi, *pos + 1); - spin_unlock(&svc->srv_lock); + cfs_spin_unlock(&svc->srv_lock); if (rc != 0) { OBD_FREE(srhi, sizeof(*srhi)); @@ -393,7 +470,7 @@ ptlrpc_lprocfs_svc_req_history_next(struct seq_file *s, return srhi; } -/* common ost/mdt srv_request_history_print_fn */ +/* common ost/mdt srv_req_printfn */ void target_print_req(void *seq_file, struct ptlrpc_request *req) { /* Called holding srv_lock with irqs disabled. @@ -430,7 +507,7 @@ static int ptlrpc_lprocfs_svc_req_history_show(struct seq_file *s, void *iter) struct ptlrpc_request *req; int rc; - spin_lock(&svc->srv_lock); + cfs_spin_lock(&svc->srv_lock); rc = ptlrpc_lprocfs_svc_req_history_seek(svc, srhi, srhi->srhi_seq); @@ -443,20 +520,20 @@ static int ptlrpc_lprocfs_svc_req_history_show(struct seq_file *s, void *iter) * must be just as careful as the service's request * parser. Currently I only print stuff here I know is OK * to look at coz it was set up in request_in_callback()!!! */ - seq_printf(s, LPD64":%s:%s:x"LPD64":%d:%s:%ld:%lds(%+lds) ", + seq_printf(s, LPD64":%s:%s:x"LPU64":%d:%s:%ld:%lds(%+lds) ", req->rq_history_seq, libcfs_nid2str(req->rq_self), libcfs_id2str(req->rq_peer), req->rq_xid, req->rq_reqlen, ptlrpc_rqphase2str(req), req->rq_arrival_time.tv_sec, req->rq_sent - req->rq_arrival_time.tv_sec, req->rq_sent - req->rq_deadline); - if (svc->srv_request_history_print_fn == NULL) + if (svc->srv_req_printfn == NULL) seq_printf(s, "\n"); else - svc->srv_request_history_print_fn(s, srhi->srhi_req); + svc->srv_req_printfn(s, srhi->srhi_req); } - spin_unlock(&svc->srv_lock); + cfs_spin_unlock(&svc->srv_lock); return rc; } @@ -527,16 +604,16 @@ static int ptlrpc_lprocfs_wr_hp_ratio(struct file *file, const char *buffer, { struct ptlrpc_service *svc = data; int rc, val; - + rc = lprocfs_write_helper(buffer, count, &val); if (rc < 0) return rc; if (val < 0) return -ERANGE; - spin_lock(&svc->srv_lock); + cfs_spin_lock(&svc->srv_lock); svc->srv_hpreq_ratio = val; - spin_unlock(&svc->srv_lock); + cfs_spin_unlock(&svc->srv_lock); return count; } @@ -544,21 +621,31 @@ void ptlrpc_lprocfs_register_service(struct proc_dir_entry *entry, struct ptlrpc_service *svc) { struct lprocfs_vars lproc_vars[] = { + {.name = "high_priority_ratio", + .read_fptr = ptlrpc_lprocfs_rd_hp_ratio, + .write_fptr = ptlrpc_lprocfs_wr_hp_ratio, + .data = svc}, {.name = "req_buffer_history_len", - .write_fptr = NULL, .read_fptr = ptlrpc_lprocfs_read_req_history_len, .data = svc}, {.name = "req_buffer_history_max", .write_fptr = ptlrpc_lprocfs_write_req_history_max, .read_fptr = ptlrpc_lprocfs_read_req_history_max, .data = svc}, + {.name = "threads_min", + .read_fptr = ptlrpc_lprocfs_rd_threads_min, + .write_fptr = ptlrpc_lprocfs_wr_threads_min, + .data = svc}, + {.name = "threads_max", + .read_fptr = ptlrpc_lprocfs_rd_threads_max, + .write_fptr = ptlrpc_lprocfs_wr_threads_max, + .data = svc}, + {.name = "threads_started", + .read_fptr = ptlrpc_lprocfs_rd_threads_started, + .data = svc}, {.name = "timeouts", .read_fptr = ptlrpc_lprocfs_rd_timeouts, .data = svc}, - {.name = "high_priority_ratio", - .read_fptr = ptlrpc_lprocfs_rd_hp_ratio, - .write_fptr = ptlrpc_lprocfs_wr_hp_ratio, - .data = svc}, {NULL} }; static struct file_operations req_history_fops = { @@ -594,7 +681,7 @@ void ptlrpc_lprocfs_register_obd(struct obd_device *obddev) } EXPORT_SYMBOL(ptlrpc_lprocfs_register_obd); -void ptlrpc_lprocfs_rpc_sent(struct ptlrpc_request *req) +void ptlrpc_lprocfs_rpc_sent(struct ptlrpc_request *req, long amount) { struct lprocfs_stats *svc_stats; __u32 op = lustre_msg_get_opc(req->rq_reqmsg); @@ -605,7 +692,7 @@ void ptlrpc_lprocfs_rpc_sent(struct ptlrpc_request *req) return; LASSERT(opc < LUSTRE_MAX_OPCODES); if (!(op == LDLM_ENQUEUE || op == MDS_REINT)) - lprocfs_counter_add(svc_stats, opc + EXTRA_MAX_OPCODES, 0); + lprocfs_counter_add(svc_stats, opc + EXTRA_MAX_OPCODES, amount); } void ptlrpc_lprocfs_brw(struct ptlrpc_request *req, int bytes)