if (obd == NULL)
return 0;
+ rc = snprintf(page, count, LPU64"\n",filter_last_id(filter, 0));
+ if (rc < 0)
+ return rc;
+ page += rc;
+ count -= rc;
+ retval += rc;
- for (i = FILTER_GROUP_MDS0; i < filter->fo_group_count; i++) {
+ for (i = FILTER_GROUP_MDS1_N_BASE; i < filter->fo_group_count; i++) {
rc = snprintf(page, count, LPU64"\n",filter_last_id(filter, i));
if (rc < 0) {
retval = rc;
return count;
}
-
int lprocfs_filter_rd_fmd_max_num(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
capa_count[CAPA_SITE_SERVER]);
}
+static int lprocfs_rd_sec_level(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
+{
+ struct obd_device *obd = data;
+
+ return snprintf(page, count, "%d\n", obd->u.filter.fo_sec_level);
+}
+
+static int lprocfs_wr_sec_level(struct file *file, const char *buffer,
+ unsigned long count, void *data)
+{
+ struct obd_device *obd = data;
+ int val, rc;
+
+ rc = lprocfs_write_helper(buffer, count, &val);
+ if (rc)
+ return rc;
+
+ if (val > LUSTRE_SEC_ALL || val < LUSTRE_SEC_NONE)
+ return -EINVAL;
+
+ if (val == LUSTRE_SEC_SPECIFY) {
+ CWARN("security level %d will be supported in future.\n",
+ LUSTRE_SEC_SPECIFY);
+ return -EINVAL;
+ }
+
+ obd->u.filter.fo_sec_level = val;
+ return count;
+}
+
+static int lprocfs_filter_rd_cache(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
+{
+ struct obd_device *obd = (struct obd_device *)data;
+ LASSERT(obd != NULL);
+
+ return snprintf(page, count, "%u\n", obd->u.filter.fo_read_cache);
+}
+
+static int lprocfs_filter_wr_cache(struct file *file, const char *buffer,
+ unsigned long count, void *data)
+{
+ struct obd_device *obd = (struct obd_device *)data;
+ int val, rc;
+ LASSERT(obd != NULL);
+
+ rc = lprocfs_write_helper(buffer, count, &val);
+
+ if (rc)
+ return rc;
+
+ spin_lock_bh(&obd->obd_processing_task_lock);
+ obd->u.filter.fo_read_cache = val;
+ spin_unlock_bh(&obd->obd_processing_task_lock);
+ return count;
+}
+
+static int lprocfs_filter_rd_wcache(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
+{
+ struct obd_device *obd = (struct obd_device *)data;
+ LASSERT(obd != NULL);
+
+ return snprintf(page, count, "%u\n", obd->u.filter.fo_writethrough_cache);
+}
+
+static int lprocfs_filter_wr_wcache(struct file *file, const char *buffer,
+ unsigned long count, void *data)
+{
+ struct obd_device *obd = (struct obd_device *)data;
+ int val, rc;
+ LASSERT(obd != NULL);
+
+ rc = lprocfs_write_helper(buffer, count, &val);
+
+ if (rc)
+ return rc;
+
+ spin_lock_bh(&obd->obd_processing_task_lock);
+ obd->u.filter.fo_writethrough_cache = val;
+ spin_unlock_bh(&obd->obd_processing_task_lock);
+ return count;
+}
+
+static int lprocfs_filter_rd_mds_sync(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
+{
+ struct obd_device *obd = (struct obd_device *)data;
+ LASSERT(obd != NULL);
+
+ return snprintf(page, count, "%u\n", obd->u.filter.fo_mds_ost_sync);
+}
+
+int lprocfs_filter_rd_degraded(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
+{
+ struct obd_device *obd = data;
+
+ return snprintf(page, count, "%u\n", obd->u.filter.fo_raid_degraded);
+}
+
+int lprocfs_filter_wr_degraded(struct file *file, const char *buffer,
+ unsigned long count, void *data)
+{
+ struct obd_device *obd = data;
+ int val, rc;
+
+ rc = lprocfs_write_helper(buffer, count, &val);
+ if (rc)
+ return rc;
+
+ spin_lock(&obd->obd_osfs_lock);
+ obd->u.filter.fo_raid_degraded = !!val;
+ spin_unlock(&obd->obd_osfs_lock);
+ return count;
+}
+
static struct lprocfs_vars lprocfs_filter_obd_vars[] = {
{ "uuid", lprocfs_rd_uuid, 0, 0 },
{ "blocksize", lprocfs_rd_blksize, 0, 0 },
lprocfs_filter_rd_readcache,
lprocfs_filter_wr_readcache, 0 },
#ifdef HAVE_QUOTA_SUPPORT
- { "quota_bunit_sz", lprocfs_rd_bunit, lprocfs_wr_bunit, 0},
- { "quota_btune_sz", lprocfs_rd_btune, lprocfs_wr_btune, 0},
- { "quota_iunit_sz", lprocfs_rd_iunit, lprocfs_wr_iunit, 0},
- { "quota_itune_sz", lprocfs_rd_itune, lprocfs_wr_itune, 0},
- { "quota_type", lprocfs_rd_type, lprocfs_wr_type, 0},
+ { "quota_type", lprocfs_quota_rd_type,
+ lprocfs_quota_wr_type, 0},
#endif
{ "client_cache_count", lprocfs_filter_rd_fmd_max_num,
lprocfs_filter_wr_fmd_max_num, 0 },
{ "capa", lprocfs_filter_rd_capa,
lprocfs_filter_wr_capa, 0 },
{ "capa_count", lprocfs_filter_rd_capa_count, 0, 0 },
+ { "sec_level", lprocfs_rd_sec_level,
+ lprocfs_wr_sec_level, 0 },
+ { "read_cache_enable", lprocfs_filter_rd_cache, lprocfs_filter_wr_cache, 0},
+ { "writethrough_cache_enable", lprocfs_filter_rd_wcache,
+ lprocfs_filter_wr_wcache, 0},
+ { "mds_sync", lprocfs_filter_rd_mds_sync, 0, 0},
+ { "degraded", lprocfs_filter_rd_degraded,
+ lprocfs_filter_wr_degraded, 0 },
{ 0 }
};
unsigned long *blocks, int blocks_per_page, int wr)
{
struct filter_obd *filter = &exp->exp_obd->u.filter;
- struct filter_export_data *fed = &exp->exp_filter_data;
struct page *last_page = NULL;
unsigned long *last_block = NULL;
unsigned long discont_pages = 0;
lprocfs_oh_tally_log2(&filter->fo_filter_stats.hist[BRW_R_PAGES + wr],
nr_pages);
- lprocfs_oh_tally_log2(&fed->fed_brw_stats.hist[BRW_R_PAGES + wr],
- nr_pages);
if (exp->exp_nid_stats && exp->exp_nid_stats->nid_brw_stats)
lprocfs_oh_tally_log2(&exp->exp_nid_stats->nid_brw_stats->
hist[BRW_R_PAGES + wr], nr_pages);
lprocfs_oh_tally(&filter->fo_filter_stats.hist[BRW_R_DISCONT_PAGES +wr],
discont_pages);
- lprocfs_oh_tally(&fed->fed_brw_stats.hist[BRW_R_DISCONT_PAGES + wr],
- discont_pages);
lprocfs_oh_tally(&filter->fo_filter_stats.hist[BRW_R_DISCONT_BLOCKS+wr],
discont_blocks);
- lprocfs_oh_tally(&fed->fed_brw_stats.hist[BRW_R_DISCONT_BLOCKS + wr],
- discont_blocks);
if (exp->exp_nid_stats && exp->exp_nid_stats->nid_brw_stats) {
lprocfs_oh_tally_log2(&exp->exp_nid_stats->nid_brw_stats->
&filter_brw_stats_fops, dev);
}
-static int filter_per_export_stats_seq_show(struct seq_file *seq, void *v)
-{
- struct filter_export_data *fed = seq->private;
-
- brw_stats_show(seq, &fed->fed_brw_stats);
-
- return 0;
-}
-
-static ssize_t filter_per_export_stats_seq_write(struct file *file,
- const char *buf, size_t len, loff_t *off)
-{
- struct seq_file *seq = file->private_data;
- struct filter_export_data *fed = seq->private;
- int i;
-
- for (i = 0; i < BRW_LAST; i++)
- lprocfs_oh_clear(&fed->fed_brw_stats.hist[i]);
-
- return len;
-}
-
-LPROC_SEQ_FOPS(filter_per_export_stats);
-
void lprocfs_filter_init_vars(struct lprocfs_static_vars *lvars)
{
lvars->module_vars = lprocfs_filter_module_vars;
static int filter_per_nid_stats_seq_show(struct seq_file *seq, void *v)
{
- nid_stat_t *tmp = seq->private;
+ nid_stat_t * stat = seq->private;
- if (tmp->nid_brw_stats)
- brw_stats_show(seq, tmp->nid_brw_stats);
+ if (stat->nid_brw_stats)
+ brw_stats_show(seq, stat->nid_brw_stats);
return 0;
}
const char *buf, size_t len,
loff_t *off)
{
- struct seq_file *seq = file->private_data;
- nid_stat_t *tmp = seq->private;
+ struct seq_file *seq = file->private_data;
+ nid_stat_t *stat = seq->private;
int i;
- if (tmp->nid_brw_stats)
+ if (stat->nid_brw_stats)
for (i = 0; i < BRW_LAST; i++)
- lprocfs_oh_clear(&tmp->nid_brw_stats->hist[i]);
+ lprocfs_oh_clear(&stat->nid_brw_stats->hist[i]);
return len;
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff