mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-29 04:09:39 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
254 lines
5.6 KiB
C
254 lines
5.6 KiB
C
/*
|
|
* Sysctl operations for Coda filesystem
|
|
* Original version: (C) 1996 P. Braam and M. Callahan
|
|
* Rewritten for Linux 2.1. (C) 1997 Carnegie Mellon University
|
|
*
|
|
* Carnegie Mellon encourages users to contribute improvements to
|
|
* the Coda project. Contact Peter Braam (coda@cs.cmu.edu).
|
|
*
|
|
* CODA operation statistics
|
|
* (c) March, 1998 Zhanyong Wan <zhanyong.wan@yale.edu>
|
|
*
|
|
*/
|
|
|
|
#include <linux/config.h>
|
|
#include <linux/time.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/sysctl.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/stat.h>
|
|
#include <linux/ctype.h>
|
|
#include <linux/bitops.h>
|
|
#include <asm/uaccess.h>
|
|
#include <linux/utsname.h>
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/coda.h>
|
|
#include <linux/coda_linux.h>
|
|
#include <linux/coda_fs_i.h>
|
|
#include <linux/coda_psdev.h>
|
|
#include <linux/coda_cache.h>
|
|
#include <linux/coda_proc.h>
|
|
|
|
static struct ctl_table_header *fs_table_header;
|
|
|
|
#define FS_CODA 1 /* Coda file system */
|
|
|
|
#define CODA_TIMEOUT 3 /* timeout on upcalls to become intrble */
|
|
#define CODA_HARD 5 /* mount type "hard" or "soft" */
|
|
#define CODA_VFS 6 /* vfs statistics */
|
|
#define CODA_CACHE_INV 9 /* cache invalidation statistics */
|
|
#define CODA_FAKE_STATFS 10 /* don't query venus for actual cache usage */
|
|
|
|
struct coda_vfs_stats coda_vfs_stat;
|
|
static struct coda_cache_inv_stats coda_cache_inv_stat;
|
|
|
|
static void reset_coda_vfs_stats( void )
|
|
{
|
|
memset( &coda_vfs_stat, 0, sizeof( coda_vfs_stat ) );
|
|
}
|
|
|
|
static void reset_coda_cache_inv_stats( void )
|
|
{
|
|
memset( &coda_cache_inv_stat, 0, sizeof( coda_cache_inv_stat ) );
|
|
}
|
|
|
|
static int do_reset_coda_vfs_stats( ctl_table * table, int write,
|
|
struct file * filp, void __user * buffer,
|
|
size_t * lenp, loff_t * ppos )
|
|
{
|
|
if ( write ) {
|
|
reset_coda_vfs_stats();
|
|
|
|
*ppos += *lenp;
|
|
} else {
|
|
*lenp = 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_reset_coda_cache_inv_stats( ctl_table * table, int write,
|
|
struct file * filp,
|
|
void __user * buffer,
|
|
size_t * lenp, loff_t * ppos )
|
|
{
|
|
if ( write ) {
|
|
reset_coda_cache_inv_stats();
|
|
|
|
*ppos += *lenp;
|
|
} else {
|
|
*lenp = 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int coda_vfs_stats_get_info( char * buffer, char ** start,
|
|
off_t offset, int length)
|
|
{
|
|
int len=0;
|
|
off_t begin;
|
|
struct coda_vfs_stats * ps = & coda_vfs_stat;
|
|
|
|
/* this works as long as we are below 1024 characters! */
|
|
len += sprintf( buffer,
|
|
"Coda VFS statistics\n"
|
|
"===================\n\n"
|
|
"File Operations:\n"
|
|
"\topen\t\t%9d\n"
|
|
"\tflush\t\t%9d\n"
|
|
"\trelease\t\t%9d\n"
|
|
"\tfsync\t\t%9d\n\n"
|
|
"Dir Operations:\n"
|
|
"\treaddir\t\t%9d\n\n"
|
|
"Inode Operations\n"
|
|
"\tcreate\t\t%9d\n"
|
|
"\tlookup\t\t%9d\n"
|
|
"\tlink\t\t%9d\n"
|
|
"\tunlink\t\t%9d\n"
|
|
"\tsymlink\t\t%9d\n"
|
|
"\tmkdir\t\t%9d\n"
|
|
"\trmdir\t\t%9d\n"
|
|
"\trename\t\t%9d\n"
|
|
"\tpermission\t%9d\n",
|
|
|
|
/* file operations */
|
|
ps->open,
|
|
ps->flush,
|
|
ps->release,
|
|
ps->fsync,
|
|
|
|
/* dir operations */
|
|
ps->readdir,
|
|
|
|
/* inode operations */
|
|
ps->create,
|
|
ps->lookup,
|
|
ps->link,
|
|
ps->unlink,
|
|
ps->symlink,
|
|
ps->mkdir,
|
|
ps->rmdir,
|
|
ps->rename,
|
|
ps->permission);
|
|
|
|
begin = offset;
|
|
*start = buffer + begin;
|
|
len -= begin;
|
|
|
|
if ( len > length )
|
|
len = length;
|
|
if ( len < 0 )
|
|
len = 0;
|
|
|
|
return len;
|
|
}
|
|
|
|
static int coda_cache_inv_stats_get_info( char * buffer, char ** start,
|
|
off_t offset, int length)
|
|
{
|
|
int len=0;
|
|
off_t begin;
|
|
struct coda_cache_inv_stats * ps = & coda_cache_inv_stat;
|
|
|
|
/* this works as long as we are below 1024 characters! */
|
|
len += sprintf( buffer,
|
|
"Coda cache invalidation statistics\n"
|
|
"==================================\n\n"
|
|
"flush\t\t%9d\n"
|
|
"purge user\t%9d\n"
|
|
"zap_dir\t\t%9d\n"
|
|
"zap_file\t%9d\n"
|
|
"zap_vnode\t%9d\n"
|
|
"purge_fid\t%9d\n"
|
|
"replace\t\t%9d\n",
|
|
ps->flush,
|
|
ps->purge_user,
|
|
ps->zap_dir,
|
|
ps->zap_file,
|
|
ps->zap_vnode,
|
|
ps->purge_fid,
|
|
ps->replace );
|
|
|
|
begin = offset;
|
|
*start = buffer + begin;
|
|
len -= begin;
|
|
|
|
if ( len > length )
|
|
len = length;
|
|
if ( len < 0 )
|
|
len = 0;
|
|
|
|
return len;
|
|
}
|
|
|
|
static ctl_table coda_table[] = {
|
|
{CODA_TIMEOUT, "timeout", &coda_timeout, sizeof(int), 0644, NULL, &proc_dointvec},
|
|
{CODA_HARD, "hard", &coda_hard, sizeof(int), 0644, NULL, &proc_dointvec},
|
|
{CODA_VFS, "vfs_stats", NULL, 0, 0644, NULL, &do_reset_coda_vfs_stats},
|
|
{CODA_CACHE_INV, "cache_inv_stats", NULL, 0, 0644, NULL, &do_reset_coda_cache_inv_stats},
|
|
{CODA_FAKE_STATFS, "fake_statfs", &coda_fake_statfs, sizeof(int), 0600, NULL, &proc_dointvec},
|
|
{ 0 }
|
|
};
|
|
|
|
static ctl_table fs_table[] = {
|
|
{FS_CODA, "coda", NULL, 0, 0555, coda_table},
|
|
{0}
|
|
};
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
/*
|
|
target directory structure:
|
|
/proc/fs (see linux/fs/proc/root.c)
|
|
/proc/fs/coda
|
|
/proc/fs/coda/{vfs_stats,
|
|
|
|
*/
|
|
|
|
static struct proc_dir_entry* proc_fs_coda;
|
|
|
|
#endif
|
|
|
|
#define coda_proc_create(name,get_info) \
|
|
create_proc_info_entry(name, 0, proc_fs_coda, get_info)
|
|
|
|
void coda_sysctl_init(void)
|
|
{
|
|
reset_coda_vfs_stats();
|
|
reset_coda_cache_inv_stats();
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
proc_fs_coda = proc_mkdir("coda", proc_root_fs);
|
|
if (proc_fs_coda) {
|
|
proc_fs_coda->owner = THIS_MODULE;
|
|
coda_proc_create("vfs_stats", coda_vfs_stats_get_info);
|
|
coda_proc_create("cache_inv_stats", coda_cache_inv_stats_get_info);
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
if ( !fs_table_header )
|
|
fs_table_header = register_sysctl_table(fs_table, 0);
|
|
#endif
|
|
}
|
|
|
|
void coda_sysctl_clean(void)
|
|
{
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
if ( fs_table_header ) {
|
|
unregister_sysctl_table(fs_table_header);
|
|
fs_table_header = NULL;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
remove_proc_entry("cache_inv_stats", proc_fs_coda);
|
|
remove_proc_entry("vfs_stats", proc_fs_coda);
|
|
remove_proc_entry("coda", proc_root_fs);
|
|
#endif
|
|
}
|