X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fptlrpc%2Flproc_ptlrpc.c;h=266e1c12b191762770028d5774b59b9eae4930c9;hp=95b167d4ae2fd8ff520a7b9aadfc999390d4ac21;hb=917655fc2938b90a9c246dd2d58408c42aa1658d;hpb=b27575d1b91d93c0f3f7f4e4a9744db37686a504 diff --git a/lustre/ptlrpc/lproc_ptlrpc.c b/lustre/ptlrpc/lproc_ptlrpc.c index 95b167d..266e1c1 100644 --- a/lustre/ptlrpc/lproc_ptlrpc.c +++ b/lustre/ptlrpc/lproc_ptlrpc.c @@ -23,7 +23,7 @@ * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2016, Intel Corporation. + * Copyright (c) 2011, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -95,6 +95,7 @@ static struct ll_rpc_opcode { { MDS_HSM_CT_REGISTER, "mds_hsm_ct_register" }, { MDS_HSM_CT_UNREGISTER, "mds_hsm_ct_unregister" }, { MDS_SWAP_LAYOUTS, "mds_swap_layouts" }, + { MDS_RMFID, "mds_rmfid" }, { LDLM_ENQUEUE, "ldlm_enqueue" }, { LDLM_CONVERT, "ldlm_convert" }, { LDLM_CANCEL, "ldlm_cancel" }, @@ -109,17 +110,17 @@ static struct ll_rpc_opcode { { MGS_TARGET_DEL, "mgs_target_del" }, { MGS_SET_INFO, "mgs_set_info" }, { MGS_CONFIG_READ, "mgs_config_read" }, - { OBD_PING, "obd_ping" }, - { OBD_LOG_CANCEL, "llog_cancel" }, - { OBD_QC_CALLBACK, "obd_quota_callback" }, - { OBD_IDX_READ, "dt_index_read" }, + { OBD_PING, "obd_ping" }, + { 401, /* was OBD_LOG_CANCEL */ "llog_cancel" }, + { 402, /* was OBD_QC_CALLBACK */ "obd_quota_callback" }, + { OBD_IDX_READ, "dt_index_read" }, { LLOG_ORIGIN_HANDLE_CREATE, "llog_origin_handle_open" }, { LLOG_ORIGIN_HANDLE_NEXT_BLOCK, "llog_origin_handle_next_block" }, { LLOG_ORIGIN_HANDLE_READ_HEADER,"llog_origin_handle_read_header" }, - { LLOG_ORIGIN_HANDLE_WRITE_REC, "llog_origin_handle_write_rec" }, - { LLOG_ORIGIN_HANDLE_CLOSE, "llog_origin_handle_close" }, - { LLOG_ORIGIN_CONNECT, "llog_origin_connect" }, - { LLOG_CATINFO, "llog_catinfo" }, + { 504, /*LLOG_ORIGIN_HANDLE_WRITE_REC*/"llog_origin_handle_write_rec" }, + { 505, /* was LLOG_ORIGIN_HANDLE_CLOSE */ "llog_origin_handle_close" }, + { 506, /* was LLOG_ORIGIN_CONNECT */ "llog_origin_connect" }, + { 507, /* was LLOG_CATINFO */ "llog_catinfo" }, { LLOG_ORIGIN_HANDLE_PREV_BLOCK, "llog_origin_handle_prev_block" }, { LLOG_ORIGIN_HANDLE_DESTROY, "llog_origin_handle_destroy" }, { QUOTA_DQACQ, "quota_acquire" }, @@ -139,20 +140,21 @@ static struct ll_eopcode { __u32 opcode; const char *opname; } ll_eopcode_table[EXTRA_LAST_OPC] = { - { LDLM_GLIMPSE_ENQUEUE, "ldlm_glimpse_enqueue" }, - { LDLM_PLAIN_ENQUEUE, "ldlm_plain_enqueue" }, - { LDLM_EXTENT_ENQUEUE, "ldlm_extent_enqueue" }, - { LDLM_FLOCK_ENQUEUE, "ldlm_flock_enqueue" }, - { LDLM_IBITS_ENQUEUE, "ldlm_ibits_enqueue" }, - { MDS_REINT_SETATTR, "mds_reint_setattr" }, - { MDS_REINT_CREATE, "mds_reint_create" }, - { MDS_REINT_LINK, "mds_reint_link" }, - { MDS_REINT_UNLINK, "mds_reint_unlink" }, - { MDS_REINT_RENAME, "mds_reint_rename" }, - { MDS_REINT_OPEN, "mds_reint_open" }, - { MDS_REINT_SETXATTR, "mds_reint_setxattr" }, - { BRW_READ_BYTES, "read_bytes" }, - { BRW_WRITE_BYTES, "write_bytes" }, + { LDLM_GLIMPSE_ENQUEUE, "ldlm_glimpse_enqueue" }, + { LDLM_PLAIN_ENQUEUE, "ldlm_plain_enqueue" }, + { LDLM_EXTENT_ENQUEUE, "ldlm_extent_enqueue" }, + { LDLM_FLOCK_ENQUEUE, "ldlm_flock_enqueue" }, + { LDLM_IBITS_ENQUEUE, "ldlm_ibits_enqueue" }, + { MDS_REINT_SETATTR, "mds_reint_setattr" }, + { MDS_REINT_CREATE, "mds_reint_create" }, + { MDS_REINT_LINK, "mds_reint_link" }, + { MDS_REINT_UNLINK, "mds_reint_unlink" }, + { MDS_REINT_RENAME, "mds_reint_rename" }, + { MDS_REINT_OPEN, "mds_reint_open" }, + { MDS_REINT_SETXATTR, "mds_reint_setxattr" }, + { MDS_REINT_RESYNC, "mds_reint_resync" }, + { BRW_READ_BYTES, "read_bytes" }, + { BRW_WRITE_BYTES, "write_bytes" }, }; const char *ll_opcode2str(__u32 opcode) @@ -193,32 +195,33 @@ static const char *ll_eopcode2str(__u32 opcode) return ll_eopcode_table[opcode].opname; } -#ifdef CONFIG_PROC_FS -static void ptlrpc_lprocfs_register(struct proc_dir_entry *root, char *dir, - char *name, struct proc_dir_entry **procroot_ret, - struct lprocfs_stats **stats_ret) +static void +ptlrpc_ldebugfs_register(struct dentry *root, char *dir, char *name, + struct dentry **debugfs_root_ret, + struct lprocfs_stats **stats_ret) { - struct proc_dir_entry *svc_procroot; + struct dentry *svc_debugfs_entry; struct lprocfs_stats *svc_stats; int i, rc; unsigned int svc_counter_config = LPROCFS_CNTR_AVGMINMAX | LPROCFS_CNTR_STDDEV; - LASSERT(*procroot_ret == NULL); - LASSERT(*stats_ret == NULL); + LASSERT(!*debugfs_root_ret); + LASSERT(!*stats_ret); - svc_stats = lprocfs_alloc_stats(EXTRA_MAX_OPCODES+LUSTRE_MAX_OPCODES,0); - if (svc_stats == NULL) + svc_stats = lprocfs_alloc_stats(EXTRA_MAX_OPCODES + LUSTRE_MAX_OPCODES, + 0); + if (!svc_stats) return; if (dir) { - svc_procroot = lprocfs_register(dir, root, NULL, NULL); - if (IS_ERR(svc_procroot)) { + svc_debugfs_entry = ldebugfs_register(dir, root, NULL, NULL); + if (IS_ERR(svc_debugfs_entry)) { lprocfs_free_stats(&svc_stats); return; } } else { - svc_procroot = root; + svc_debugfs_entry = root; } lprocfs_counter_init(svc_stats, PTLRPC_REQWAIT_CNTR, @@ -234,7 +237,7 @@ static void ptlrpc_lprocfs_register(struct proc_dir_entry *root, char *dir, for (i = 0; i < EXTRA_LAST_OPC; i++) { char *units; - switch(i) { + switch (i) { case BRW_WRITE_BYTES: case BRW_READ_BYTES: units = "bytes"; @@ -254,16 +257,16 @@ static void ptlrpc_lprocfs_register(struct proc_dir_entry *root, char *dir, ll_opcode2str(opcode), "usec"); } - rc = lprocfs_register_stats(svc_procroot, name, svc_stats); - if (rc < 0) { - if (dir) - lprocfs_remove(&svc_procroot); - lprocfs_free_stats(&svc_stats); - } else { - if (dir) - *procroot_ret = svc_procroot; - *stats_ret = svc_stats; - } + rc = ldebugfs_register_stats(svc_debugfs_entry, name, svc_stats); + if (rc < 0) { + if (dir) + debugfs_remove_recursive(svc_debugfs_entry); + lprocfs_free_stats(&svc_stats); + } else { + if (dir) + *debugfs_root_ret = svc_debugfs_entry; + *stats_ret = svc_stats; + } } static int @@ -280,7 +283,9 @@ ptlrpc_lprocfs_req_history_len_seq_show(struct seq_file *m, void *v) seq_printf(m, "%d\n", total); return 0; } -LPROC_SEQ_FOPS_RO(ptlrpc_lprocfs_req_history_len); + + +LDEBUGFS_SEQ_FOPS_RO(ptlrpc_lprocfs_req_history_len); static int ptlrpc_lprocfs_req_history_max_seq_show(struct seq_file *m, void *n) @@ -304,11 +309,12 @@ ptlrpc_lprocfs_req_history_max_seq_write(struct file *file, { struct seq_file *m = file->private_data; struct ptlrpc_service *svc = m->private; + unsigned long long val; + unsigned long long limit; int bufpages; - __s64 val; int rc; - rc = lprocfs_str_to_s64(buffer, count, &val); + rc = kstrtoull_from_user(buffer, count, 0, &val); if (rc < 0) return rc; @@ -317,10 +323,15 @@ ptlrpc_lprocfs_req_history_max_seq_write(struct file *file, /* This sanity check is more of an insanity check; we can still * hose a kernel by allowing the request history to grow too - * far. */ - bufpages = (svc->srv_buf_size + PAGE_SIZE - 1) >> + * far. The roundup to the next power of two is an empirical way + * to take care that request buffer is allocated in Slab and thus + * will be upgraded */ + bufpages = (roundup_pow_of_two(svc->srv_buf_size) + PAGE_SIZE - 1) >> PAGE_SHIFT; - if (val > totalram_pages/(2 * bufpages)) + limit = cfs_totalram_pages() / (2 * bufpages); + /* do not allow history to consume more than half max number of rqbds */ + if ((svc->srv_nrqbds_max == 0 && val > limit) || + (svc->srv_nrqbds_max != 0 && val > svc->srv_nrqbds_max / 2)) return -ERANGE; spin_lock(&svc->srv_lock); @@ -335,7 +346,45 @@ ptlrpc_lprocfs_req_history_max_seq_write(struct file *file, return count; } -LPROC_SEQ_FOPS(ptlrpc_lprocfs_req_history_max); + +LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_req_history_max); + +static int +ptlrpc_lprocfs_req_buffers_max_seq_show(struct seq_file *m, void *n) +{ + struct ptlrpc_service *svc = m->private; + + seq_printf(m, "%d\n", svc->srv_nrqbds_max); + return 0; +} + +static ssize_t +ptlrpc_lprocfs_req_buffers_max_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) +{ + struct seq_file *m = file->private_data; + struct ptlrpc_service *svc = m->private; + int val; + int rc; + + rc = kstrtoint_from_user(buffer, count, 0, &val); + if (rc < 0) + return rc; + + if (val < svc->srv_nbuf_per_group && val != 0) + return -ERANGE; + + spin_lock(&svc->srv_lock); + + svc->srv_nrqbds_max = (uint)val; + + spin_unlock(&svc->srv_lock); + + return count; +} + +LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_req_buffers_max); static ssize_t threads_min_show(struct kobject *kobj, struct attribute *attr, char *buf) @@ -468,7 +517,7 @@ void nrs_policy_get_info_locked(struct ptlrpc_nrs_policy *policy, LASSERT(info != NULL); assert_spin_locked(&policy->pol_nrs->nrs_lock); - CLASSERT(sizeof(info->pi_arg) == sizeof(policy->pol_arg)); + BUILD_BUG_ON(sizeof(info->pi_arg) != sizeof(policy->pol_arg)); memcpy(info->pi_name, policy->pol_desc->pd_name, NRS_POL_NAME_MAX); memcpy(info->pi_arg, policy->pol_arg, sizeof(policy->pol_arg)); @@ -743,7 +792,8 @@ out: RETURN(rc < 0 ? rc : count); } -LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs); + +LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_nrs); /** @} nrs */ @@ -863,10 +913,12 @@ ptlrpc_lprocfs_svc_req_history_start(struct seq_file *s, loff_t *pos) if (i > cpt) /* make up the lowest position for this CPT */ *pos = PTLRPC_REQ_CPT2POS(svc, i); + mutex_lock(&svcpt->scp_mutex); spin_lock(&svcpt->scp_lock); rc = ptlrpc_lprocfs_svc_req_history_seek(svcpt, srhi, PTLRPC_REQ_POS2SEQ(svc, *pos)); spin_unlock(&svcpt->scp_lock); + mutex_unlock(&svcpt->scp_mutex); if (rc == 0) { *pos = PTLRPC_REQ_SEQ2POS(svc, srhi->srhi_seq); srhi->srhi_idx = i; @@ -908,9 +960,11 @@ ptlrpc_lprocfs_svc_req_history_next(struct seq_file *s, seq = srhi->srhi_seq + (1 << svc->srv_cpt_bits); } + mutex_lock(&svcpt->scp_mutex); spin_lock(&svcpt->scp_lock); rc = ptlrpc_lprocfs_svc_req_history_seek(svcpt, srhi, seq); spin_unlock(&svcpt->scp_lock); + mutex_unlock(&svcpt->scp_mutex); if (rc == 0) { *pos = PTLRPC_REQ_SEQ2POS(svc, srhi->srhi_seq); srhi->srhi_idx = i; @@ -964,6 +1018,7 @@ static int ptlrpc_lprocfs_svc_req_history_show(struct seq_file *s, void *iter) svcpt = svc->srv_parts[srhi->srhi_idx]; + mutex_lock(&svcpt->scp_mutex); spin_lock(&svcpt->scp_lock); rc = ptlrpc_lprocfs_svc_req_history_seek(svcpt, srhi, srhi->srhi_seq); @@ -1004,6 +1059,8 @@ static int ptlrpc_lprocfs_svc_req_history_show(struct seq_file *s, void *iter) } spin_unlock(&svcpt->scp_lock); + mutex_unlock(&svcpt->scp_mutex); + return rc; } @@ -1028,7 +1085,7 @@ ptlrpc_lprocfs_svc_req_history_open(struct inode *inode, struct file *file) return rc; seqf = file->private_data; - seqf->private = PDE_DATA(inode); + seqf->private = inode->i_private; return 0; } @@ -1062,7 +1119,8 @@ static int ptlrpc_lprocfs_timeouts_seq_show(struct seq_file *m, void *n) return 0; } -LPROC_SEQ_FOPS_RO(ptlrpc_lprocfs_timeouts); + +LDEBUGFS_SEQ_FOPS_RO(ptlrpc_lprocfs_timeouts); static ssize_t high_priority_ratio_show(struct kobject *kobj, struct attribute *attr, @@ -1136,8 +1194,8 @@ int ptlrpc_sysfs_register_service(struct kset *parent, &parent->kobj, "%s", svc->srv_name); } -void ptlrpc_lprocfs_register_service(struct proc_dir_entry *entry, - struct ptlrpc_service *svc) +void ptlrpc_ldebugfs_register_service(struct dentry *entry, + struct ptlrpc_service *svc) { struct lprocfs_vars lproc_vars[] = { { .name = "req_buffer_history_len", @@ -1152,6 +1210,9 @@ void ptlrpc_lprocfs_register_service(struct proc_dir_entry *entry, { .name = "nrs_policies", .fops = &ptlrpc_lprocfs_nrs_fops, .data = svc }, + { .name = "req_buffers_max", + .fops = &ptlrpc_lprocfs_req_buffers_max_fops, + .data = svc }, { NULL } }; static struct file_operations req_history_fops = { @@ -1164,25 +1225,24 @@ void ptlrpc_lprocfs_register_service(struct proc_dir_entry *entry, int rc; - ptlrpc_lprocfs_register(entry, svc->srv_name, - "stats", &svc->srv_procroot, - &svc->srv_stats); - if (svc->srv_procroot == NULL) + ptlrpc_ldebugfs_register(entry, svc->srv_name, "stats", + &svc->srv_debugfs_entry, &svc->srv_stats); + if (!svc->srv_debugfs_entry) return; - lprocfs_add_vars(svc->srv_procroot, lproc_vars, NULL); + ldebugfs_add_vars(svc->srv_debugfs_entry, lproc_vars, NULL); - rc = lprocfs_seq_create(svc->srv_procroot, "req_history", - 0400, &req_history_fops, svc); + rc = ldebugfs_seq_create(svc->srv_debugfs_entry, "req_history", + 0400, &req_history_fops, svc); if (rc) CWARN("Error adding the req_history file\n"); } void ptlrpc_lprocfs_register_obd(struct obd_device *obddev) { - ptlrpc_lprocfs_register(obddev->obd_proc_entry, NULL, "stats", - &obddev->obd_svc_procroot, - &obddev->obd_svc_stats); + ptlrpc_ldebugfs_register(obddev->obd_debugfs_entry, NULL, "stats", + &obddev->obd_svc_debugfs_entry, + &obddev->obd_svc_stats); } EXPORT_SYMBOL(ptlrpc_lprocfs_register_obd); @@ -1230,49 +1290,57 @@ EXPORT_SYMBOL(ptlrpc_lprocfs_brw); void ptlrpc_lprocfs_unregister_service(struct ptlrpc_service *svc) { - if (svc->srv_procroot != NULL) - lprocfs_remove(&svc->srv_procroot); + debugfs_remove_recursive(svc->srv_debugfs_entry); - if (svc->srv_stats) - lprocfs_free_stats(&svc->srv_stats); + if (svc->srv_stats) + lprocfs_free_stats(&svc->srv_stats); } void ptlrpc_lprocfs_unregister_obd(struct obd_device *obd) { - if (obd->obd_svc_procroot) - lprocfs_remove(&obd->obd_svc_procroot); + /* cleanup first to allow concurrent access to device's + * stats via debugfs to complete safely + */ + lprocfs_obd_cleanup(obd); - if (obd->obd_svc_stats) - lprocfs_free_stats(&obd->obd_svc_stats); + debugfs_remove_recursive(obd->obd_svc_debugfs_entry); + + if (obd->obd_svc_stats) + lprocfs_free_stats(&obd->obd_svc_stats); } EXPORT_SYMBOL(ptlrpc_lprocfs_unregister_obd); -ssize_t -lprocfs_ping_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) +ssize_t ping_show(struct kobject *kobj, struct attribute *attr, + char *buffer) { - struct seq_file *m = file->private_data; - struct obd_device *obd = m->private; - struct ptlrpc_request *req; - int rc; - ENTRY; + struct obd_device *obd = container_of(kobj, struct obd_device, + obd_kset.kobj); + 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) + if (!req) RETURN(-ENOMEM); req->rq_send_state = LUSTRE_IMP_FULL; rc = ptlrpc_queue_wait(req); - ptlrpc_req_finished(req); - if (rc >= 0) - RETURN(count); + RETURN(rc); } -EXPORT_SYMBOL(lprocfs_ping_seq_write); +EXPORT_SYMBOL(ping_show); + +/* kept for older verison of tools. */ +ssize_t ping_store(struct kobject *kobj, struct attribute *attr, + const char *buffer, size_t count) +{ + return ping_show(kobj, attr, (char *)buffer); +} +EXPORT_SYMBOL(ping_store); /* Write the connection UUID to this file to attempt to connect to that node. * The connection UUID is a node's primary NID. For example, @@ -1308,17 +1376,19 @@ lprocfs_import_seq_write(struct file *file, const char __user *buffer, if (strncmp(prefix, kbuf, prefix_len) != 0) GOTO(out, count = -EINVAL); + LPROCFS_CLIMP_CHECK(obd); + uuid = kbuf + prefix_len; ptr = strstr(uuid, "::"); if (ptr) { - __u32 inst; - char *endptr; + u32 inst; + int rc; *ptr = 0; do_reconn = 0; ptr += 2; /* Skip :: */ - inst = simple_strtol(ptr, &endptr, 10); - if (*endptr) { + rc = kstrtouint(ptr, 10, &inst); + if (rc) { CERROR("config: wrong instance # %s\n", ptr); } else if (inst != imp->imp_connect_data.ocd_instance) { CDEBUG(D_INFO, "IR: %s is connecting to an obsoleted " @@ -1333,6 +1403,7 @@ lprocfs_import_seq_write(struct file *file, const char __user *buffer, } } + LPROCFS_CLIMP_EXIT(obd); if (do_reconn) ptlrpc_recover_import(imp, uuid, 1); @@ -1362,16 +1433,13 @@ lprocfs_pinger_recov_seq_write(struct file *file, const char __user *buffer, struct obd_device *obd = m->private; struct client_obd *cli = &obd->u.cli; struct obd_import *imp = cli->cl_import; + bool val; int rc; - __s64 val; - rc = lprocfs_str_to_s64(buffer, count, &val); + rc = kstrtobool_from_user(buffer, count, &val); if (rc < 0) return rc; - if (val != 0 && val != 1) - return -ERANGE; - LPROCFS_CLIMP_CHECK(obd); spin_lock(&imp->imp_lock); imp->imp_no_pinger_recover = !val; @@ -1380,5 +1448,3 @@ lprocfs_pinger_recov_seq_write(struct file *file, const char __user *buffer, return count; } EXPORT_SYMBOL(lprocfs_pinger_recov_seq_write); - -#endif /* CONFIG_PROC_FS */