X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fosd-ldiskfs%2Fosd_lproc.c;h=91fd2ae3ec151bed6739db886dbe04af3e054d36;hp=90494b6c22fec542ddd8cae3827d9ac71532f3fe;hb=ecd28d9b6cb691bda8184a7e07f1acc1ccded391;hpb=9fb46705ae86aa2c0ac29427f0ff24f923560eb7 diff --git a/lustre/osd-ldiskfs/osd_lproc.c b/lustre/osd-ldiskfs/osd_lproc.c index 90494b6..91fd2ae 100644 --- a/lustre/osd-ldiskfs/osd_lproc.c +++ b/lustre/osd-ldiskfs/osd_lproc.c @@ -27,7 +27,7 @@ * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, Whamcloud, Inc. + * Copyright (c) 2011, 2014, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -38,16 +38,14 @@ * Author: Mikhail Pershin */ -#define DEBUG_SUBSYSTEM S_CLASS +#define DEBUG_SUBSYSTEM S_OSD #include -#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) { @@ -65,7 +63,7 @@ void osd_brw_stats_update(struct osd_device *osd, struct osd_iobuf *iobuf) if (unlikely(nr_pages == 0)) return; - blocks_per_page = CFS_PAGE_SIZE >> osd_sb(osd)->s_blocksize_bits; + blocks_per_page = PAGE_CACHE_SIZE >> osd_sb(osd)->s_blocksize_bits; lprocfs_oh_tally_log2(&s->hist[BRW_R_PAGES+rw], nr_pages); @@ -127,12 +125,12 @@ 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 timeval now; - /* this sampling races with updates */ - cfs_gettimeofday(&now); - seq_printf(seq, "snapshot_time: %lu.%lu (secs.usecs)\n", - now.tv_sec, now.tv_usec); + /* this sampling races with updates */ + do_gettimeofday(&now); + seq_printf(seq, "snapshot_time: %lu.%lu (secs.usecs)\n", + now.tv_sec, now.tv_usec); display_brw_stats(seq, "pages per bulk r/w", "rpcs", &brw_stats->hist[BRW_R_PAGES], @@ -154,9 +152,10 @@ static void brw_stats_show(struct seq_file *seq, struct brw_stats *brw_stats) &brw_stats->hist[BRW_R_RPC_HIST], &brw_stats->hist[BRW_W_RPC_HIST], 0); - display_brw_stats(seq, "I/O time (1/1000s)", "ios", - &brw_stats->hist[BRW_R_IO_TIME], - &brw_stats->hist[BRW_W_IO_TIME], 1000 / CFS_HZ); + display_brw_stats(seq, "I/O time (1/1000s)", "ios", + &brw_stats->hist[BRW_R_IO_TIME], + &brw_stats->hist[BRW_W_IO_TIME], + jiffies_to_msecs(1000) / MSEC_PER_SEC); display_brw_stats(seq, "disk I/O size", "ios", &brw_stats->hist[BRW_R_DISK_IOSIZE], @@ -230,8 +229,8 @@ static int osd_stats_init(struct osd_device *osd) LPROCFS_CNTR_AVGMINMAX, "thandle closing", "usec"); #endif - lprocfs_seq_create(osd->od_proc_entry, "brw_stats", - 0444, &osd_brw_stats_fops, osd); + result = lprocfs_seq_create(osd->od_proc_entry, "brw_stats", + 0644, &osd_brw_stats_fops, osd); } else result = -ENOMEM; @@ -239,120 +238,46 @@ out: RETURN(result); } -static const char *osd_counter_names[] = { -#if OSD_THANDLE_STATS - [LPROC_OSD_THANDLE_STARTING] = "thandle starting", - [LPROC_OSD_THANDLE_OPEN] = "thandle open", - [LPROC_OSD_THANDLE_CLOSING] = "thandle closing" -#endif -}; - -int osd_procfs_init(struct osd_device *osd, const char *name) -{ - struct lprocfs_static_vars lvars; - struct obd_type *type; - int rc; - ENTRY; - - /* at the moment there is no linkage between lu_type - * and obd_type, so we lookup obd_type this way */ - type = class_search_type(LUSTRE_OSD_LDISKFS_NAME); - - LASSERT(name != NULL); - LASSERT(type != NULL); - - /* Find the type procroot and add the proc entry for this device */ - lprocfs_osd_init_vars(&lvars); - osd->od_proc_entry = lprocfs_register(name, type->typ_procroot, - lvars.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", - rc, name); - osd->od_proc_entry = NULL; - GOTO(out, rc); - } - - rc = lu_time_init(&osd->od_stats, - osd->od_proc_entry, - osd_counter_names, ARRAY_SIZE(osd_counter_names)); - - rc = osd_stats_init(osd); - - EXIT; -out: - if (rc) - osd_procfs_fini(osd); - return rc; -} - -int osd_procfs_fini(struct osd_device *osd) -{ - if (osd->od_stats) - lu_time_fini(&osd->od_stats); - - if (osd->od_proc_entry) { - lprocfs_remove(&osd->od_proc_entry); - osd->od_proc_entry = NULL; - } - RETURN(0); -} - -void osd_lprocfs_time_start(const struct lu_env *env) -{ - lu_lprocfs_time_start(env); -} - -void osd_lprocfs_time_end(const struct lu_env *env, struct osd_device *osd, - int idx) +static int ldiskfs_osd_fstype_seq_show(struct seq_file *m, void *data) { - lu_lprocfs_time_end(env, osd->od_stats, idx); -} - - - -static int lprocfs_osd_rd_fstype(char *page, char **start, off_t off, int count, - int *eof, void *data) -{ - struct osd_device *osd = osd_dt_dev(data); + struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private); - LASSERT(osd != NULL); - return snprintf(page, count, "ldiskfs\n"); + LASSERT(osd != NULL); + return seq_printf(m, "ldiskfs\n"); } +LPROC_SEQ_FOPS_RO(ldiskfs_osd_fstype); -static int lprocfs_osd_rd_mntdev(char *page, char **start, off_t off, int count, - int *eof, void *data) +static int ldiskfs_osd_mntdev_seq_show(struct seq_file *m, void *data) { - struct osd_device *osd = osd_dt_dev(data); + struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private); - LASSERT(osd != NULL); + LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) - return -EINPROGRESS; - - LASSERT(mnt_get_devname(osd->od_mnt)); - *eof = 1; + return -EINPROGRESS; - return snprintf(page, count, "%s\n", - mnt_get_devname(osd->od_mnt)); + return seq_printf(m, "%s\n", osd->od_mntdev); } +LPROC_SEQ_FOPS_RO(ldiskfs_osd_mntdev); -static int lprocfs_osd_rd_cache(char *page, char **start, off_t off, - int count, int *eof, void *data) +static int ldiskfs_osd_cache_seq_show(struct seq_file *m, void *data) { - struct osd_device *osd = osd_dt_dev(data); + struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private); LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) return -EINPROGRESS; - return snprintf(page, count, "%u\n", osd->od_read_cache); + return seq_printf(m, "%u\n", osd->od_read_cache); } -static int lprocfs_osd_wr_cache(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t +ldiskfs_osd_cache_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - struct osd_device *osd = osd_dt_dev(data); - int val, rc; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; + struct osd_device *osd = osd_dt_dev(dt); + int val, rc; LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) @@ -365,24 +290,27 @@ static int lprocfs_osd_wr_cache(struct file *file, const char *buffer, osd->od_read_cache = !!val; return count; } +LPROC_SEQ_FOPS(ldiskfs_osd_cache); -static int lprocfs_osd_rd_wcache(char *page, char **start, off_t off, - int count, int *eof, void *data) +static int ldiskfs_osd_wcache_seq_show(struct seq_file *m, void *data) { - struct osd_device *osd = osd_dt_dev(data); + struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private); LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) return -EINPROGRESS; - return snprintf(page, count, "%u\n", osd->od_writethrough_cache); + return seq_printf(m, "%u\n", osd->od_writethrough_cache); } -static int lprocfs_osd_wr_wcache(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t +ldiskfs_osd_wcache_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - struct osd_device *osd = osd_dt_dev(data); - int val, rc; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; + struct osd_device *osd = osd_dt_dev(dt); + int val, rc; LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) @@ -395,14 +323,17 @@ static int lprocfs_osd_wr_wcache(struct file *file, const char *buffer, osd->od_writethrough_cache = !!val; return count; } +LPROC_SEQ_FOPS(ldiskfs_osd_wcache); -static int lprocfs_osd_wr_force_sync(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t +lprocfs_osd_force_sync_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - struct osd_device *osd = osd_dt_dev(data); - struct dt_device *dt = data; - struct lu_env env; - int rc; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; + struct osd_device *osd = osd_dt_dev(dt); + struct lu_env env; + int rc; LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) @@ -416,21 +347,18 @@ static int lprocfs_osd_wr_force_sync(struct file *file, const char *buffer, return rc == 0 ? count : rc; } +LPROC_SEQ_FOPS_WO_TYPE(ldiskfs, osd_force_sync); -#ifdef HAVE_LDISKFS_PDO -static int lprocfs_osd_rd_pdo(char *page, char **start, off_t off, int count, - int *eof, void *data) +static int ldiskfs_osd_pdo_seq_show(struct seq_file *m, void *data) { - *eof = 1; - - return snprintf(page, count, "%s\n", ldiskfs_pdo ? "ON" : "OFF"); + return seq_printf(m, "%s\n", ldiskfs_pdo ? "ON" : "OFF"); } -static int lprocfs_osd_wr_pdo(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t +ldiskfs_osd_pdo_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - int pdo; - int rc; + int pdo, rc; rc = lprocfs_write_helper(buffer, count, &pdo); if (rc != 0) @@ -440,25 +368,26 @@ static int lprocfs_osd_wr_pdo(struct file *file, const char *buffer, return count; } -#endif +LPROC_SEQ_FOPS(ldiskfs_osd_pdo); -static int lprocfs_osd_rd_auto_scrub(char *page, char **start, off_t off, - int count, int *eof, void *data) +static int ldiskfs_osd_auto_scrub_seq_show(struct seq_file *m, void *data) { - struct osd_device *dev = osd_dt_dev(data); + struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private); LASSERT(dev != NULL); if (unlikely(dev->od_mnt == NULL)) return -EINPROGRESS; - *eof = 1; - return snprintf(page, count, "%d\n", !dev->od_noscrub); + return seq_printf(m, "%d\n", !dev->od_noscrub); } -static int lprocfs_osd_wr_auto_scrub(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t +ldiskfs_osd_auto_scrub_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - struct osd_device *dev = osd_dt_dev(data); + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; + struct osd_device *dev = osd_dt_dev(dt); int val, rc; LASSERT(dev != NULL); @@ -472,40 +401,139 @@ static int lprocfs_osd_wr_auto_scrub(struct file *file, const char *buffer, dev->od_noscrub = !val; return count; } +LPROC_SEQ_FOPS(ldiskfs_osd_auto_scrub); -static int lprocfs_osd_rd_oi_scrub(char *page, char **start, off_t off, - int count, int *eof, void *data) +static int ldiskfs_osd_full_scrub_ratio_seq_show(struct seq_file *m, void *data) { - struct osd_device *dev = osd_dt_dev(data); + struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private); LASSERT(dev != NULL); if (unlikely(dev->od_mnt == NULL)) return -EINPROGRESS; - *eof = 1; - return osd_scrub_dump(dev, page, count); + return seq_printf(m, LPU64"\n", dev->od_full_scrub_ratio); } -int lprocfs_osd_rd_readcache(char *page, char **start, off_t off, int count, - int *eof, void *data) +static ssize_t +ldiskfs_osd_full_scrub_ratio_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - struct osd_device *osd = osd_dt_dev(data); - int rc; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; + struct osd_device *dev = osd_dt_dev(dt); + int val, rc; + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + rc = lprocfs_write_helper(buffer, count, &val); + if (rc != 0) + return rc; + + if (val < 0) + return -EINVAL; + + dev->od_full_scrub_ratio = val; + return count; +} +LPROC_SEQ_FOPS(ldiskfs_osd_full_scrub_ratio); + +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); + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + return seq_printf(m, LPU64" (bad OI mappings/minute)\n", + dev->od_full_scrub_threshold_rate); +} + +static ssize_t +ldiskfs_osd_full_scrub_threshold_rate_seq_write(struct file *file, + const char *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); + int val, rc; + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + rc = lprocfs_write_helper(buffer, count, &val); + if (rc != 0) + return rc; + + if (val < 0) + return -EINVAL; + + dev->od_full_scrub_threshold_rate = val; + return count; +} +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); +} + +static ssize_t +ldiskfs_osd_track_declares_assert_seq_write(struct file *file, + const char *buffer, + size_t count, loff_t *off) +{ + int track_declares_assert; + int rc; + + rc = lprocfs_write_helper(buffer, count, &track_declares_assert); + if (rc != 0) + return rc; + + ldiskfs_track_declares_assert = !!track_declares_assert; + + return count; +} +LPROC_SEQ_FOPS(ldiskfs_osd_track_declares_assert); + +static int ldiskfs_osd_oi_scrub_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; + + return osd_scrub_dump(m, dev); +} +LPROC_SEQ_FOPS_RO(ldiskfs_osd_oi_scrub); + +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); LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) return -EINPROGRESS; - rc = snprintf(page, count, LPU64"\n", osd->od_readcache_max_filesize); - return rc; + return seq_printf(m, LPU64"\n", osd->od_readcache_max_filesize); } -int lprocfs_osd_wr_readcache(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t +ldiskfs_osd_readcache_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - struct osd_device *osd = osd_dt_dev(data); - __u64 val; - int rc; + 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; LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) @@ -519,40 +547,181 @@ int lprocfs_osd_wr_readcache(struct file *file, const char *buffer, OSD_MAX_CACHE_SIZE : val; return count; } +LPROC_SEQ_FOPS(ldiskfs_osd_readcache); -struct lprocfs_vars lprocfs_osd_obd_vars[] = { - { "blocksize", lprocfs_osd_rd_blksize, 0, 0 }, - { "kbytestotal", lprocfs_osd_rd_kbytestotal, 0, 0 }, - { "kbytesfree", lprocfs_osd_rd_kbytesfree, 0, 0 }, - { "kbytesavail", lprocfs_osd_rd_kbytesavail, 0, 0 }, - { "filestotal", lprocfs_osd_rd_filestotal, 0, 0 }, - { "filesfree", lprocfs_osd_rd_filesfree, 0, 0 }, - { "fstype", lprocfs_osd_rd_fstype, 0, 0 }, - { "mntdev", lprocfs_osd_rd_mntdev, 0, 0 }, - { "force_sync", 0, lprocfs_osd_wr_force_sync }, -#ifdef HAVE_LDISKFS_PDO - { "pdo", lprocfs_osd_rd_pdo, lprocfs_osd_wr_pdo, 0 }, +#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); + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + return seq_printf(m, "%d\n", (int)(dev->od_index_in_idif)); +} + +static ssize_t +ldiskfs_osd_index_in_idif_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) +{ + 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); + struct lu_target *tgt; + int val; + int rc; + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + rc = lprocfs_write_helper(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 - { "auto_scrub", lprocfs_osd_rd_auto_scrub, - lprocfs_osd_wr_auto_scrub, 0 }, - { "oi_scrub", lprocfs_osd_rd_oi_scrub, 0, 0 }, - { "force_sync", 0, lprocfs_osd_wr_force_sync }, - { "read_cache_enable", lprocfs_osd_rd_cache, lprocfs_osd_wr_cache, 0 }, - { "writethrough_cache_enable", lprocfs_osd_rd_wcache, - lprocfs_osd_wr_wcache, 0 }, - { "readcache_max_filesize", lprocfs_osd_rd_readcache, - lprocfs_osd_wr_readcache, 0 }, - { 0 } + +LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_blksize); +LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_kbytestotal); +LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_kbytesfree); +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_vars lprocfs_osd_obd_vars[] = { + { .name = "blocksize", + .fops = &ldiskfs_dt_blksize_fops }, + { .name = "kbytestotal", + .fops = &ldiskfs_dt_kbytestotal_fops }, + { .name = "kbytesfree", + .fops = &ldiskfs_dt_kbytesfree_fops }, + { .name = "kbytesavail", + .fops = &ldiskfs_dt_kbytesavail_fops }, + { .name = "filestotal", + .fops = &ldiskfs_dt_filestotal_fops }, + { .name = "filesfree", + .fops = &ldiskfs_dt_filesfree_fops }, + { .name = "fstype", + .fops = &ldiskfs_osd_fstype_fops }, + { .name = "mntdev", + .fops = &ldiskfs_osd_mntdev_fops }, + { .name = "force_sync", + .fops = &ldiskfs_osd_force_sync_fops }, + { .name = "pdo", + .fops = &ldiskfs_osd_pdo_fops }, + { .name = "auto_scrub", + .fops = &ldiskfs_osd_auto_scrub_fops }, + { .name = "full_scrub_ratio", + .fops = &ldiskfs_osd_full_scrub_ratio_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", + .fops = &ldiskfs_osd_cache_fops }, + { .name = "writethrough_cache_enable", + .fops = &ldiskfs_osd_wcache_fops }, + { .name = "readcache_max_filesize", + .fops = &ldiskfs_osd_readcache_fops }, + { NULL } }; struct lprocfs_vars lprocfs_osd_module_vars[] = { - { "num_refs", lprocfs_rd_numrefs, 0, 0 }, - { 0 } + { .name = "track_declares_assert", + .fops = &ldiskfs_osd_track_declares_assert_fops }, + { NULL } }; -void lprocfs_osd_init_vars(struct lprocfs_static_vars *lvars) + +int osd_procfs_init(struct osd_device *osd, const char *name) { - lvars->module_vars = lprocfs_osd_module_vars; - lvars->obd_vars = lprocfs_osd_obd_vars; + struct obd_type *type; + int rc; + ENTRY; + + if (osd->od_proc_entry) + RETURN(0); + + /* at the moment there is no linkage between lu_type + * and obd_type, so we lookup obd_type this way */ + type = class_search_type(LUSTRE_OSD_LDISKFS_NAME); + + LASSERT(name != NULL); + LASSERT(type != NULL); + + /* Find the type procroot and add the proc entry for this device */ + 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", + rc, name); + osd->od_proc_entry = NULL; + GOTO(out, rc); + } + + rc = osd_stats_init(osd); + + EXIT; +out: + if (rc) + osd_procfs_fini(osd); + return rc; +} + +int osd_procfs_fini(struct osd_device *osd) +{ + if (osd->od_stats) + lprocfs_free_stats(&osd->od_stats); + + if (osd->od_proc_entry) + lprocfs_remove(&osd->od_proc_entry); + RETURN(0); } #endif