X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Flprocfs_status_server.c;h=b4d0dd61c5f39ceb8da33046d18118b85c195b10;hb=fd669eba19210edd3a011d6862fda96383453cc3;hp=dc3e95c756b87809a89a570582bd697d46e04492;hpb=500f334631c6ebec72f5791472f21603da3e0ef9;p=fs%2Flustre-release.git diff --git a/lustre/obdclass/lprocfs_status_server.c b/lustre/obdclass/lprocfs_status_server.c index dc3e95c..b4d0dd6 100644 --- a/lustre/obdclass/lprocfs_status_server.c +++ b/lustre/obdclass/lprocfs_status_server.c @@ -15,7 +15,7 @@ * * You should have received a copy of the GNU General Public License * version 2 along with this program; If not, see - * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf + * http://www.gnu.org/licenses/gpl-2.0.html * * GPL HEADER END */ @@ -23,7 +23,7 @@ * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2014, 2015, Intel Corporation. + * Copyright (c) 2014, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -34,12 +34,57 @@ #define DEBUG_SUBSYSTEM S_CLASS +#include +#include #include #include -#include #include +#define MAX_STRING_SIZE 128 + +struct dentry *ldebugfs_add_symlink(const char *name, const char *target, + const char *format, ...) +{ + struct dentry *entry = NULL; + struct dentry *parent; + struct qstr dname; + va_list ap; + char *dest; + + if (!target || !format) + return NULL; + + dname.name = target; + dname.len = strlen(dname.name); + dname.hash = ll_full_name_hash(debugfs_lustre_root, + dname.name, dname.len); + parent = d_lookup(debugfs_lustre_root, &dname); + if (!parent) + return NULL; + + OBD_ALLOC_WAIT(dest, MAX_STRING_SIZE + 1); + if (!dest) + goto no_entry; + + va_start(ap, format); + vsnprintf(dest, MAX_STRING_SIZE, format, ap); + va_end(ap); + + entry = debugfs_create_symlink(name, parent, dest); + if (IS_ERR_OR_NULL(entry)) { + CERROR("LdebugFS: Could not create symbolic link from %s to %s\n", + name, dest); + entry = NULL; + } + + OBD_FREE(dest, MAX_STRING_SIZE + 1); +no_entry: + dput(parent); + return entry; +} +EXPORT_SYMBOL(ldebugfs_add_symlink); + #ifdef CONFIG_PROC_FS int lprocfs_evict_client_open(struct inode *inode, struct file *f) @@ -114,6 +159,86 @@ int lprocfs_num_exports_seq_show(struct seq_file *m, void *data) } EXPORT_SYMBOL(lprocfs_num_exports_seq_show); +static int obd_export_flags2str(struct obd_export *exp, struct seq_file *m) +{ + bool first = true; + + flag2str(exp, failed); + flag2str(exp, in_recovery); + flag2str(exp, disconnected); + flag2str(exp, connecting); + + return 0; +} + +static int +lprocfs_exp_print_export_seq(struct cfs_hash *hs, struct cfs_hash_bd *bd, + struct hlist_node *hnode, void *cb_data) +{ + struct seq_file *m = cb_data; + struct obd_export *exp = cfs_hash_object(hs, hnode); + struct obd_device *obd; + struct obd_connect_data *ocd; + + LASSERT(exp != NULL); + if (exp->exp_nid_stats == NULL) + goto out; + obd = exp->exp_obd; + ocd = &exp->exp_connect_data; + + seq_printf(m, "%s:\n" + " name: %s\n" + " client: %s\n" + " connect_flags: [ ", + obd_uuid2str(&exp->exp_client_uuid), + obd->obd_name, + obd_export_nid2str(exp)); + obd_connect_seq_flags2str(m, ocd->ocd_connect_flags, + ocd->ocd_connect_flags2, ", "); + seq_printf(m, " ]\n"); + obd_connect_data_seqprint(m, ocd); + seq_printf(m, " export_flags: [ "); + obd_export_flags2str(exp, m); + seq_printf(m, " ]\n"); + +out: + return 0; +} + +/** + * RPC connections are composed of an import and an export. Using the + * lctl utility we can extract important information about the state. + * The lprocfs_exp_export_seq_show routine displays the state information + * for the export. + * + * \param[in] m seq file + * \param[in] data unused + * + * \retval 0 on success + * + * The format of the export state information is like: + * a793e354-49c0-aa11-8c4f-a4f2b1a1a92b: + * name: MGS + * client: 10.211.55.10@tcp + * connect_flags: [ version, barrier, adaptive_timeouts, ... ] + * connect_data: + * flags: 0x2000011005002020 + * instance: 0 + * target_version: 2.10.51.0 + * export_flags: [ ... ] + * + */ +static int lprocfs_exp_export_seq_show(struct seq_file *m, void *data) +{ + struct nid_stat *stats = m->private; + struct obd_device *obd = stats->nid_obd; + + cfs_hash_for_each_key(obd->obd_nid_hash, &stats->nid, + lprocfs_exp_print_export_seq, m); + return 0; +} +LPROC_SEQ_FOPS_RO(lprocfs_exp_export); + static void lprocfs_free_client_stats(struct nid_stat *client_stat) { CDEBUG(D_CONFIG, "stat %p - data %p/%p\n", client_stat, @@ -384,7 +509,8 @@ int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid) &lprocfs_exp_nodemap_fops); if (IS_ERR(entry)) { rc = PTR_ERR(entry); - CWARN("Error adding the nodemap file: rc = %d\n", rc); + CWARN("%s: error adding the nodemap file: rc = %d\n", + obd->obd_name, rc); GOTO(destroy_new_ns, rc); } @@ -392,7 +518,8 @@ int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid) &lprocfs_exp_uuid_fops); if (IS_ERR(entry)) { rc = PTR_ERR(entry); - CWARN("Error adding the NID stats file: rc = %d\n", rc); + CWARN("%s: error adding the NID stats file: rc = %d\n", + obd->obd_name, rc); GOTO(destroy_new_ns, rc); } @@ -400,7 +527,17 @@ int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid) &lprocfs_exp_hash_fops); if (IS_ERR(entry)) { rc = PTR_ERR(entry); - CWARN("Error adding the hash file: rc = %d\n", rc); + CWARN("%s: error adding the hash file: rc = %d\n", + obd->obd_name, rc); + GOTO(destroy_new_ns, rc); + } + + entry = lprocfs_add_simple(new_stat->nid_proc, "export", + new_stat, &lprocfs_exp_export_fops); + if (IS_ERR(entry)) { + rc = PTR_ERR(entry); + CWARN("%s: error adding the export file: rc = %d\n", + obd->obd_name, rc); GOTO(destroy_new_ns, rc); } @@ -408,7 +545,7 @@ int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid) &lprocfs_exp_replydata_fops); if (IS_ERR(entry)) { rc = PTR_ERR(entry); - CWARN("%s: Error adding the reply_data file: rc = %d\n", + CWARN("%s: error adding the reply_data file: rc = %d\n", obd->obd_name, rc); GOTO(destroy_new_ns, rc); } @@ -564,6 +701,7 @@ EXPORT_SYMBOL(lprocfs_hash_seq_show); int lprocfs_recovery_status_seq_show(struct seq_file *m, void *data) { struct obd_device *obd = m->private; + struct target_distribute_txn_data *tdtd; LASSERT(obd != NULL); @@ -576,11 +714,12 @@ int lprocfs_recovery_status_seq_show(struct seq_file *m, void *data) /* sampled unlocked, but really... */ if (obd->obd_recovering == 0) { seq_printf(m, "COMPLETE\n"); - seq_printf(m, "recovery_start: %lu\n", obd->obd_recovery_start); - seq_printf(m, "recovery_duration: %lu\n", + seq_printf(m, "recovery_start: %lld\n", + (s64)obd->obd_recovery_start); + seq_printf(m, "recovery_duration: %lld\n", obd->obd_recovery_end ? obd->obd_recovery_end - obd->obd_recovery_start : - cfs_time_current_sec() - obd->obd_recovery_start); + ktime_get_real_seconds() - obd->obd_recovery_start); /* Number of clients that have completed recovery */ seq_printf(m, "completed_clients: %d/%d\n", obd->obd_max_recoverable_clients - @@ -597,15 +736,48 @@ int lprocfs_recovery_status_seq_show(struct seq_file *m, void *data) goto out; } + tdtd = obd->u.obt.obt_lut->lut_tdtd; + if (tdtd && tdtd->tdtd_show_update_logs_retrievers) { + char *buf; + int size = 0; + int count = 0; + + buf = tdtd->tdtd_show_update_logs_retrievers( + tdtd->tdtd_show_retrievers_cbdata, + &size, &count); + if (count > 0) { + seq_printf(m, "WAITING\n"); + seq_printf(m, "non-ready MDTs: %s\n", + buf ? buf : "unknown (not enough RAM)"); + seq_printf(m, "recovery_start: %lld\n", + (s64)obd->obd_recovery_start); + seq_printf(m, "time_waited: %lld\n", + (s64)(ktime_get_real_seconds() - + obd->obd_recovery_start)); + } + + if (buf != NULL) + OBD_FREE(buf, size); + + if (likely(count > 0)) + goto out; + } + + /* recovery won't start until the clients connect */ + if (obd->obd_recovery_start == 0) { + seq_printf(m, "WAITING_FOR_CLIENTS\n"); + goto out; + } + seq_printf(m, "RECOVERING\n"); - seq_printf(m, "recovery_start: %lu\n", obd->obd_recovery_start); - seq_printf(m, "time_remaining: %lu\n", - cfs_time_current_sec() >= + seq_printf(m, "recovery_start: %lld\n", (s64)obd->obd_recovery_start); + seq_printf(m, "time_remaining: %lld\n", + ktime_get_real_seconds() >= obd->obd_recovery_start + obd->obd_recovery_timeout ? 0 : - obd->obd_recovery_start + - obd->obd_recovery_timeout - - cfs_time_current_sec()); + (s64)(obd->obd_recovery_start + + obd->obd_recovery_timeout - + ktime_get_real_seconds())); seq_printf(m, "connected_clients: %d/%d\n", atomic_read(&obd->obd_connected_clients), obd->obd_max_recoverable_clients); @@ -644,11 +816,11 @@ lprocfs_ir_factor_seq_write(struct file *file, const char __user *buffer, { struct seq_file *m = file->private_data; struct obd_device *obd = m->private; + int val; int rc; - __s64 val; LASSERT(obd != NULL); - rc = lprocfs_str_to_s64(buffer, count, &val); + rc = kstrtoint_from_user(buffer, count, 10, &val); if (rc) return rc; @@ -660,12 +832,41 @@ lprocfs_ir_factor_seq_write(struct file *file, const char __user *buffer, } EXPORT_SYMBOL(lprocfs_ir_factor_seq_write); +int lprocfs_checksum_dump_seq_show(struct seq_file *m, void *data) +{ + struct obd_device *obd = m->private; + + LASSERT(obd != NULL); + seq_printf(m, "%d\n", obd->obd_checksum_dump); + return 0; +} +EXPORT_SYMBOL(lprocfs_checksum_dump_seq_show); + +ssize_t +lprocfs_checksum_dump_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) +{ + struct seq_file *m = file->private_data; + struct obd_device *obd = m->private; + bool val; + int rc; + + LASSERT(obd != NULL); + rc = kstrtobool_from_user(buffer, count, &val); + if (rc) + return rc; + + obd->obd_checksum_dump = val; + return count; +} +EXPORT_SYMBOL(lprocfs_checksum_dump_seq_write); + int lprocfs_recovery_time_soft_seq_show(struct seq_file *m, void *data) { struct obd_device *obd = m->private; LASSERT(obd != NULL); - seq_printf(m, "%d\n", obd->obd_recovery_timeout); + seq_printf(m, "%llu\n", obd->obd_recovery_timeout); return 0; } EXPORT_SYMBOL(lprocfs_recovery_time_soft_seq_show); @@ -677,15 +878,13 @@ lprocfs_recovery_time_soft_seq_write(struct file *file, { struct seq_file *m = file->private_data; struct obd_device *obd = m->private; + unsigned int val; int rc; - __s64 val; LASSERT(obd != NULL); - rc = lprocfs_str_to_s64(buffer, count, &val); + rc = kstrtouint_from_user(buffer, count, 0, &val); if (rc) return rc; - if (val < 0 || val > INT_MAX) - return -ERANGE; obd->obd_recovery_timeout = val; return count; @@ -697,7 +896,7 @@ int lprocfs_recovery_time_hard_seq_show(struct seq_file *m, void *data) struct obd_device *obd = m->private; LASSERT(obd != NULL); - seq_printf(m, "%u\n", obd->obd_recovery_time_hard); + seq_printf(m, "%lld\n", obd->obd_recovery_time_hard); return 0; } EXPORT_SYMBOL(lprocfs_recovery_time_hard_seq_show); @@ -709,15 +908,13 @@ lprocfs_recovery_time_hard_seq_write(struct file *file, { struct seq_file *m = file->private_data; struct obd_device *obd = m->private; + unsigned int val; int rc; - __s64 val; LASSERT(obd != NULL); - rc = lprocfs_str_to_s64(buffer, count, &val); + rc = kstrtouint_from_user(buffer, count, 0, &val); if (rc) return rc; - if (val < 0 || val > INT_MAX) - return -ERANGE; obd->obd_recovery_time_hard = val; return count;