开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
sysctl.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：12k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

sysctl.c：源码内容
  1. /*
  2.  * Sysctl operations for Coda filesystem
  3.  * Original version: (C) 1996 P. Braam and M. Callahan
  4.  * Rewritten for Linux 2.1. (C) 1997 Carnegie Mellon University
  5.  * 
  6.  * Carnegie Mellon encourages users to contribute improvements to
  7.  * the Coda project. Contact Peter Braam (coda@cs.cmu.edu).
  8.  * 
  9.  * CODA operation statistics
  10.  * (c) March, 1998 Zhanyong Wan <zhanyong.wan@yale.edu>
  11.  *
  12.  */
  14. #include <linux/config.h>
  15. #include <linux/sched.h>
  16. #include <linux/mm.h>
  17. #include <linux/sysctl.h>
  18. #include <linux/swapctl.h>
  19. #include <linux/proc_fs.h>
  20. #include <linux/slab.h>
  21. #include <linux/stat.h>
  22. #include <linux/ctype.h>
  23. #include <asm/bitops.h>
  24. #include <asm/segment.h>
  25. #include <asm/uaccess.h>
  26. #include <linux/utsname.h>
  27. #define __NO_VERSION__
  28. #include <linux/module.h>
  30. #include <linux/coda.h>
  31. #include <linux/coda_linux.h>
  32. #include <linux/coda_fs_i.h>
  33. #include <linux/coda_psdev.h>
  34. #include <linux/coda_cache.h>
  35. #include <linux/coda_proc.h>
  37. static struct ctl_table_header *fs_table_header;
  39. #define FS_CODA         1       /* Coda file system */
  41. #define CODA_DEBUG    1  /* control debugging */
  42. #define CODA_ENTRY  2       /* control enter/leave pattern */
  43. #define CODA_TIMEOUT    3       /* timeout on upcalls to become intrble */
  44. #define CODA_MC         4       /* use/do not use the access cache */
  45. #define CODA_HARD       5       /* mount type "hard" or "soft" */
  46. #define CODA_VFS   6       /* vfs statistics */
  47. #define CODA_UPCALL   7       /* upcall statistics */
  48. #define CODA_PERMISSION  8       /* permission statistics */
  49. #define CODA_CACHE_INV   9       /* cache invalidation statistics */
  50. #define CODA_FAKE_STATFS 10  /* don't query venus for actual cache usage */
  52. static ctl_table coda_table[] = {
  53. {CODA_DEBUG, "debug", &coda_debug, sizeof(int), 0644, NULL, &proc_dointvec},
  54. {CODA_ENTRY, "printentry", &coda_print_entry, sizeof(int), 0644, NULL, &proc_dointvec},
  55.   {CODA_MC, "accesscache", &coda_access_cache, sizeof(int), 0644, NULL, &proc_dointvec}, 
  56.   {CODA_TIMEOUT, "timeout", &coda_timeout, sizeof(int), 0644, NULL, &proc_dointvec},
  57.   {CODA_HARD, "hard", &coda_hard, sizeof(int), 0644, NULL, &proc_dointvec},
  58.   {CODA_VFS, "vfs_stats", NULL, 0, 0644, NULL, &do_reset_coda_vfs_stats},
  59.   {CODA_UPCALL, "upcall_stats", NULL, 0, 0644, NULL, &do_reset_coda_upcall_stats},
  60.   {CODA_PERMISSION, "permission_stats", NULL, 0, 0644, NULL, &do_reset_coda_permission_stats},
  61.   {CODA_CACHE_INV, "cache_inv_stats", NULL, 0, 0644, NULL, &do_reset_coda_cache_inv_stats},
  62.   {CODA_FAKE_STATFS, "fake_statfs", &coda_fake_statfs, sizeof(int), 0600, NULL, &proc_dointvec},
  63. { 0 }
  64. };
  66. static ctl_table fs_table[] = {
  67.        {FS_CODA, "coda",    NULL, 0, 0555, coda_table},
  68.        {0}
  69. };
  71. struct coda_vfs_stats coda_vfs_stat;
  72. struct coda_permission_stats coda_permission_stat;
  73. struct coda_cache_inv_stats coda_cache_inv_stat;
  74. struct coda_upcall_stats_entry  coda_upcall_stat[CODA_NCALLS];
  75. struct coda_upcallstats         coda_callstats;
  76. int                             coda_upcall_timestamping = 0;
  78. /* keep this in sync with coda.h! */
  79. char *coda_upcall_names[] = {
  80. "totals      ",   /*  0 */
  81. "-           ",   /*  1 */
  82. "root        ",   /*  2 */
  83. "open_by_fd  ",   /*  3 */
  84. "open        ",   /*  4 */
  85. "close       ",   /*  5 */
  86. "ioctl       ",   /*  6 */
  87. "getattr     ",   /*  7 */
  88. "setattr     ",   /*  8 */
  89. "access      ",   /*  9 */
  90. "lookup      ",   /* 10 */
  91. "create      ",   /* 11 */
  92. "remove      ",   /* 12 */
  93. "link        ",   /* 13 */
  94. "rename      ",   /* 14 */
  95. "mkdir       ",   /* 15 */
  96. "rmdir       ",   /* 16 */
  97. "readdir     ",   /* 17 */
  98. "symlink     ",   /* 18 */
  99. "readlink    ",   /* 19 */
  100. "fsync       ",   /* 20 */
  101. "-           ",   /* 21 */
  102. "vget        ",   /* 22 */
  103. "signal      ",   /* 23 */
  104. "replace     ",   /* 24 */
  105. "flush       ",   /* 25 */
  106. "purgeuser   ",   /* 26 */
  107. "zapfile     ",   /* 27 */
  108. "zapdir      ",   /* 28 */
  109. "-           ",   /* 29 */
  110. "purgefid    ",   /* 30 */
  111. "open_by_path",   /* 31 */
  112. "resolve     ",   /* 32 */
  113. "reintegrate ",   /* 33 */
  114. "statfs      ",   /* 34 */
  115. "store       ",   /* 35 */
  116. "release     "    /* 36 */
  117. };
  120. void reset_coda_vfs_stats( void )
  121. {
  122. memset( &coda_vfs_stat, 0, sizeof( coda_vfs_stat ) );
  123. }
  125. void reset_coda_upcall_stats( void )
  126. {
  127. memset( &coda_upcall_stat, 0, sizeof( coda_upcall_stat ) );
  128. }
  130. void reset_coda_permission_stats( void )
  131. {
  132. memset( &coda_permission_stat, 0, sizeof( coda_permission_stat ) );
  133. }
  135. void reset_coda_cache_inv_stats( void )
  136. {
  137. memset( &coda_cache_inv_stat, 0, sizeof( coda_cache_inv_stat ) );
  138. }
  141. void do_time_stats( struct coda_upcall_stats_entry * pentry, 
  142.     unsigned long runtime )
  143. {
  144. unsigned long time = runtime; /* time in us */
  145. CDEBUG(D_SPECIAL, "time: %ldn", time);
  147. if ( pentry->count == 0 ) {
  148. pentry->time_sum = pentry->time_squared_sum = 0;
  149. }
  151. pentry->count++;
  152. pentry->time_sum += time;
  153. pentry->time_squared_sum += time*time;
  154. }
  158. void coda_upcall_stats(int opcode, long unsigned runtime) 
  159. {
  160. struct coda_upcall_stats_entry * pentry;
  162. if ( opcode < 0 || opcode > CODA_NCALLS - 1) {
  163. printk("Nasty opcode %d passed to coda_upcall_statsn",
  164.        opcode);
  165. return;
  166. }
  168. pentry = &coda_upcall_stat[opcode];
  169. do_time_stats(pentry, runtime);
  171.         /* fill in the totals */
  172. pentry = &coda_upcall_stat[0];
  173. do_time_stats(pentry, runtime);
  175. }
  177. unsigned long get_time_average( const struct coda_upcall_stats_entry * pentry )
  178. {
  179. return ( pentry->count == 0 ) ? 0 : pentry->time_sum / pentry->count;
  180. }
  182. static inline unsigned long absolute( unsigned long x )
  183. {
  184. return x >= 0 ? x : -x;
  185. }
  187. static unsigned long sqr_root( unsigned long x )
  188. {
  189. unsigned long y = x, r;
  190. int n_bit = 0;
  191.   
  192. if ( x == 0 )
  193. return 0;
  194. if ( x < 0)
  195. x = -x;
  197. while ( y ) {
  198. y >>= 1;
  199. n_bit++;
  200. }
  201.   
  202. r = 1 << (n_bit/2);
  203.   
  204. while ( 1 ) {
  205. r = (r + x/r)/2;
  206. if ( r*r <= x && x < (r+1)*(r+1) )
  207. break;
  208. }
  209.   
  210. return r;
  211. }
  213. unsigned long get_time_std_deviation( const struct coda_upcall_stats_entry * pentry )
  214. {
  215. unsigned long time_avg;
  216.   
  217. if ( pentry->count <= 1 )
  218. return 0;
  219.   
  220. time_avg = get_time_average( pentry );
  222. return sqr_root( (pentry->time_squared_sum / pentry->count) - 
  223.     time_avg * time_avg );
  224. }
  226. int do_reset_coda_vfs_stats( ctl_table * table, int write, struct file * filp,
  227.      void * buffer, size_t * lenp )
  228. {
  229. if ( write ) {
  230. reset_coda_vfs_stats();
  232. filp->f_pos += *lenp;
  233. } else {
  234. *lenp = 0;
  235. }
  237. return 0;
  238. }
  240. int do_reset_coda_upcall_stats( ctl_table * table, int write, 
  241. struct file * filp, void * buffer, 
  242. size_t * lenp )
  243. {
  244. if ( write ) {
  245.          if (*lenp > 0) {
  246. char c;
  247.                  if (get_user(c, (char *)buffer))
  248.         return -EFAULT;
  249.                         coda_upcall_timestamping = (c == '1');
  250.                 }
  251. reset_coda_upcall_stats();
  253. filp->f_pos += *lenp;
  254. } else {
  255. *lenp = 0;
  256. }
  258. return 0;
  259. }
  261. int do_reset_coda_permission_stats( ctl_table * table, int write, 
  262.     struct file * filp, void * buffer, 
  263.     size_t * lenp )
  264. {
  265. if ( write ) {
  266. reset_coda_permission_stats();
  268. filp->f_pos += *lenp;
  269. } else {
  270. *lenp = 0;
  271. }
  273. return 0;
  274. }
  276. int do_reset_coda_cache_inv_stats( ctl_table * table, int write, 
  277.    struct file * filp, void * buffer, 
  278.    size_t * lenp )
  279. {
  280. if ( write ) {
  281. reset_coda_cache_inv_stats();
  283. filp->f_pos += *lenp;
  284. } else {
  285. *lenp = 0;
  286. }
  287.   
  288. return 0;
  289. }
  291. int coda_vfs_stats_get_info( char * buffer, char ** start, off_t offset,
  292.      int length)
  293. {
  294. int len=0;
  295. off_t begin;
  296. struct coda_vfs_stats * ps = & coda_vfs_stat;
  297.   
  298.   /* this works as long as we are below 1024 characters! */
  299. len += sprintf( buffer,
  300. "Coda VFS statisticsn"
  301. "===================nn"
  302. "File Operations:n"
  303. "topentt%9dn"
  304. "tflushtt%9dn"
  305. "treleasett%9dn"
  306. "tfsynctt%9dnn"
  307. "Dir Operations:n"
  308. "treaddirtt%9dnn"
  309. "Inode Operationsn"
  310. "tcreatett%9dn"
  311. "tlookuptt%9dn"
  312. "tlinktt%9dn"
  313. "tunlinktt%9dn"
  314. "tsymlinktt%9dn"
  315. "tmkdirtt%9dn"
  316. "trmdirtt%9dn"
  317. "trenamett%9dn"
  318. "tpermissiont%9dn",
  320. /* file operations */
  321. ps->open,
  322. ps->flush,
  323. ps->release,
  324. ps->fsync,
  326. /* dir operations */
  327. ps->readdir,
  328.   
  329. /* inode operations */
  330. ps->create,
  331. ps->lookup,
  332. ps->link,
  333. ps->unlink,
  334. ps->symlink,
  335. ps->mkdir,
  336. ps->rmdir,
  337. ps->rename,
  338. ps->permission); 
  340. begin = offset;
  341. *start = buffer + begin;
  342. len -= begin;
  344. if ( len > length )
  345. len = length;
  346. if ( len < 0 )
  347. len = 0;
  349. return len;
  350. }
  352. int coda_upcall_stats_get_info( char * buffer, char ** start, off_t offset,
  353. int length)
  354. {
  355. int len=0;
  356. int i;
  357. off_t begin;
  358. off_t pos = 0;
  359. char tmpbuf[80];
  360. int tmplen = 0;
  362. /* this works as long as we are below 1024 characters! */
  363. if ( offset < 80 ) 
  364. len += sprintf( buffer,"%-79sn", "Coda upcall statistics");
  365. if ( offset < 160) 
  366. len += sprintf( buffer + len,"%-79sn", "======================");
  367. if ( offset < 240) 
  368. len += sprintf( buffer + len,"%-79sn", "upcall              count       avg time(us)    std deviation(us)");
  369. if ( offset < 320) 
  370. len += sprintf( buffer + len,"%-79sn", "------              -----       ------------    -----------------");
  371. pos = 320; 
  372. for ( i = 0 ; i < CODA_NCALLS ; i++ ) {
  373. tmplen += sprintf(tmpbuf,"%s    %9d       %10ld      %10ld", 
  374.   coda_upcall_names[i],
  375.   coda_upcall_stat[i].count, 
  376.   get_time_average(&coda_upcall_stat[i]),
  377.   coda_upcall_stat[i].time_squared_sum);
  378. pos += 80;
  379. if ( pos < offset ) 
  380. continue; 
  381. len += sprintf(buffer + len, "%-79sn", tmpbuf);
  382. if ( len >= length ) 
  383. break; 
  384. }
  385.   
  386. begin = len- (pos - offset);
  387. *start = buffer + begin;
  388. len -= begin;
  390. if ( len > length )
  391. len = length;
  392. if ( len < 0 )
  393. len = 0;
  395. return len;
  396. }
  398. int coda_permission_stats_get_info( char * buffer, char ** start, off_t offset,
  399.     int length)
  400. {
  401. int len=0;
  402. off_t begin;
  403. struct coda_permission_stats * ps = & coda_permission_stat;
  404.   
  405. /* this works as long as we are below 1024 characters! */
  406. len += sprintf( buffer,
  407. "Coda permission statisticsn"
  408. "==========================nn"
  409. "counttt%9dn"
  410. "hit countt%9dn",
  412. ps->count,
  413. ps->hit_count );
  414.   
  415. begin = offset;
  416. *start = buffer + begin;
  417. len -= begin;
  419. if ( len > length )
  420. len = length;
  421. if ( len < 0 )
  422. len = 0;
  424. return len;
  425. }
  427. int coda_cache_inv_stats_get_info( char * buffer, char ** start, off_t offset,
  428.    int length)
  429. {
  430. int len=0;
  431. off_t begin;
  432. struct coda_cache_inv_stats * ps = & coda_cache_inv_stat;
  433.   
  434. /* this works as long as we are below 1024 characters! */
  435. len += sprintf( buffer,
  436. "Coda cache invalidation statisticsn"
  437. "==================================nn"
  438. "flushtt%9dn"
  439. "purge usert%9dn"
  440. "zap_dirtt%9dn"
  441. "zap_filet%9dn"
  442. "zap_vnodet%9dn"
  443. "purge_fidt%9dn"
  444. "replacett%9dn",
  445. ps->flush,
  446. ps->purge_user,
  447. ps->zap_dir,
  448. ps->zap_file,
  449. ps->zap_vnode,
  450. ps->purge_fid,
  451. ps->replace );
  452.   
  453. begin = offset;
  454. *start = buffer + begin;
  455. len -= begin;
  457. if ( len > length )
  458. len = length;
  459. if ( len < 0 )
  460. len = 0;
  462. return len;
  463. }
  466. #ifdef CONFIG_PROC_FS
  468. /*
  469.  target directory structure:
  470.    /proc/fs  (see linux/fs/proc/root.c)
  471.    /proc/fs/coda
  472.    /proc/fs/coda/{vfs_stats,
  474. */
  476. struct proc_dir_entry* proc_fs_coda;
  478. #endif
  480. #define coda_proc_create(name,get_info) 
  481. create_proc_info_entry(name, 0, proc_fs_coda, get_info)
  483. void coda_sysctl_init()
  484. {
  485. memset(&coda_callstats, 0, sizeof(coda_callstats));
  486. reset_coda_vfs_stats();
  487. reset_coda_upcall_stats();
  488. reset_coda_permission_stats();
  489. reset_coda_cache_inv_stats();
  491. #ifdef CONFIG_PROC_FS
  492. proc_fs_coda = proc_mkdir("coda", proc_root_fs);
  493. if (proc_fs_coda) {
  494. proc_fs_coda->owner = THIS_MODULE;
  495. coda_proc_create("vfs_stats", coda_vfs_stats_get_info);
  496. coda_proc_create("upcall_stats", coda_upcall_stats_get_info);
  497. coda_proc_create("permission_stats", coda_permission_stats_get_info);
  498. coda_proc_create("cache_inv_stats", coda_cache_inv_stats_get_info);
  499. }
  500. #endif
  502. #ifdef CONFIG_SYSCTL
  503. if ( !fs_table_header )
  504. fs_table_header = register_sysctl_table(fs_table, 0);
  505. #endif 
  506. }
  508. void coda_sysctl_clean() 
  509. {
  511. #ifdef CONFIG_SYSCTL
  512. if ( fs_table_header ) {
  513. unregister_sysctl_table(fs_table_header);
  514. fs_table_header = 0;
  515. }
  516. #endif
  518. #if CONFIG_PROC_FS
  519.         remove_proc_entry("cache_inv_stats", proc_fs_coda);
  520.         remove_proc_entry("permission_stats", proc_fs_coda);
  521.         remove_proc_entry("upcall_stats", proc_fs_coda);
  522.         remove_proc_entry("vfs_stats", proc_fs_coda);
  523. remove_proc_entry("coda", proc_root_fs);
  524. #endif 
  525. }