X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fosd-ldiskfs%2Fosd_lproc.c;h=0c93d277a4929f0f8ee8e5db49606a984aa9c26c;hp=c46ef9672d356368f6cdd96f5b2b4a1f401241a1;hb=a48853cf3dc51b24cc276fcf5f2e3e25a32c0d25;hpb=b1e595c09e1b07a6840142b3ae015b8a5a8affeb diff --git a/lustre/osd-ldiskfs/osd_lproc.c b/lustre/osd-ldiskfs/osd_lproc.c index c46ef96..0c93d27 100644 --- a/lustre/osd-ldiskfs/osd_lproc.c +++ b/lustre/osd-ldiskfs/osd_lproc.c @@ -15,11 +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 - * - * 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 */ @@ -27,7 +23,7 @@ * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2013, Intel Corporation. + * Copyright (c) 2011, 2015, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -41,21 +37,20 @@ #define DEBUG_SUBSYSTEM S_OSD #include -#include #include "osd_internal.h" -#ifdef LPROCFS +#ifdef CONFIG_PROC_FS void osd_brw_stats_update(struct osd_device *osd, struct osd_iobuf *iobuf) { struct brw_stats *s = &osd->od_brw_stats; - unsigned long *last_block = NULL; + sector_t *last_block = NULL; struct page **pages = iobuf->dr_pages; struct page *last_page = NULL; unsigned long discont_pages = 0; unsigned long discont_blocks = 0; - unsigned long *blocks = iobuf->dr_blocks; + sector_t *blocks = iobuf->dr_blocks; int i, nr_pages = iobuf->dr_npages; int blocks_per_page; int rw = iobuf->dr_rw; @@ -63,7 +58,7 @@ void osd_brw_stats_update(struct osd_device *osd, struct osd_iobuf *iobuf) if (unlikely(nr_pages == 0)) return; - blocks_per_page = PAGE_CACHE_SIZE >> osd_sb(osd)->s_blocksize_bits; + blocks_per_page = PAGE_SIZE >> osd_sb(osd)->s_blocksize_bits; lprocfs_oh_tally_log2(&s->hist[BRW_R_PAGES+rw], nr_pages); @@ -125,12 +120,13 @@ static void display_brw_stats(struct seq_file *seq, char *name, char *units, static void brw_stats_show(struct seq_file *seq, struct brw_stats *brw_stats) { - struct timeval now; + struct timespec64 now; /* this sampling races with updates */ - do_gettimeofday(&now); - seq_printf(seq, "snapshot_time: %lu.%lu (secs.usecs)\n", - now.tv_sec, now.tv_usec); + ktime_get_real_ts64(&now); + + seq_printf(seq, "snapshot_time: %lld.%09ld (secs.nsecs)\n", + (s64)now.tv_sec, now.tv_nsec); display_brw_stats(seq, "pages per bulk r/w", "rpcs", &brw_stats->hist[BRW_R_PAGES], @@ -173,10 +169,11 @@ static int osd_brw_stats_seq_show(struct seq_file *seq, void *v) return 0; } -static ssize_t osd_brw_stats_seq_write(struct file *file, const char *buf, - size_t len, loff_t *off) +static ssize_t osd_brw_stats_seq_write(struct file *file, + const char __user *buf, + size_t len, loff_t *off) { - struct seq_file *seq = file->private_data; + struct seq_file *seq = file->private_data; struct osd_device *osd = seq->private; int i; @@ -243,7 +240,8 @@ static int ldiskfs_osd_fstype_seq_show(struct seq_file *m, void *data) struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private); LASSERT(osd != NULL); - return seq_printf(m, "ldiskfs\n"); + seq_puts(m, "ldiskfs\n"); + return 0; } LPROC_SEQ_FOPS_RO(ldiskfs_osd_fstype); @@ -255,7 +253,8 @@ static int ldiskfs_osd_mntdev_seq_show(struct seq_file *m, void *data) if (unlikely(osd->od_mnt == NULL)) return -EINPROGRESS; - return seq_printf(m, "%s\n", osd->od_mntdev); + seq_printf(m, "%s\n", osd->od_mntdev); + return 0; } LPROC_SEQ_FOPS_RO(ldiskfs_osd_mntdev); @@ -267,23 +266,25 @@ static int ldiskfs_osd_cache_seq_show(struct seq_file *m, void *data) if (unlikely(osd->od_mnt == NULL)) return -EINPROGRESS; - return seq_printf(m, "%u\n", osd->od_read_cache); + seq_printf(m, "%u\n", osd->od_read_cache); + return 0; } static ssize_t -ldiskfs_osd_cache_seq_write(struct file *file, const char *buffer, +ldiskfs_osd_cache_seq_write(struct file *file, const char __user *buffer, size_t count, loff_t *off) { - struct seq_file *m = file->private_data; - struct dt_device *dt = m->private; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; struct osd_device *osd = osd_dt_dev(dt); - int val, rc; + int rc; + __s64 val; LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) return -EINPROGRESS; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc) return rc; @@ -300,23 +301,25 @@ static int ldiskfs_osd_wcache_seq_show(struct seq_file *m, void *data) if (unlikely(osd->od_mnt == NULL)) return -EINPROGRESS; - return seq_printf(m, "%u\n", osd->od_writethrough_cache); + seq_printf(m, "%u\n", osd->od_writethrough_cache); + return 0; } static ssize_t -ldiskfs_osd_wcache_seq_write(struct file *file, const char *buffer, +ldiskfs_osd_wcache_seq_write(struct file *file, const char __user *buffer, size_t count, loff_t *off) { - struct seq_file *m = file->private_data; - struct dt_device *dt = m->private; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; struct osd_device *osd = osd_dt_dev(dt); - int val, rc; + int rc; + __s64 val; LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) return -EINPROGRESS; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc) return rc; @@ -326,7 +329,7 @@ ldiskfs_osd_wcache_seq_write(struct file *file, const char *buffer, LPROC_SEQ_FOPS(ldiskfs_osd_wcache); static ssize_t -lprocfs_osd_force_sync_seq_write(struct file *file, const char *buffer, +lprocfs_osd_force_sync_seq_write(struct file *file, const char __user *buffer, size_t count, loff_t *off) { struct seq_file *m = file->private_data; @@ -347,26 +350,28 @@ lprocfs_osd_force_sync_seq_write(struct file *file, const char *buffer, return rc == 0 ? count : rc; } -LPROC_SEQ_FOPS_WO_TYPE(ldiskfs, osd_force_sync); +LPROC_SEQ_FOPS_WR_ONLY(ldiskfs, osd_force_sync); static int ldiskfs_osd_pdo_seq_show(struct seq_file *m, void *data) { - return seq_printf(m, "%s\n", ldiskfs_pdo ? "ON" : "OFF"); + seq_printf(m, "%s\n", ldiskfs_pdo ? "ON" : "OFF"); + return 0; } static ssize_t -ldiskfs_osd_pdo_seq_write(struct file *file, const char *buffer, +ldiskfs_osd_pdo_seq_write(struct file *file, const char __user *buffer, size_t count, loff_t *off) { - int pdo, rc; + int rc; + __s64 pdo; - rc = lprocfs_write_helper(buffer, count, &pdo); - if (rc != 0) - return rc; + rc = lprocfs_str_to_s64(buffer, count, &pdo); + if (rc != 0) + return rc; - ldiskfs_pdo = !!pdo; + ldiskfs_pdo = !!pdo; - return count; + return count; } LPROC_SEQ_FOPS(ldiskfs_osd_pdo); @@ -378,27 +383,29 @@ static int ldiskfs_osd_auto_scrub_seq_show(struct seq_file *m, void *data) if (unlikely(dev->od_mnt == NULL)) return -EINPROGRESS; - return seq_printf(m, "%d\n", !dev->od_noscrub); + seq_printf(m, "%lld\n", dev->od_auto_scrub_interval); + return 0; } static ssize_t -ldiskfs_osd_auto_scrub_seq_write(struct file *file, const char *buffer, +ldiskfs_osd_auto_scrub_seq_write(struct file *file, const char __user *buffer, size_t count, loff_t *off) { - struct seq_file *m = file->private_data; - struct dt_device *dt = m->private; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; struct osd_device *dev = osd_dt_dev(dt); - int val, rc; + int rc; + __s64 val; LASSERT(dev != NULL); if (unlikely(dev->od_mnt == NULL)) return -EINPROGRESS; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc) return rc; - dev->od_noscrub = !val; + dev->od_auto_scrub_interval = val; return count; } LPROC_SEQ_FOPS(ldiskfs_osd_auto_scrub); @@ -411,23 +418,26 @@ static int ldiskfs_osd_full_scrub_ratio_seq_show(struct seq_file *m, void *data) if (unlikely(dev->od_mnt == NULL)) return -EINPROGRESS; - return seq_printf(m, LPU64"\n", dev->od_full_scrub_ratio); + seq_printf(m, "%llu\n", dev->od_full_scrub_ratio); + return 0; } static ssize_t -ldiskfs_osd_full_scrub_ratio_seq_write(struct file *file, const char *buffer, +ldiskfs_osd_full_scrub_ratio_seq_write(struct file *file, + const char __user *buffer, size_t count, loff_t *off) { - struct seq_file *m = file->private_data; - struct dt_device *dt = m->private; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; struct osd_device *dev = osd_dt_dev(dt); - int val, rc; + int rc; + __s64 val; LASSERT(dev != NULL); if (unlikely(dev->od_mnt == NULL)) return -EINPROGRESS; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc != 0) return rc; @@ -439,7 +449,8 @@ ldiskfs_osd_full_scrub_ratio_seq_write(struct file *file, const char *buffer, } LPROC_SEQ_FOPS(ldiskfs_osd_full_scrub_ratio); -static int ldiskfs_osd_full_scrub_speed_seq_show(struct seq_file *m, void *data) +static int ldiskfs_osd_full_scrub_threshold_rate_seq_show(struct seq_file *m, + void *data) { struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private); @@ -447,50 +458,54 @@ static int ldiskfs_osd_full_scrub_speed_seq_show(struct seq_file *m, void *data) if (unlikely(dev->od_mnt == NULL)) return -EINPROGRESS; - return seq_printf(m, LPU64" (bad OI mappings/minute)\n", - dev->od_full_scrub_speed); + seq_printf(m, "%llu (bad OI mappings/minute)\n", + dev->od_full_scrub_threshold_rate); + return 0; } static ssize_t -ldiskfs_osd_full_scrub_speed_seq_write(struct file *file, const char *buffer, - size_t count, loff_t *off) +ldiskfs_osd_full_scrub_threshold_rate_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) { - struct seq_file *m = file->private_data; - struct dt_device *dt = m->private; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; struct osd_device *dev = osd_dt_dev(dt); - int val, rc; + int rc; + __s64 val; LASSERT(dev != NULL); if (unlikely(dev->od_mnt == NULL)) return -EINPROGRESS; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc != 0) return rc; if (val < 0) return -EINVAL; - dev->od_full_scrub_speed = val; + dev->od_full_scrub_threshold_rate = val; return count; } -LPROC_SEQ_FOPS(ldiskfs_osd_full_scrub_speed); +LPROC_SEQ_FOPS(ldiskfs_osd_full_scrub_threshold_rate); static int ldiskfs_osd_track_declares_assert_seq_show(struct seq_file *m, void *data) { - return seq_printf(m, "%d\n", ldiskfs_track_declares_assert); + seq_printf(m, "%d\n", ldiskfs_track_declares_assert); + return 0; } static ssize_t ldiskfs_osd_track_declares_assert_seq_write(struct file *file, - const char *buffer, + const char __user *buffer, size_t count, loff_t *off) { - int track_declares_assert; - int rc; + __s64 track_declares_assert; + int rc; - rc = lprocfs_write_helper(buffer, count, &track_declares_assert); + rc = lprocfs_str_to_s64(buffer, count, &track_declares_assert); if (rc != 0) return rc; @@ -508,11 +523,12 @@ static int ldiskfs_osd_oi_scrub_seq_show(struct seq_file *m, void *data) if (unlikely(dev->od_mnt == NULL)) return -EINPROGRESS; - return osd_scrub_dump(m, dev); + osd_scrub_dump(m, dev); + return 0; } LPROC_SEQ_FOPS_RO(ldiskfs_osd_oi_scrub); -int ldiskfs_osd_readcache_seq_show(struct seq_file *m, void *data) +static int ldiskfs_osd_readcache_seq_show(struct seq_file *m, void *data) { struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private); @@ -520,26 +536,29 @@ int ldiskfs_osd_readcache_seq_show(struct seq_file *m, void *data) if (unlikely(osd->od_mnt == NULL)) return -EINPROGRESS; - return seq_printf(m, LPU64"\n", osd->od_readcache_max_filesize); + seq_printf(m, "%llu\n", osd->od_readcache_max_filesize); + return 0; } -ssize_t -ldiskfs_osd_readcache_seq_write(struct file *file, const char *buffer, +static ssize_t +ldiskfs_osd_readcache_seq_write(struct file *file, const char __user *buffer, size_t count, loff_t *off) { - struct seq_file *m = file->private_data; - struct dt_device *dt = m->private; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; struct osd_device *osd = osd_dt_dev(dt); - __u64 val; - int rc; + __s64 val; + int rc; LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) return -EINPROGRESS; - rc = lprocfs_write_u64_helper(buffer, count, &val); + rc = lprocfs_str_with_units_to_s64(buffer, count, &val, '1'); if (rc) return rc; + if (val < 0) + return -ERANGE; osd->od_readcache_max_filesize = val > OSD_MAX_CACHE_SIZE ? OSD_MAX_CACHE_SIZE : val; @@ -547,7 +566,8 @@ ldiskfs_osd_readcache_seq_write(struct file *file, const char *buffer, } LPROC_SEQ_FOPS(ldiskfs_osd_readcache); -static int ldiskfs_osd_lma_self_repair_seq_show(struct seq_file *m, void *data) +#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 0, 52, 0) +static int ldiskfs_osd_index_in_idif_seq_show(struct seq_file *m, void *data) { struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private); @@ -555,31 +575,110 @@ static int ldiskfs_osd_lma_self_repair_seq_show(struct seq_file *m, void *data) if (unlikely(dev->od_mnt == NULL)) return -EINPROGRESS; - return seq_printf(m, "%d\n", !!dev->od_lma_self_repair); + seq_printf(m, "%d\n", (int)(dev->od_index_in_idif)); + return 0; } static ssize_t -ldiskfs_osd_lma_self_repair_seq_write(struct file *file, const char *buffer, - size_t count, loff_t *off) +ldiskfs_osd_index_in_idif_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) { - struct seq_file *m = file->private_data; - struct dt_device *dt = m->private; + struct lu_env env; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; struct osd_device *dev = osd_dt_dev(dt); - int val; - int rc; + struct lu_target *tgt; + __s64 val; + int rc; + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc != 0) + return rc; + + if (dev->od_index_in_idif) { + if (val != 0) + return count; + + LCONSOLE_WARN("%s: OST-index in IDIF has been enabled, " + "it cannot be reverted back.\n", osd_name(dev)); + return -EPERM; + } + + if (val == 0) + return count; + + rc = lu_env_init(&env, LCT_DT_THREAD); + if (rc != 0) + return rc; + + tgt = dev->od_dt_dev.dd_lu_dev.ld_site->ls_tgt; + tgt->lut_lsd.lsd_feature_rocompat |= OBD_ROCOMPAT_IDX_IN_IDIF; + rc = tgt_server_data_update(&env, tgt, 1); + lu_env_fini(&env); + if (rc < 0) + return rc; + + LCONSOLE_INFO("%s: enable OST-index in IDIF successfully, " + "it cannot be reverted back.\n", osd_name(dev)); + + dev->od_index_in_idif = 1; + return count; +} +LPROC_SEQ_FOPS(ldiskfs_osd_index_in_idif); + +int osd_register_proc_index_in_idif(struct osd_device *osd) +{ + struct proc_dir_entry *proc; + + proc = proc_create_data("index_in_idif", 0, osd->od_proc_entry, + &ldiskfs_osd_index_in_idif_fops, + &osd->od_dt_dev); + if (proc == NULL) + return -ENOMEM; + + return 0; +} +#endif + +static int ldiskfs_osd_index_backup_seq_show(struct seq_file *m, void *data) +{ + struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private); + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + seq_printf(m, "%d\n", dev->od_index_backup_policy); + return 0; +} + +static ssize_t ldiskfs_osd_index_backup_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) +{ + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; + struct osd_device *dev = osd_dt_dev(dt); + __s64 val; + int rc; LASSERT(dev != NULL); if (unlikely(dev->od_mnt == NULL)) return -EINPROGRESS; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc) return rc; - dev->od_lma_self_repair = !!val; + dev->od_index_backup_policy = val; return count; } -LPROC_SEQ_FOPS(ldiskfs_osd_lma_self_repair); +LPROC_SEQ_FOPS(ldiskfs_osd_index_backup); LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_blksize); LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_kbytestotal); @@ -588,7 +687,7 @@ LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_kbytesavail); LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_filestotal); LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_filesfree); -struct lprocfs_seq_vars lprocfs_osd_obd_vars[] = { +struct lprocfs_vars lprocfs_osd_obd_vars[] = { { .name = "blocksize", .fops = &ldiskfs_dt_blksize_fops }, { .name = "kbytestotal", @@ -613,8 +712,8 @@ struct lprocfs_seq_vars lprocfs_osd_obd_vars[] = { .fops = &ldiskfs_osd_auto_scrub_fops }, { .name = "full_scrub_ratio", .fops = &ldiskfs_osd_full_scrub_ratio_fops }, - { .name = "full_scrub_speed", - .fops = &ldiskfs_osd_full_scrub_speed_fops }, + { .name = "full_scrub_threshold_rate", + .fops = &ldiskfs_osd_full_scrub_threshold_rate_fops }, { .name = "oi_scrub", .fops = &ldiskfs_osd_oi_scrub_fops }, { .name = "read_cache_enable", @@ -623,15 +722,15 @@ struct lprocfs_seq_vars lprocfs_osd_obd_vars[] = { .fops = &ldiskfs_osd_wcache_fops }, { .name = "readcache_max_filesize", .fops = &ldiskfs_osd_readcache_fops }, - { .name = "lma_self_repair", - .fops = &ldiskfs_osd_lma_self_repair_fops }, - { 0 } + { .name = "index_backup", + .fops = &ldiskfs_osd_index_backup_fops }, + { NULL } }; -struct lprocfs_seq_vars lprocfs_osd_module_vars[] = { +struct lprocfs_vars lprocfs_osd_module_vars[] = { { .name = "track_declares_assert", .fops = &ldiskfs_osd_track_declares_assert_fops }, - { 0 } + { NULL } }; @@ -652,9 +751,9 @@ int osd_procfs_init(struct osd_device *osd, const char *name) LASSERT(type != NULL); /* Find the type procroot and add the proc entry for this device */ - osd->od_proc_entry = lprocfs_seq_register(name, type->typ_procroot, - lprocfs_osd_obd_vars, - &osd->od_dt_dev); + osd->od_proc_entry = lprocfs_register(name, type->typ_procroot, + lprocfs_osd_obd_vars, + &osd->od_dt_dev); if (IS_ERR(osd->od_proc_entry)) { rc = PTR_ERR(osd->od_proc_entry); CERROR("Error %d setting up lprocfs for %s\n",