* 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/
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 ll_sb_info *sbi = ll_s2sbi(sb);
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 ll_sb_info *sbi = ll_s2sbi(sb);
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;
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,
+static ssize_t ll_max_rw_chunk_seq_write(struct file *file,
+ const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
}
}
-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;
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;
+ 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);
}
}
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",
.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 */