* Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2012, Intel Corporation.
+ * Copyright (c) 2012, 2013, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#include <obd.h>
#include <lprocfs_status.h>
#include <linux/seq_file.h>
+#include <lustre_lfsck.h>
#include "ofd_internal.h"
int count, int *eof, void *data)
{
struct obd_device *obd = (struct obd_device *)data;
- struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+ struct ofd_device *ofd;
LASSERT(obd != NULL);
+ ofd = ofd_dev(obd->obd_lu_dev);
*eof = 1;
return snprintf(page, count, "%d\n", ofd->ofd_precreate_batch);
}
read_lock(&ofd->ofd_seq_list_lock);
cfs_list_for_each_entry(oseq, &ofd->ofd_seq_list, os_list) {
- rc = snprintf(page, count, DOSTID"\n", POSTID(&oseq->os_oi));
+ __u64 seq;
+
+ seq = ostid_seq(&oseq->os_oi) == 0 ?
+ fid_idif_seq(ostid_id(&oseq->os_oi),
+ ofd->ofd_lut.lut_lsd.lsd_osd_index) :
+ ostid_seq(&oseq->os_oi);
+ rc = snprintf(page, count, DOSTID"\n", seq,
+ ostid_id(&oseq->os_oi));
if (rc < 0) {
retval = rc;
break;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
int rc;
- rc = snprintf(page, count, "%ld\n", ofd->ofd_fmd_max_age / CFS_HZ);
+ rc = snprintf(page, count, "%ld\n", ofd->ofd_fmd_max_age / HZ);
return rc;
}
if (val > 65536 || val < 1)
return -EINVAL;
- ofd->ofd_fmd_max_age = val * CFS_HZ;
+ ofd->ofd_fmd_max_age = val * HZ;
return count;
}
int count, int *eof, void *data)
{
struct obd_device *obd = data;
- struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+ struct lu_target *tgt = obd->u.obt.obt_lut;
int rc;
rc = snprintf(page, count, "%s\n",
- sync_on_cancel_states[ofd->ofd_sync_lock_cancel]);
+ sync_on_cancel_states[tgt->lut_sync_lock_cancel]);
return rc;
}
unsigned long count, void *data)
{
struct obd_device *obd = data;
- struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+ struct lu_target *tgt = obd->u.obt.obt_lut;
int val = -1;
int i;
if (val < 0 || val > 2)
return -EINVAL;
- spin_lock(&ofd->ofd_flags_lock);
- ofd->ofd_sync_lock_cancel = val;
- spin_unlock(&ofd->ofd_flags_lock);
+ spin_lock(&tgt->lut_flags_lock);
+ tgt->lut_sync_lock_cancel = val;
+ spin_unlock(&tgt->lut_flags_lock);
return count;
}
return count;
}
+int lprocfs_ofd_rd_soft_sync_limit(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
+{
+ struct obd_device *obd = data;
+ struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+
+ return lprocfs_rd_uint(page, start, off, count, eof,
+ &ofd->ofd_soft_sync_limit);
+}
+
+int lprocfs_ofd_wr_soft_sync_limit(struct file *file, const char *buffer,
+ unsigned long count, void *data)
+{
+ struct obd_device *obd = data;
+ struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+
+ return lprocfs_wr_uint(file, buffer, count, &ofd->ofd_soft_sync_limit);
+}
+
+static int lprocfs_rd_lfsck_speed_limit(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
+{
+ struct obd_device *obd = data;
+ struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+
+ *eof = 1;
+
+ return lfsck_get_speed(ofd->ofd_osd, page, count);
+}
+
+static int lprocfs_wr_lfsck_speed_limit(struct file *file, const char *buffer,
+ unsigned long count, void *data)
+{
+ struct obd_device *obd = data;
+ struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+ __u32 val;
+ int rc;
+
+ rc = lprocfs_write_helper(buffer, count, &val);
+ if (rc != 0)
+ return rc;
+
+ rc = lfsck_set_speed(ofd->ofd_osd, val);
+
+ return rc != 0 ? rc : count;
+}
+
+static int lprocfs_rd_lfsck_layout(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
+{
+ struct obd_device *obd = data;
+ struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+
+ *eof = 1;
+
+ return lfsck_dump(ofd->ofd_osd, page, count, LT_LAYOUT);
+}
+
static struct lprocfs_vars lprocfs_ofd_obd_vars[] = {
{ "uuid", lprocfs_rd_uuid, 0, 0 },
{ "blocksize", lprocfs_rd_blksize, 0, 0 },
{ "capa_count", lprocfs_ofd_rd_capa_count, 0, 0 },
{ "job_cleanup_interval", lprocfs_rd_job_interval,
lprocfs_wr_job_interval, 0},
+ { "soft_sync_limit", lprocfs_ofd_rd_soft_sync_limit,
+ lprocfs_ofd_wr_soft_sync_limit, 0},
+ { "lfsck_speed_limit", lprocfs_rd_lfsck_speed_limit,
+ lprocfs_wr_lfsck_speed_limit, 0 },
+ { "lfsck_layout", lprocfs_rd_lfsck_layout, 0, 0 },
{ 0 }
};
void ofd_stats_counter_init(struct lprocfs_stats *stats)
{
- LASSERT(stats && stats->ls_num == LPROC_OFD_STATS_LAST);
+ LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST);
+
lprocfs_counter_init(stats, LPROC_OFD_STATS_READ,
- LPROCFS_CNTR_AVGMINMAX, "read", "bytes");
+ LPROCFS_CNTR_AVGMINMAX, "read_bytes", "bytes");
lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE,
- LPROCFS_CNTR_AVGMINMAX, "write", "bytes");
+ LPROCFS_CNTR_AVGMINMAX, "write_bytes", "bytes");
+ lprocfs_counter_init(stats, LPROC_OFD_STATS_GETATTR,
+ 0, "getattr", "reqs");
lprocfs_counter_init(stats, LPROC_OFD_STATS_SETATTR,
0, "setattr", "reqs");
lprocfs_counter_init(stats, LPROC_OFD_STATS_PUNCH,
0, "punch", "reqs");
lprocfs_counter_init(stats, LPROC_OFD_STATS_SYNC,
0, "sync", "reqs");
+ lprocfs_counter_init(stats, LPROC_OFD_STATS_DESTROY,
+ 0, "destroy", "reqs");
+ lprocfs_counter_init(stats, LPROC_OFD_STATS_CREATE,
+ 0, "create", "reqs");
+ lprocfs_counter_init(stats, LPROC_OFD_STATS_STATFS,
+ 0, "statfs", "reqs");
+ lprocfs_counter_init(stats, LPROC_OFD_STATS_GET_INFO,
+ 0, "get_info", "reqs");
+ lprocfs_counter_init(stats, LPROC_OFD_STATS_SET_INFO,
+ 0, "set_info", "reqs");
+ lprocfs_counter_init(stats, LPROC_OFD_STATS_QUOTACTL,
+ 0, "quotactl", "reqs");
}
+
#endif /* LPROCFS */