* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2012, 2013, Intel Corporation.
+ * Copyright (c) 2012, 2014, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#define DEBUG_SUBSYSTEM S_LLITE
#include <linux/version.h>
+#include <linux/user_namespace.h>
+#ifdef HAVE_UIDGID_HEADER
+# include <linux/uidgid.h>
+#endif
#include <lustre_param.h>
#include <lprocfs_status.h>
#include <obd_support.h>
struct proc_dir_entry *proc_lustre_fs_root;
-#ifdef LPROCFS
+#ifdef CONFIG_PROC_FS
/* /proc/lustre/llite mount point registration */
-struct file_operations ll_rw_extents_stats_fops;
-struct file_operations ll_rw_extents_stats_pp_fops;
-struct file_operations ll_rw_offset_stats_fops;
+static const struct file_operations ll_rw_extents_stats_fops;
+static const struct file_operations ll_rw_extents_stats_pp_fops;
+static const struct file_operations ll_rw_offset_stats_fops;
static int ll_blksize_seq_show(struct seq_file *m, void *v)
{
return seq_printf(m, "%u\n", sbi->ll_xattr_cache_enabled);
}
-static ssize_t ll_xattr_cache_seq_write(struct file *file, const char *buffer,
+static ssize_t ll_xattr_cache_seq_write(struct file *file,
+ const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
}
static ssize_t
-ll_max_readahead_mb_seq_write(struct file *file, const char *buffer,
+ll_max_readahead_mb_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
- struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
- int mult, rc, pages_number;
+ struct super_block *sb = m->private;
+ struct ll_sb_info *sbi = ll_s2sbi(sb);
+ __u64 val;
+ long pages_number;
+ int pages_shift;
+ int rc;
- mult = 1 << (20 - PAGE_CACHE_SHIFT);
- rc = lprocfs_write_frac_helper(buffer, count, &pages_number, mult);
+ pages_shift = 20 - PAGE_CACHE_SHIFT;
+ rc = lprocfs_write_frac_u64_helper(buffer, count, &val,
+ 1 << pages_shift);
if (rc)
return rc;
+ if (val > LONG_MAX)
+ return -ERANGE;
+ pages_number = (long)val;
+
if (pages_number < 0 || pages_number > totalram_pages / 2) {
/* 1/2 of RAM */
- CERROR("can't set file readahead more than %lu MB\n",
- totalram_pages >> (20 - PAGE_CACHE_SHIFT + 1));
+ CERROR("%s: can't set max_readahead_mb=%lu > %luMB\n",
+ ll_get_fsname(sb, NULL, 0), pages_number >> pages_shift,
+ totalram_pages >> (pages_shift + 1));
return -ERANGE;
}
}
static ssize_t
-ll_max_readahead_per_file_mb_seq_write(struct file *file, const char *buffer,
+ll_max_readahead_per_file_mb_seq_write(struct file *file,
+ const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
- struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
- int mult, rc, pages_number;
+ struct super_block *sb = m->private;
+ struct ll_sb_info *sbi = ll_s2sbi(sb);
+ int pages_shift, rc, pages_number;
- mult = 1 << (20 - PAGE_CACHE_SHIFT);
- rc = lprocfs_write_frac_helper(buffer, count, &pages_number, mult);
+ pages_shift = 20 - PAGE_CACHE_SHIFT;
+ rc = lprocfs_write_frac_helper(buffer, count, &pages_number,
+ 1 << pages_shift);
if (rc)
return rc;
- if (pages_number < 0 ||
- pages_number > sbi->ll_ra_info.ra_max_pages) {
- CERROR("can't set file readahead more than"
- "max_read_ahead_mb %lu MB\n",
- sbi->ll_ra_info.ra_max_pages);
+ if (pages_number < 0 || pages_number > sbi->ll_ra_info.ra_max_pages) {
+ CERROR("%s: can't set max_readahead_per_file_mb=%u > "
+ "max_read_ahead_mb=%lu\n", ll_get_fsname(sb, NULL, 0),
+ pages_number >> pages_shift,
+ sbi->ll_ra_info.ra_max_pages >> pages_shift);
return -ERANGE;
}
}
static ssize_t
-ll_max_read_ahead_whole_mb_seq_write(struct file *file, const char *buffer,
+ll_max_read_ahead_whole_mb_seq_write(struct file *file,
+ const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
- struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
- int mult, rc, pages_number;
+ struct super_block *sb = m->private;
+ struct ll_sb_info *sbi = ll_s2sbi(sb);
+ int pages_shift, rc, pages_number;
- mult = 1 << (20 - PAGE_CACHE_SHIFT);
- rc = lprocfs_write_frac_helper(buffer, count, &pages_number, mult);
+ pages_shift = 20 - PAGE_CACHE_SHIFT;
+ rc = lprocfs_write_frac_helper(buffer, count, &pages_number,
+ 1 << pages_shift);
if (rc)
return rc;
* algorithm does this anyway so it's pointless to set it larger. */
if (pages_number < 0 ||
pages_number > sbi->ll_ra_info.ra_max_pages_per_file) {
- CERROR("can't set max_read_ahead_whole_mb more than "
- "max_read_ahead_per_file_mb: %lu\n",
- sbi->ll_ra_info.ra_max_pages_per_file >>
- (20 - PAGE_CACHE_SHIFT));
+ CERROR("%s: can't set max_read_ahead_whole_mb=%u > "
+ "max_read_ahead_per_file_mb=%lu\n",
+ ll_get_fsname(sb, NULL, 0),
+ pages_number >> pages_shift,
+ sbi->ll_ra_info.ra_max_pages_per_file >> pages_shift);
return -ERANGE;
}
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
- struct cl_client_cache *cache = &sbi->ll_cache;
+ struct cl_client_cache *cache = sbi->ll_cache;
int shift = 20 - PAGE_CACHE_SHIFT;
- int max_cached_mb;
- int unused_mb;
+ long max_cached_mb;
+ long unused_mb;
max_cached_mb = cache->ccc_lru_max >> shift;
- unused_mb = atomic_read(&cache->ccc_lru_left) >> shift;
+ unused_mb = atomic_long_read(&cache->ccc_lru_left) >> shift;
return seq_printf(m,
"users: %d\n"
- "max_cached_mb: %d\n"
- "used_mb: %d\n"
- "unused_mb: %d\n"
+ "max_cached_mb: %ld\n"
+ "used_mb: %ld\n"
+ "unused_mb: %ld\n"
"reclaim_count: %u\n",
atomic_read(&cache->ccc_users),
max_cached_mb,
struct seq_file *m = file->private_data;
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
- struct cl_client_cache *cache = &sbi->ll_cache;
+ struct cl_client_cache *cache = sbi->ll_cache;
struct lu_env *env;
+ __u64 val;
+ long diff = 0;
+ long nrpages = 0;
+ long pages_number;
int refcheck;
- int mult, rc, pages_number;
- int diff = 0;
- int nrpages = 0;
+ int mult;
+ long rc;
char kernbuf[128];
ENTRY;
mult = 1 << (20 - PAGE_CACHE_SHIFT);
buffer += lprocfs_find_named_value(kernbuf, "max_cached_mb:", &count) -
kernbuf;
- rc = lprocfs_write_frac_helper(buffer, count, &pages_number, mult);
+ rc = lprocfs_write_frac_u64_helper(buffer, count, &val, mult);
if (rc)
RETURN(rc);
+ if (val > LONG_MAX)
+ return -ERANGE;
+ pages_number = (long)val;
+
if (pages_number < 0 || pages_number > totalram_pages) {
CERROR("%s: can't set max cache more than %lu MB\n",
ll_get_fsname(sb, NULL, 0),
totalram_pages >> (20 - PAGE_CACHE_SHIFT));
RETURN(-ERANGE);
}
+ /* Allow enough cache so clients can make well-formed RPCs */
+ pages_number = max_t(long, pages_number, PTLRPC_MAX_BRW_PAGES);
spin_lock(&sbi->ll_lock);
diff = pages_number - cache->ccc_lru_max;
/* easy - add more LRU slots. */
if (diff >= 0) {
- atomic_add(diff, &cache->ccc_lru_left);
+ atomic_long_add(diff, &cache->ccc_lru_left);
GOTO(out, rc = 0);
}
diff = -diff;
while (diff > 0) {
- int tmp;
+ long tmp;
/* reduce LRU budget from free slots. */
do {
- int ov, nv;
+ long ov, nv;
- ov = atomic_read(&cache->ccc_lru_left);
+ ov = atomic_long_read(&cache->ccc_lru_left);
if (ov == 0)
break;
nv = ov > diff ? ov - diff : 0;
- rc = atomic_cmpxchg(&cache->ccc_lru_left, ov, nv);
+ rc = atomic_long_cmpxchg(&cache->ccc_lru_left, ov, nv);
if (likely(ov == rc)) {
diff -= ov - nv;
nrpages += ov - nv;
spin_unlock(&sbi->ll_lock);
rc = count;
} else {
- atomic_add(nrpages, &cache->ccc_lru_left);
+ atomic_long_add(nrpages, &cache->ccc_lru_left);
}
return rc;
}
return seq_printf(m, "%u\n", (sbi->ll_flags & LL_SBI_CHECKSUM) ? 1 : 0);
}
-static ssize_t ll_checksum_seq_write(struct file *file, const char *buffer,
+static ssize_t ll_checksum_seq_write(struct file *file,
+ const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
}
LPROC_SEQ_FOPS(ll_checksum);
-static int ll_max_rw_chunk_seq_show(struct seq_file *m, void *v)
-{
- struct super_block *sb = m->private;
-
- return seq_printf(m, "%lu\n", ll_s2sbi(sb)->ll_max_rw_chunk);
-}
-
-static ssize_t ll_max_rw_chunk_seq_write(struct file *file, const char *buffer,
- size_t count, loff_t *off)
-{
- struct seq_file *m = file->private_data;
- struct super_block *sb = m->private;
- int rc, val;
-
- rc = lprocfs_write_helper(buffer, count, &val);
- if (rc)
- return rc;
- ll_s2sbi(sb)->ll_max_rw_chunk = val;
- return count;
-}
-LPROC_SEQ_FOPS(ll_max_rw_chunk);
-
static int ll_rd_track_id(struct seq_file *m, enum stats_track_type type)
{
struct super_block *sb = m->private;
}
}
-static int ll_wr_track_id(const char *buffer, unsigned long count, void *data,
- enum stats_track_type type)
+static int ll_wr_track_id(const char __user *buffer, unsigned long count,
+ void *data, enum stats_track_type type)
{
struct super_block *sb = data;
int rc, pid;
return ll_rd_track_id(m, STATS_TRACK_PID);
}
-static ssize_t ll_track_pid_seq_write(struct file *file, const char *buffer,
+static ssize_t ll_track_pid_seq_write(struct file *file,
+ const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *seq = file->private_data;
return ll_rd_track_id(m, STATS_TRACK_PPID);
}
-static ssize_t ll_track_ppid_seq_write(struct file *file, const char *buffer,
+static ssize_t ll_track_ppid_seq_write(struct file *file,
+ const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *seq = file->private_data;
return ll_rd_track_id(m, STATS_TRACK_GID);
}
-static ssize_t ll_track_gid_seq_write(struct file *file, const char *buffer,
+static ssize_t ll_track_gid_seq_write(struct file *file,
+ const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *seq = file->private_data;
return seq_printf(m, "%u\n", sbi->ll_sa_max);
}
-static ssize_t ll_statahead_max_seq_write(struct file *file, const char *buffer,
+static ssize_t ll_statahead_max_seq_write(struct file *file,
+ const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
sbi->ll_flags & LL_SBI_AGL_ENABLED ? 1 : 0);
}
-static ssize_t ll_statahead_agl_seq_write(struct file *file, const char *buffer,
+static ssize_t ll_statahead_agl_seq_write(struct file *file,
+ const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
(sbi->ll_flags & LL_SBI_LAZYSTATFS) ? 1 : 0);
}
-static ssize_t ll_lazystatfs_seq_write(struct file *file, const char *buffer,
+static ssize_t ll_lazystatfs_seq_write(struct file *file,
+ const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
}
LPROC_SEQ_FOPS_RO(ll_max_easize);
-static int ll_defult_easize_seq_show(struct seq_file *m, void *v)
+/**
+ * Get default_easize.
+ *
+ * \see client_obd::cl_default_mds_easize
+ *
+ * \param[in] m seq_file handle
+ * \param[in] v unused for single entry
+ *
+ * \retval 0 on success
+ * \retval negative negated errno on failure
+ */
+static int ll_default_easize_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
return seq_printf(m, "%u\n", ealen);
}
-LPROC_SEQ_FOPS_RO(ll_defult_easize);
-static int ll_max_cookiesize_seq_show(struct seq_file *m, void *v)
+/**
+ * Set default_easize.
+ *
+ * Range checking on the passed value is handled by
+ * ll_set_default_mdsize().
+ *
+ * \see client_obd::cl_default_mds_easize
+ *
+ * \param[in] file proc file
+ * \param[in] buffer string passed from user space
+ * \param[in] count \a buffer length
+ * \param[in] off unused for single entry
+ *
+ * \retval positive \a count on success
+ * \retval negative negated errno on failure
+ */
+static ssize_t ll_default_easize_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *unused)
{
- struct super_block *sb = m->private;
- struct ll_sb_info *sbi = ll_s2sbi(sb);
- unsigned int cookielen;
- int rc;
+ struct seq_file *seq = file->private_data;
+ struct super_block *sb = (struct super_block *)seq->private;
+ struct ll_sb_info *sbi = ll_s2sbi(sb);
+ int val;
+ int rc;
- rc = ll_get_max_cookiesize(sbi, &cookielen);
- if (rc)
- return rc;
-
- return seq_printf(m, "%u\n", cookielen);
-}
-LPROC_SEQ_FOPS_RO(ll_max_cookiesize);
+ if (count == 0)
+ return 0;
-static int ll_defult_cookiesize_seq_show(struct seq_file *m, void *v)
-{
- struct super_block *sb = m->private;
- struct ll_sb_info *sbi = ll_s2sbi(sb);
- unsigned int cookielen;
- int rc;
+ rc = lprocfs_write_helper(buffer, count, &val);
+ if (rc < 0)
+ return rc;
- rc = ll_get_default_cookiesize(sbi, &cookielen);
+ rc = ll_set_default_mdsize(sbi, val);
if (rc)
return rc;
- return seq_printf(m, "%u\n", cookielen);
+ return count;
}
-LPROC_SEQ_FOPS_RO(ll_defult_cookiesize);
+LPROC_SEQ_FOPS(ll_default_easize);
static int ll_sbi_flags_seq_show(struct seq_file *m, void *v)
{
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
- struct cl_client_cache *cache = &sbi->ll_cache;
- int pages, mb;
+ struct cl_client_cache *cache = sbi->ll_cache;
+ long pages;
+ int mb;
- pages = atomic_read(&cache->ccc_unstable_nr);
+ pages = atomic_long_read(&cache->ccc_unstable_nr);
mb = (pages * PAGE_CACHE_SIZE) >> 20;
- return seq_printf(m, "unstable_check: %8d\n"
- "unstable_pages: %8d\n"
- "unstable_mb: %8d\n",
+ return seq_printf(m, "unstable_check: %8d\n"
+ "unstable_pages: %12ld\n"
+ "unstable_mb: %8d\n",
cache->ccc_unstable_check, pages, mb);
}
return rc;
/* borrow lru lock to set the value */
- spin_lock(&sbi->ll_cache.ccc_lru_lock);
- sbi->ll_cache.ccc_unstable_check = !!val;
- spin_unlock(&sbi->ll_cache.ccc_lru_lock);
+ spin_lock(&sbi->ll_cache->ccc_lru_lock);
+ sbi->ll_cache->ccc_unstable_check = !!val;
+ spin_unlock(&sbi->ll_cache->ccc_lru_lock);
return count;
}
}
LPROC_SEQ_FOPS(ll_nosquash_nids);
-struct lprocfs_seq_vars lprocfs_llite_obd_vars[] = {
+struct lprocfs_vars lprocfs_llite_obd_vars[] = {
{ .name = "uuid",
.fops = &ll_sb_uuid_fops },
{ .name = "fstype",
{ .name = "blocksize",
.fops = &ll_blksize_fops },
{ .name = "kbytestotal",
- .fops = &ll_kbytestotal_fops },
+ .fops = &ll_kbytestotal_fops },
{ .name = "kbytesfree",
.fops = &ll_kbytesfree_fops },
{ .name = "kbytesavail",
.fops = &ll_max_cached_mb_fops },
{ .name = "checksum_pages",
.fops = &ll_checksum_fops },
- { .name = "max_rw_chunk",
- .fops = &ll_max_rw_chunk_fops },
{ .name = "stats_track_pid",
.fops = &ll_track_pid_fops },
{ .name = "stats_track_ppid",
{ .name = "statahead_stats",
.fops = &ll_statahead_stats_fops },
{ .name = "lazystatfs",
- .fops = &ll_lazystatfs_fops },
+ .fops = &ll_lazystatfs_fops },
{ .name = "max_easize",
- .fops = &ll_max_easize_fops },
+ .fops = &ll_max_easize_fops },
{ .name = "default_easize",
- .fops = &ll_defult_easize_fops },
- { .name = "max_cookiesize",
- .fops = &ll_max_cookiesize_fops },
- { .name = "default_cookiesize",
- .fops = &ll_defult_cookiesize_fops },
+ .fops = &ll_default_easize_fops },
{ .name = "sbi_flags",
- .fops = &ll_sbi_flags_fops },
+ .fops = &ll_sbi_flags_fops },
{ .name = "xattr_cache",
.fops = &ll_xattr_cache_fops },
{ .name = "unstable_stats",
.fops = &ll_root_squash_fops },
{ .name = "nosquash_nids",
.fops = &ll_nosquash_nids_fops },
- { 0 }
+ { NULL }
};
#define MAX_STRING_SIZE 128
int lprocfs_register_mountpoint(struct proc_dir_entry *parent,
struct super_block *sb, char *osc, char *mdc)
{
- struct lprocfs_seq_vars lvars[2];
+ struct lprocfs_vars lvars[2];
struct lustre_sb_info *lsi = s2lsi(sb);
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct obd_device *obd;
snprintf(name, MAX_STRING_SIZE, "%.*s-%p", len,
lsi->lsi_lmd->lmd_profile, sb);
- sbi->ll_proc_root = lprocfs_seq_register(name, parent, NULL, NULL);
+ sbi->ll_proc_root = lprocfs_register(name, parent, NULL, NULL);
if (IS_ERR(sbi->ll_proc_root)) {
err = PTR_ERR(sbi->ll_proc_root);
sbi->ll_proc_root = NULL;
GOTO(out, err);
- err = lprocfs_seq_add_vars(sbi->ll_proc_root, lprocfs_llite_obd_vars, sb);
+ err = lprocfs_add_vars(sbi->ll_proc_root, lprocfs_llite_obd_vars, sb);
if (err)
GOTO(out, err);
snprintf(name, MAX_STRING_SIZE, "common_name");
lvars[0].fops = &llite_name_fops;
- err = lprocfs_seq_add_vars(dir, lvars, obd);
+ err = lprocfs_add_vars(dir, lvars, obd);
if (err)
GOTO(out, err);
snprintf(name, MAX_STRING_SIZE, "uuid");
lvars[0].fops = &llite_uuid_fops;
- err = lprocfs_seq_add_vars(dir, lvars, obd);
+ err = lprocfs_add_vars(dir, lvars, obd);
if (err)
GOTO(out, err);
snprintf(name, MAX_STRING_SIZE, "common_name");
lvars[0].fops = &llite_name_fops;
- err = lprocfs_seq_add_vars(dir, lvars, obd);
+ err = lprocfs_add_vars(dir, lvars, obd);
if (err)
GOTO(out, err);
snprintf(name, MAX_STRING_SIZE, "uuid");
lvars[0].fops = &llite_uuid_fops;
- err = lprocfs_seq_add_vars(dir, lvars, obd);
+ err = lprocfs_add_vars(dir, lvars, obd);
out:
if (err) {
lprocfs_remove(&sbi->ll_proc_root);
}
LPROC_SEQ_FOPS(ll_rw_offset_stats);
-#endif /* LPROCFS */
+#endif /* CONFIG_PROC_FS */
git://git.whamcloud.com / fs / lustre-release.git / blobdiff