X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fmdc%2Flproc_mdc.c;h=cf374679d08f4af599c37fe16dd834e934f2f0f7;hp=c5cefe4b77ae3bba0707eacdb3190eb0557c2f8c;hb=db2d74e8091a7b816d831babe428fa189e002544;hpb=e7f3c2955a426bbe3e39b32208056b9ab8667190 diff --git a/lustre/mdc/lproc_mdc.c b/lustre/mdc/lproc_mdc.c index c5cefe4..cf37467 100644 --- a/lustre/mdc/lproc_mdc.c +++ b/lustre/mdc/lproc_mdc.c @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -17,17 +15,15 @@ * * 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 - * - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. + * http://www.gnu.org/licenses/gpl-2.0.html * * 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. + * + * Copyright (c) 2011, 2016, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -39,131 +35,471 @@ #include #include #include -#include +#include +#include + +#include "mdc_internal.h" + +#ifdef CONFIG_PROC_FS +static int mdc_active_seq_show(struct seq_file *m, void *v) +{ + struct obd_device *dev = m->private; + + LPROCFS_CLIMP_CHECK(dev); + seq_printf(m, "%d\n", !dev->u.cli.cl_import->imp_deactive); + LPROCFS_CLIMP_EXIT(dev); + return 0; +} + +static ssize_t mdc_active_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) +{ + struct obd_device *dev; + int rc; + __s64 val; + + dev = ((struct seq_file *)file->private_data)->private; + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; + if (val < 0 || val > 1) + return -ERANGE; -#ifdef LPROCFS + /* opposite senses */ + if (dev->u.cli.cl_import->imp_deactive == val) + rc = ptlrpc_set_import_active(dev->u.cli.cl_import, val); + else + CDEBUG(D_CONFIG, "activate %llu: ignoring repeat request\n", + val); -static int mdc_rd_max_rpcs_in_flight(char *page, char **start, off_t off, - int count, int *eof, void *data) + return count; +} +LPROC_SEQ_FOPS(mdc_active); + +static int mdc_max_dirty_mb_seq_show(struct seq_file *m, void *v) { - struct obd_device *dev = data; - struct client_obd *cli = &dev->u.cli; - int rc; + struct obd_device *dev = m->private; + struct client_obd *cli = &dev->u.cli; + long val; + int mult; + + spin_lock(&cli->cl_loi_list_lock); + val = cli->cl_dirty_max_pages; + spin_unlock(&cli->cl_loi_list_lock); - client_obd_list_lock(&cli->cl_loi_list_lock); - rc = snprintf(page, count, "%u\n", cli->cl_max_rpcs_in_flight); - client_obd_list_unlock(&cli->cl_loi_list_lock); - return rc; + mult = 1 << (20 - PAGE_SHIFT); + return lprocfs_seq_read_frac_helper(m, val, mult); } -static int mdc_wr_max_rpcs_in_flight(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t mdc_max_dirty_mb_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) { - struct obd_device *dev = data; - struct client_obd *cli = &dev->u.cli; - int val, rc; + struct seq_file *sfl = file->private_data; + struct obd_device *dev = sfl->private; + struct client_obd *cli = &dev->u.cli; + __s64 pages_number; + int rc; - rc = lprocfs_write_helper(buffer, count, &val); - if (rc) - return rc; + rc = lprocfs_str_with_units_to_s64(buffer, count, &pages_number, 'M'); + if (rc) + return rc; - if (val < 1 || val > MDC_MAX_RIF_MAX) - return -ERANGE; + pages_number >>= PAGE_SHIFT; - client_obd_list_lock(&cli->cl_loi_list_lock); - cli->cl_max_rpcs_in_flight = val; - client_obd_list_unlock(&cli->cl_loi_list_lock); + if (pages_number <= 0 || + pages_number >= OSC_MAX_DIRTY_MB_MAX << (20 - PAGE_SHIFT) || + pages_number > totalram_pages / 4) /* 1/4 of RAM */ + return -ERANGE; - return count; + spin_lock(&cli->cl_loi_list_lock); + cli->cl_dirty_max_pages = pages_number; + osc_wake_cache_waiters(cli); + spin_unlock(&cli->cl_loi_list_lock); + + return count; } +LPROC_SEQ_FOPS(mdc_max_dirty_mb); -static int mdc_changelog_seq_release(struct inode *inode, struct file *file) +static int mdc_cached_mb_seq_show(struct seq_file *m, void *v) { - struct seq_file *seq = file->private_data; - struct changelog_seq_iter *csi = seq->private; + struct obd_device *dev = m->private; + struct client_obd *cli = &dev->u.cli; + int shift = 20 - PAGE_SHIFT; - if (csi && csi->csi_llh) - llog_cat_put(csi->csi_llh); - if (csi && csi->csi_ctxt) - llog_ctxt_put(csi->csi_ctxt); + seq_printf(m, "used_mb: %ld\n" + "busy_cnt: %ld\n" + "reclaim: %llu\n", + (atomic_long_read(&cli->cl_lru_in_list) + + atomic_long_read(&cli->cl_lru_busy)) >> shift, + atomic_long_read(&cli->cl_lru_busy), + cli->cl_lru_reclaim); - return (changelog_seq_release(inode, file)); + return 0; } -static int mdc_changelog_seq_open(struct inode *inode, struct file *file) +/* shrink the number of caching pages to a specific number */ +static ssize_t +mdc_cached_mb_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) { - struct changelog_seq_iter *csi; - int rc; - ENTRY; + struct seq_file *sfl = file->private_data; + struct obd_device *dev = sfl->private; + struct client_obd *cli = &dev->u.cli; + __s64 pages_number; + long rc; + char kernbuf[128]; + + if (count >= sizeof(kernbuf)) + return -EINVAL; + + if (copy_from_user(kernbuf, buffer, count)) + return -EFAULT; + kernbuf[count] = 0; - rc = changelog_seq_open(inode, file, &csi); - if (rc) - RETURN(rc); + buffer += lprocfs_find_named_value(kernbuf, "used_mb:", &count) - + kernbuf; + rc = lprocfs_str_with_units_to_s64(buffer, count, &pages_number, 'M'); + if (rc) + return rc; - /* Set up the remote catalog handle */ - /* Note the proc file is set up with obd in data, not mdc_device */ - csi->csi_ctxt = llog_get_context((struct obd_device *)csi->csi_dev, - LLOG_CHANGELOG_REPL_CTXT); - if (csi->csi_ctxt == NULL) - GOTO(out, rc = -ENOENT); - rc = llog_create(csi->csi_ctxt, &csi->csi_llh, NULL, CHANGELOG_CATALOG); - if (rc) { - CERROR("llog_create() failed %d\n", rc); - GOTO(out, rc); - } - rc = llog_init_handle(csi->csi_llh, LLOG_F_IS_CAT, NULL); - if (rc) { - CERROR("llog_init_handle failed %d\n", rc); - GOTO(out, rc); - } + pages_number >>= PAGE_SHIFT; -out: - if (rc) - mdc_changelog_seq_release(inode, file); - RETURN(rc); + if (pages_number < 0) + return -ERANGE; + + rc = atomic_long_read(&cli->cl_lru_in_list) - pages_number; + if (rc > 0) { + struct lu_env *env; + __u16 refcheck; + + env = cl_env_get(&refcheck); + if (!IS_ERR(env)) { + (void)osc_lru_shrink(env, cli, rc, true); + cl_env_put(env, &refcheck); + } + } + + return count; } +LPROC_SEQ_FOPS(mdc_cached_mb); -static struct file_operations mdc_changelog_fops = { - .owner = THIS_MODULE, - .open = mdc_changelog_seq_open, - .read = seq_read, - .llseek = changelog_seq_lseek, - .release = mdc_changelog_seq_release, -}; +static int mdc_contention_seconds_seq_show(struct seq_file *m, void *v) +{ + struct obd_device *obd = m->private; + struct osc_device *od = obd2osc_dev(obd); + + seq_printf(m, "%u\n", od->od_contention_time); + return 0; +} +static ssize_t mdc_contention_seconds_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) +{ + struct seq_file *sfl = file->private_data; + struct obd_device *obd = sfl->private; + struct osc_device *od = obd2osc_dev(obd); + int rc; + __s64 val; -static struct lprocfs_vars lprocfs_mdc_obd_vars[] = { - { "uuid", lprocfs_rd_uuid, 0, 0 }, - { "ping", 0, lprocfs_wr_ping, 0, 0, 0222 }, - { "connect_flags", lprocfs_rd_connect_flags, 0, 0 }, - { "blocksize", lprocfs_rd_blksize, 0, 0 }, - { "kbytestotal", lprocfs_rd_kbytestotal, 0, 0 }, - { "kbytesfree", lprocfs_rd_kbytesfree, 0, 0 }, - { "kbytesavail", lprocfs_rd_kbytesavail, 0, 0 }, - { "filestotal", lprocfs_rd_filestotal, 0, 0 }, - { "filesfree", lprocfs_rd_filesfree, 0, 0 }, - /*{ "filegroups", lprocfs_rd_filegroups, 0, 0 },*/ - { "mds_server_uuid", lprocfs_rd_server_uuid, 0, 0 }, - { "mds_conn_uuid", lprocfs_rd_conn_uuid, 0, 0 }, - { "max_rpcs_in_flight", mdc_rd_max_rpcs_in_flight, - mdc_wr_max_rpcs_in_flight, 0 }, - { "quota_resend_count", lprocfs_rd_quota_resend_count, - lprocfs_wr_quota_resend_count, 0}, - { "timeouts", lprocfs_rd_timeouts, 0, 0 }, - { "import", lprocfs_rd_import, 0, 0 }, - { "state", lprocfs_rd_state, 0, 0 }, - { "changelog", 0, 0, 0, &mdc_changelog_fops, 0400 }, - { 0 } -}; + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; + if (val < 0 || val > INT_MAX) + return -ERANGE; -static struct lprocfs_vars lprocfs_mdc_module_vars[] = { - { "num_refs", lprocfs_rd_numrefs, 0, 0 }, - { 0 } -}; + od->od_contention_time = val; + + return count; +} +LPROC_SEQ_FOPS(mdc_contention_seconds); + +static int mdc_unstable_stats_seq_show(struct seq_file *m, void *v) +{ + struct obd_device *dev = m->private; + struct client_obd *cli = &dev->u.cli; + long pages; + int mb; + + pages = atomic_long_read(&cli->cl_unstable_count); + mb = (pages * PAGE_SIZE) >> 20; + + seq_printf(m, "unstable_pages: %20ld\n" + "unstable_mb: %10d\n", pages, mb); + return 0; +} +LPROC_SEQ_FOPS_RO(mdc_unstable_stats); + +static int mdc_max_rpcs_in_flight_seq_show(struct seq_file *m, void *v) +{ + struct obd_device *dev = m->private; + __u32 max; + + max = obd_get_max_rpcs_in_flight(&dev->u.cli); + seq_printf(m, "%u\n", max); + + return 0; +} -void lprocfs_mdc_init_vars(struct lprocfs_static_vars *lvars) +static ssize_t mdc_max_rpcs_in_flight_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) { - lvars->module_vars = lprocfs_mdc_module_vars; - lvars->obd_vars = lprocfs_mdc_obd_vars; + struct obd_device *dev; + __s64 val; + int rc; + + dev = ((struct seq_file *)file->private_data)->private; + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; + + if (val < 0 || val > UINT_MAX) + return -ERANGE; + + rc = obd_set_max_rpcs_in_flight(&dev->u.cli, val); + if (rc) + return rc; + + return count; } -#endif /* LPROCFS */ +LPROC_SEQ_FOPS(mdc_max_rpcs_in_flight); + +static int mdc_max_mod_rpcs_in_flight_seq_show(struct seq_file *m, void *v) +{ + struct obd_device *dev = m->private; + __u16 max; + + max = obd_get_max_mod_rpcs_in_flight(&dev->u.cli); + seq_printf(m, "%hu\n", max); + + return 0; +} + +static ssize_t mdc_max_mod_rpcs_in_flight_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) +{ + struct obd_device *dev; + __s64 val; + int rc; + + dev = ((struct seq_file *)file->private_data)->private; + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; + + if (val < 0 || val > USHRT_MAX) + return -ERANGE; + + rc = obd_set_max_mod_rpcs_in_flight(&dev->u.cli, val); + if (rc) + count = rc; + + return count; +} +LPROC_SEQ_FOPS(mdc_max_mod_rpcs_in_flight); + +static ssize_t mdc_rpc_stats_seq_write(struct file *file, + const char __user *buf, + size_t len, loff_t *off) +{ + struct seq_file *seq = file->private_data; + struct obd_device *dev = seq->private; + struct client_obd *cli = &dev->u.cli; + + lprocfs_oh_clear(&cli->cl_mod_rpcs_hist); + + lprocfs_oh_clear(&cli->cl_read_rpc_hist); + lprocfs_oh_clear(&cli->cl_write_rpc_hist); + lprocfs_oh_clear(&cli->cl_read_page_hist); + lprocfs_oh_clear(&cli->cl_write_page_hist); + lprocfs_oh_clear(&cli->cl_read_offset_hist); + lprocfs_oh_clear(&cli->cl_write_offset_hist); + + return len; +} + +#define pct(a, b) (b ? a * 100 / b : 0) +static int mdc_rpc_stats_seq_show(struct seq_file *seq, void *v) +{ + struct obd_device *dev = seq->private; + struct client_obd *cli = &dev->u.cli; + unsigned long read_tot = 0, write_tot = 0, read_cum, write_cum; + int i; + + obd_mod_rpc_stats_seq_show(&dev->u.cli, seq); + + spin_lock(&cli->cl_loi_list_lock); + + seq_printf(seq, "\nread RPCs in flight: %d\n", + cli->cl_r_in_flight); + seq_printf(seq, "write RPCs in flight: %d\n", + cli->cl_w_in_flight); + seq_printf(seq, "pending write pages: %d\n", + atomic_read(&cli->cl_pending_w_pages)); + seq_printf(seq, "pending read pages: %d\n", + atomic_read(&cli->cl_pending_r_pages)); + + seq_printf(seq, "\n\t\t\tread\t\t\twrite\n"); + seq_printf(seq, "pages per rpc rpcs %% cum %% |"); + seq_printf(seq, " rpcs %% cum %%\n"); + + read_tot = lprocfs_oh_sum(&cli->cl_read_page_hist); + write_tot = lprocfs_oh_sum(&cli->cl_write_page_hist); + + read_cum = 0; + write_cum = 0; + for (i = 0; i < OBD_HIST_MAX; i++) { + unsigned long r = cli->cl_read_page_hist.oh_buckets[i]; + unsigned long w = cli->cl_write_page_hist.oh_buckets[i]; + + read_cum += r; + write_cum += w; + seq_printf(seq, "%d:\t\t%10lu %3lu %3lu | %10lu %3lu %3lu\n", + 1 << i, r, pct(r, read_tot), + pct(read_cum, read_tot), w, + pct(w, write_tot), + pct(write_cum, write_tot)); + if (read_cum == read_tot && write_cum == write_tot) + break; + } + + seq_printf(seq, "\n\t\t\tread\t\t\twrite\n"); + seq_printf(seq, "rpcs in flight rpcs %% cum %% |"); + seq_printf(seq, " rpcs %% cum %%\n"); + + read_tot = lprocfs_oh_sum(&cli->cl_read_rpc_hist); + write_tot = lprocfs_oh_sum(&cli->cl_write_rpc_hist); + + read_cum = 0; + write_cum = 0; + for (i = 0; i < OBD_HIST_MAX; i++) { + unsigned long r = cli->cl_read_rpc_hist.oh_buckets[i]; + unsigned long w = cli->cl_write_rpc_hist.oh_buckets[i]; + + read_cum += r; + write_cum += w; + seq_printf(seq, "%d:\t\t%10lu %3lu %3lu | %10lu %3lu %3lu\n", + i, r, pct(r, read_tot), pct(read_cum, read_tot), w, + pct(w, write_tot), pct(write_cum, write_tot)); + if (read_cum == read_tot && write_cum == write_tot) + break; + } + + seq_printf(seq, "\n\t\t\tread\t\t\twrite\n"); + seq_printf(seq, "offset rpcs %% cum %% |"); + seq_printf(seq, " rpcs %% cum %%\n"); + + read_tot = lprocfs_oh_sum(&cli->cl_read_offset_hist); + write_tot = lprocfs_oh_sum(&cli->cl_write_offset_hist); + + read_cum = 0; + write_cum = 0; + for (i = 0; i < OBD_HIST_MAX; i++) { + unsigned long r = cli->cl_read_offset_hist.oh_buckets[i]; + unsigned long w = cli->cl_write_offset_hist.oh_buckets[i]; + + read_cum += r; + write_cum += w; + seq_printf(seq, "%d:\t\t%10lu %3lu %3lu | %10lu %3lu %3lu\n", + (i == 0) ? 0 : 1 << (i - 1), + r, pct(r, read_tot), pct(read_cum, read_tot), + w, pct(w, write_tot), pct(write_cum, write_tot)); + if (read_cum == read_tot && write_cum == write_tot) + break; + } + spin_unlock(&cli->cl_loi_list_lock); + + return 0; +} +#undef pct +LPROC_SEQ_FOPS(mdc_rpc_stats); + +static int mdc_stats_seq_show(struct seq_file *seq, void *v) +{ + struct timespec64 now; + struct obd_device *dev = seq->private; + struct osc_stats *stats = &obd2osc_dev(dev)->od_stats; + + ktime_get_real_ts64(&now); + + seq_printf(seq, "snapshot_time: %lld.%09lu (secs.nsecs)\n", + (s64)now.tv_sec, now.tv_nsec); + seq_printf(seq, "lockless_write_bytes\t\t%llu\n", + stats->os_lockless_writes); + seq_printf(seq, "lockless_read_bytes\t\t%llu\n", + stats->os_lockless_reads); + seq_printf(seq, "lockless_truncate\t\t%llu\n", + stats->os_lockless_truncates); + return 0; +} + +static ssize_t mdc_stats_seq_write(struct file *file, + const char __user *buf, + size_t len, loff_t *off) +{ + struct seq_file *seq = file->private_data; + struct obd_device *dev = seq->private; + struct osc_stats *stats = &obd2osc_dev(dev)->od_stats; + + memset(stats, 0, sizeof(*stats)); + return len; +} +LPROC_SEQ_FOPS(mdc_stats); + +LPROC_SEQ_FOPS_WR_ONLY(mdc, ping); + +LPROC_SEQ_FOPS_RO_TYPE(mdc, connect_flags); +LPROC_SEQ_FOPS_RO_TYPE(mdc, server_uuid); +LPROC_SEQ_FOPS_RO_TYPE(mdc, conn_uuid); +LPROC_SEQ_FOPS_RO_TYPE(mdc, timeouts); +LPROC_SEQ_FOPS_RO_TYPE(mdc, state); +LPROC_SEQ_FOPS_RW_TYPE(mdc, obd_max_pages_per_rpc); +LPROC_SEQ_FOPS_RW_TYPE(mdc, import); +LPROC_SEQ_FOPS_RW_TYPE(mdc, pinger_recov); + +struct lprocfs_vars lprocfs_mdc_obd_vars[] = { + { .name = "ping", + .fops = &mdc_ping_fops, + .proc_mode = 0222 }, + { .name = "connect_flags", + .fops = &mdc_connect_flags_fops }, + { .name = "mds_server_uuid", + .fops = &mdc_server_uuid_fops }, + { .name = "mds_conn_uuid", + .fops = &mdc_conn_uuid_fops }, + { .name = "max_pages_per_rpc", + .fops = &mdc_obd_max_pages_per_rpc_fops }, + { .name = "max_rpcs_in_flight", + .fops = &mdc_max_rpcs_in_flight_fops }, + { .name = "max_mod_rpcs_in_flight", + .fops = &mdc_max_mod_rpcs_in_flight_fops }, + { .name = "max_dirty_mb", + .fops = &mdc_max_dirty_mb_fops }, + { .name = "mdc_cached_mb", + .fops = &mdc_cached_mb_fops }, + { .name = "timeouts", + .fops = &mdc_timeouts_fops }, + { .name = "contention_seconds", + .fops = &mdc_contention_seconds_fops }, + { .name = "import", + .fops = &mdc_import_fops }, + { .name = "state", + .fops = &mdc_state_fops }, + { .name = "pinger_recov", + .fops = &mdc_pinger_recov_fops }, + { .name = "rpc_stats", + .fops = &mdc_rpc_stats_fops }, + { .name = "active", + .fops = &mdc_active_fops }, + { .name = "unstable_stats", + .fops = &mdc_unstable_stats_fops }, + { .name = "mdc_stats", + .fops = &mdc_stats_fops }, + { NULL } +}; + +#endif /* CONFIG_PROC_FS */