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

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

嵌入式Linux

开发平台：

Unix_Linux

procfs.c：源码内容
  1. /* -*- linux-c -*- */
  3. /* fs/reiserfs/procfs.c */
  5. /*
  6.  * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
  7.  */
  9. /* proc info support a la one created by Sizif@Botik.RU for PGC */
  11. /* $Id: procfs.c,v 1.1.8.2 2001/07/15 17:08:42 god Exp $ */
  13. #include <linux/config.h>
  14. #include <linux/module.h>
  15. #include <linux/sched.h>
  16. #include <asm/uaccess.h>
  17. #include <linux/reiserfs_fs.h>
  18. #include <linux/reiserfs_fs_sb.h>
  19. #include <linux/smp_lock.h>
  20. #include <linux/locks.h>
  21. #include <linux/init.h>
  22. #include <linux/proc_fs.h>
  24. #if defined( REISERFS_PROC_INFO )
  26. /*
  27.  * LOCKING:
  28.  *
  29.  * We rely on new Alexander Viro's super-block locking.
  30.  *
  31.  */
  33. static struct super_block *procinfo_prologue( kdev_t dev )
  34. {
  35. struct super_block *result;
  37. /* get super-block by device */
  38. result = get_super( dev );
  39. if( result != NULL ) {
  40. if( !reiserfs_is_super( result ) ) {
  41. printk( KERN_DEBUG "reiserfs: procfs-52: "
  42. "non-reiserfs super foundn" );
  43. drop_super( result );
  44. result = NULL;
  45. }
  46. } else
  47. printk( KERN_DEBUG "reiserfs: procfs-74: "
  48. "race between procinfo and umountn" );
  49. return result;
  50. }
  52. int procinfo_epilogue( struct super_block *super )
  53. {
  54. drop_super( super );
  55. return 0;
  56. }
  58. int reiserfs_proc_tail( int len, char *buffer, char **start, 
  59. off_t offset, int count, int *eof )
  60. {
  61. /* this is black procfs magic */
  62. if( offset >= len ) {
  63. *start = buffer;
  64. *eof = 1;
  65. return 0;
  66. }
  67. *start = buffer + offset;
  68. if( ( len -= offset ) > count ) {
  69. return count;
  70. }
  71. *eof = 1;
  72. return len;
  73. }
  75. int reiserfs_version_in_proc( char *buffer, char **start, off_t offset,
  76.       int count, int *eof, void *data )
  77. {
  78. int len = 0;
  79. struct super_block *sb;
  80. char *format;
  81.     
  82. sb = procinfo_prologue( ( kdev_t ) ( long ) data );
  83. if( sb == NULL )
  84. return -ENOENT;
  85. if ( sb->u.reiserfs_sb.s_properties & (1 << REISERFS_3_6) ) {
  86. format = "3.6";
  87. } else if ( sb->u.reiserfs_sb.s_properties & (1 << REISERFS_3_5) ) {
  88. format = "3.5";
  89. } else {
  90. format = "unknown";
  91. }
  92. len += sprintf( &buffer[ len ], "%s formattwith checks %sn",
  93. format,
  94. #if defined( CONFIG_REISERFS_CHECK )
  95. "on"
  96. #else
  97. "off"
  98. #endif
  99. );
  100. procinfo_epilogue( sb );
  101. return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
  102. }
  104. int reiserfs_global_version_in_proc( char *buffer, char **start, off_t offset,
  105.      int count, int *eof, void *data )
  106. {
  107. int len = 0;
  108.     
  109. len += sprintf( &buffer[ len ], "%s [%s]n", 
  110. reiserfs_get_version_string(),
  111. #if defined( CONFIG_REISERFS_FS_MODULE )
  112. "as module"
  113. #else
  114. "built into kernel"
  115. #endif
  116. );
  117. return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
  118. }
  120. #define SF( x ) ( r -> x )
  121. #define SFP( x ) SF( s_proc_info_data.x )
  122. #define SFPL( x ) SFP( x[ level ] )
  123. #define SFPF( x ) SFP( find_forward.x )
  124. #define SFPJ( x ) SFP( journal.x )
  126. #define D2C( x ) le16_to_cpu( x )
  127. #define D4C( x ) le32_to_cpu( x )
  128. #define DF( x ) D2C( rs -> x )
  129. #define DFL( x ) D4C( rs -> x )
  131. #define objectid_map( s, rs ) (old_format_only (s) ?
  132.                          (__u32 *)((struct reiserfs_super_block_v1 *)rs + 1) :
  133.  (__u32 *)(rs + 1))
  134. #define MAP( i ) D4C( objectid_map( sb, rs )[ i ] )
  136. #define DJF( x ) le32_to_cpu( rs -> x )
  137. #define JF( x ) ( r -> s_journal -> x )
  139. int reiserfs_super_in_proc( char *buffer, char **start, off_t offset,
  140.     int count, int *eof, void *data )
  141. {
  142. struct super_block *sb;
  143. struct reiserfs_sb_info *r;
  144. int len = 0;
  145.     
  146. sb = procinfo_prologue( ( kdev_t ) ( long ) data );
  147. if( sb == NULL )
  148. return -ENOENT;
  149. r = &sb->u.reiserfs_sb;
  150. len += sprintf( &buffer[ len ], 
  151. "state: t%sn"
  152. "mount options: t%s%s%s%s%s%s%s%s%s%s%s%sn"
  153. "gen. counter: t%in"
  154. "s_kmallocs: t%in"
  155. "s_disk_reads: t%in"
  156. "s_disk_writes: t%in"
  157. "s_fix_nodes: t%in"
  158. "s_do_balance: t%in"
  159. "s_unneeded_left_neighbor: t%in"
  160. "s_good_search_by_key_reada: t%in"
  161. "s_bmaps: t%in"
  162. "s_bmaps_without_search: t%in"
  163. "s_direct2indirect: t%in"
  164. "s_indirect2direct: t%in"
  165. "n"
  166. "max_hash_collisions: t%in"
  168. "breads: t%lun"
  169. "bread_misses: t%lun"
  171. "search_by_key: t%lun"
  172. "search_by_key_fs_changed: t%lun"
  173. "search_by_key_restarted: t%lun"
  175. "leaked_oid: t%lun"
  176. "leaves_removable: t%lun",
  178. SF( s_mount_state ) == REISERFS_VALID_FS ?
  179. "REISERFS_VALID_FS" : "REISERFS_ERROR_FS",
  180. reiserfs_r5_hash( sb ) ? "FORCE_R5 " : "",
  181. reiserfs_rupasov_hash( sb ) ? "FORCE_RUPASOV " : "",
  182. reiserfs_tea_hash( sb ) ? "FORCE_TEA " : "",
  183. reiserfs_hash_detect( sb ) ? "DETECT_HASH " : "",
  184. reiserfs_no_border( sb ) ? "NO_BORDER " : "BORDER ",
  185. reiserfs_no_unhashed_relocation( sb ) ? "NO_UNHASHED_RELOCATION " : "",
  186. reiserfs_hashed_relocation( sb ) ? "UNHASHED_RELOCATION " : "",
  187. reiserfs_test4( sb ) ? "TEST4 " : "",
  188. dont_have_tails( sb ) ? "NO_TAILS " : "TAILS ",
  189. replay_only( sb ) ? "REPLAY_ONLY " : "",
  190. reiserfs_dont_log( sb ) ? "DONT_LOG " : "LOG ",
  191. convert_reiserfs( sb ) ? "CONV " : "",
  193. atomic_read( &r -> s_generation_counter ),
  194. SF( s_kmallocs ),
  195. SF( s_disk_reads ),
  196. SF( s_disk_writes ),
  197. SF( s_fix_nodes ),
  198. SF( s_do_balance ),
  199. SF( s_unneeded_left_neighbor ),
  200. SF( s_good_search_by_key_reada ),
  201. SF( s_bmaps ),
  202. SF( s_bmaps_without_search ),
  203. SF( s_direct2indirect ),
  204. SF( s_indirect2direct ),
  205. SFP( max_hash_collisions ),
  206. SFP( breads ),
  207. SFP( bread_miss ),
  208. SFP( search_by_key ),
  209. SFP( search_by_key_fs_changed ),
  210. SFP( search_by_key_restarted ),
  211. SFP( leaked_oid ),
  212. SFP( leaves_removable ) );
  214. procinfo_epilogue( sb );
  215. return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
  216. }
  218. int reiserfs_per_level_in_proc( char *buffer, char **start, off_t offset,
  219. int count, int *eof, void *data )
  220. {
  221. struct super_block *sb;
  222. struct reiserfs_sb_info *r;
  223. int len = 0;
  224. int level;
  226. sb = procinfo_prologue( ( kdev_t ) ( long ) data );
  227. if( sb == NULL )
  228. return -ENOENT;
  229. r = &sb->u.reiserfs_sb;
  231. len += sprintf( &buffer[ len ],
  232. "levelt"
  233. "     balances"
  234. " [sbk:  reads"
  235. "   fs_changed"
  236. "   restarted]"
  237. "   free space"
  238. "        items"
  239. "   can_remove"
  240. "         lnum"
  241. "         rnum"
  242. "       lbytes"
  243. "       rbytes"
  244. "     get_neig"
  245. " get_neig_res"
  246. "  need_l_neig"
  247. "  need_r_neig"
  248. "n"
  250. );
  252. for( level = 0 ; level < MAX_HEIGHT ; ++ level ) {
  253. if( len > PAGE_SIZE - 240 ) {
  254. len += sprintf( &buffer[ len ], "... and moren" );
  255. break;
  256. }
  257. len += sprintf( &buffer[ len ], 
  258. "%it"
  259. " %12lu"
  260. " %12lu"
  261. " %12lu"
  262. " %12lu"
  263. " %12lu"
  264. " %12lu"
  265. " %12lu"
  266. " %12li"
  267. " %12li"
  268. " %12li"
  269. " %12li"
  270. " %12lu"
  271. " %12lu"
  272. " %12lu"
  273. " %12lu"
  274. "n",
  275. level, 
  276. SFPL( balance_at ),
  277. SFPL( sbk_read_at ),
  278. SFPL( sbk_fs_changed ),
  279. SFPL( sbk_restarted ),
  280. SFPL( free_at ),
  281. SFPL( items_at ),
  282. SFPL( can_node_be_removed ),
  283. SFPL( lnum ),
  284. SFPL( rnum ),
  285. SFPL( lbytes ),
  286. SFPL( rbytes ),
  287. SFPL( get_neighbors ),
  288. SFPL( get_neighbors_restart ),
  289. SFPL( need_l_neighbor ),
  290. SFPL( need_r_neighbor )
  291. );
  292. }
  294. procinfo_epilogue( sb );
  295. return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
  296. }
  298. int reiserfs_bitmap_in_proc( char *buffer, char **start, off_t offset,
  299.      int count, int *eof, void *data )
  300. {
  301. struct super_block *sb;
  302. struct reiserfs_sb_info *r = &sb->u.reiserfs_sb;
  303. int len = 0;
  304.     
  305. sb = procinfo_prologue( ( kdev_t ) ( long ) data );
  306. if( sb == NULL )
  307. return -ENOENT;
  308. r = &sb->u.reiserfs_sb;
  310. len += sprintf( &buffer[ len ], "free_block: %lun"
  311. "find_forward:"
  312. "         wait"
  313. "         bmap"
  314. "        retry"
  315. " journal_hint"
  316. "  journal_out"
  317. "n"
  318. " %12lu"
  319. " %12lu"
  320. " %12lu"
  321. " %12lu"
  322. " %12lu"
  323. " %12lu"
  324. "n",
  325. SFP( free_block ),
  326. SFPF( call ), 
  327. SFPF( wait ), 
  328. SFPF( bmap ),
  329. SFPF( retry ),
  330. SFPF( in_journal_hint ),
  331. SFPF( in_journal_out ) );
  333. procinfo_epilogue( sb );
  334. return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
  335. }
  337. int reiserfs_on_disk_super_in_proc( char *buffer, char **start, off_t offset,
  338.     int count, int *eof, void *data )
  339. {
  340. struct super_block *sb;
  341. struct reiserfs_sb_info *sb_info;
  342. struct reiserfs_super_block *rs;
  343. int hash_code;
  344. int len = 0;
  345.     
  346. sb = procinfo_prologue( ( kdev_t ) ( long ) data );
  347. if( sb == NULL )
  348. return -ENOENT;
  349. sb_info = &sb->u.reiserfs_sb;
  350. rs = sb_info -> s_rs;
  351. hash_code = DFL( s_hash_function_code );
  353. len += sprintf( &buffer[ len ], 
  354. "block_count: t%in"
  355. "free_blocks: t%in"
  356. "root_block: t%in"
  357. "blocksize: t%in"
  358. "oid_maxsize: t%in"
  359. "oid_cursize: t%in"
  360. "state: t%in"
  361. "magic: t%12.12sn"
  362. "hash: t%sn"
  363. "tree_height: t%in"
  364. "bmap_nr: t%in"
  365. "version: t%in",
  367. DFL( s_block_count ),
  368. DFL( s_free_blocks ),
  369. DFL( s_root_block ),
  370. DF( s_blocksize ),
  371. DF( s_oid_maxsize ),
  372. DF( s_oid_cursize ),
  373. DF( s_state ),
  374. rs -> s_magic,
  375. hash_code == TEA_HASH ? "tea" :
  376. ( hash_code == YURA_HASH ) ? "rupasov" :
  377. ( hash_code == R5_HASH ) ? "r5" :
  378. ( hash_code == UNSET_HASH ) ? "unset" : "unknown",
  379. DF( s_tree_height ),
  380. DF( s_bmap_nr ),
  381. DF( s_version ) );
  383. procinfo_epilogue( sb );
  384. return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
  385. }
  387. int reiserfs_oidmap_in_proc( char *buffer, char **start, off_t offset,
  388.      int count, int *eof, void *data )
  389. {
  390. struct super_block *sb;
  391. struct reiserfs_sb_info *sb_info;
  392. struct reiserfs_super_block *rs;
  393. int i;
  394. unsigned int mapsize;
  395. unsigned long total_used;
  396. int len = 0;
  397. int exact;
  398.     
  399. sb = procinfo_prologue( ( kdev_t ) ( long ) data );
  400. if( sb == NULL )
  401. return -ENOENT;
  402. sb_info = &sb->u.reiserfs_sb;
  403. rs = sb_info -> s_rs;
  404. mapsize = le16_to_cpu( rs -> s_oid_cursize );
  405. total_used = 0;
  407. for( i = 0 ; i < mapsize ; ++i ) {
  408. __u32 right;
  410. right = ( i == mapsize - 1 ) ? MAX_KEY_OBJECTID : MAP( i + 1 );
  411. len += sprintf( &buffer[ len ], "%s: [ %x .. %x )n",
  412. ( i & 1 ) ? "free" : "used", MAP( i ), right );
  413. if( ! ( i & 1 ) ) {
  414. total_used += right - MAP( i );
  415. }
  416. if( len > PAGE_SIZE - 100 ) {
  417. len += sprintf( &buffer[ len ], "... and moren" );
  418. break;
  419. }
  420. }
  421. #if defined( REISERFS_USE_OIDMAPF )
  422. if( sb_info -> oidmap.use_file && ( sb_info -> oidmap.mapf != NULL ) ) {
  423. loff_t size;
  425. size = sb_info -> oidmap.mapf -> f_dentry -> d_inode -> i_size;
  426. total_used += size / sizeof( reiserfs_oidinterval_d_t );
  427. exact = 1;
  428. } else
  429. #endif
  430. {
  431. exact = ( i == mapsize );
  432. }
  433. len += sprintf( &buffer[ len ], "total: t%i [%i/%i] used: %lu [%s]n", 
  434. i, 
  435. mapsize, le16_to_cpu( rs -> s_oid_maxsize ),
  436. total_used, exact ? "exact" : "estimation" );
  438. procinfo_epilogue( sb );
  439. return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
  440. }
  442. int reiserfs_journal_in_proc( char *buffer, char **start, off_t offset,
  443.       int count, int *eof, void *data )
  444. {
  445. struct super_block *sb;
  446. struct reiserfs_sb_info *r;
  447. struct reiserfs_super_block *rs;
  448. int len = 0;
  449.     
  450. sb = procinfo_prologue( ( kdev_t ) ( long ) data );
  451. if( sb == NULL )
  452. return -ENOENT;
  453. r = &sb->u.reiserfs_sb;
  454. rs = r -> s_rs;
  456. len += sprintf( &buffer[ len ], 
  457. /* on-disk fields */
  458. "s_journal_block: t%in"
  459. "s_journal_dev: t%s[%x]n"
  460. "s_orig_journal_size: t%in"
  461. "s_journal_trans_max: t%in"
  462. "s_journal_block_count: t%in"
  463. "s_journal_max_batch: t%in"
  464. "s_journal_max_commit_age: t%in"
  465. "s_journal_max_trans_age: t%in"
  466. /* incore fields */
  467. "j_state: t%lin"
  468. "j_trans_id: t%lun"
  469. "j_mount_id: t%lun"
  470. "j_start: t%lun"
  471. "j_len: t%lun"
  472. "j_len_alloc: t%lun"
  473. "j_wcount: t%in"
  474. "j_bcount: t%lun"
  475. "j_first_unflushed_offset: t%lun"
  476. "j_last_flush_trans_id: t%lun"
  477. "j_trans_start_time: t%lin"
  478. "j_journal_list_index: t%in"
  479. "j_list_bitmap_index: t%in"
  480. "j_must_wait: t%in"
  481. "j_next_full_flush: t%in"
  482. "j_next_async_flush: t%in"
  483. "j_cnode_used: t%in"
  484. "j_cnode_free: t%in"
  485. "n"
  486. /* reiserfs_proc_info_data_t.journal fields */
  487. "in_journal: t%12lun"
  488. "in_journal_bitmap: t%12lun"
  489. "in_journal_reusable: t%12lun"
  490. "lock_journal: t%12lun"
  491. "lock_journal_wait: t%12lun"
  492. "journal_begin: t%12lun"
  493. "journal_relock_writers: t%12lun"
  494. "journal_relock_wcount: t%12lun"
  495. "mark_dirty: t%12lun"
  496. "mark_dirty_already: t%12lun"
  497. "mark_dirty_notjournal: t%12lun"
  498. "restore_prepared: t%12lun"
  499. "prepare: t%12lun"
  500. "prepare_retry: t%12lun",
  502. DJF( s_journal_block ),
  503. DJF( s_journal_dev ) == 0 ? "none" : bdevname( DJF( s_journal_dev ) ), 
  504. DJF( s_journal_dev ),
  505. DJF( s_orig_journal_size ),
  506. DJF( s_journal_trans_max ),
  507. DJF( s_journal_block_count ),
  508. DJF( s_journal_max_batch ),
  509. DJF( s_journal_max_commit_age ),
  510. DJF( s_journal_max_trans_age ),
  512. JF( j_state ),
  513. JF( j_trans_id ),
  514. JF( j_mount_id ),
  515. JF( j_start ),
  516. JF( j_len ),
  517. JF( j_len_alloc ),
  518. atomic_read( & r -> s_journal -> j_wcount ),
  519. JF( j_bcount ),
  520. JF( j_first_unflushed_offset ),
  521. JF( j_last_flush_trans_id ),
  522. JF( j_trans_start_time ),
  523. JF( j_journal_list_index ),
  524. JF( j_list_bitmap_index ),
  525. JF( j_must_wait ),
  526. JF( j_next_full_flush ),
  527. JF( j_next_async_flush ),
  528. JF( j_cnode_used ),
  529. JF( j_cnode_free ),
  531. SFPJ( in_journal ),
  532. SFPJ( in_journal_bitmap ),
  533. SFPJ( in_journal_reusable ),
  534. SFPJ( lock_journal ),
  535. SFPJ( lock_journal_wait ),
  536. SFPJ( journal_being ),
  537. SFPJ( journal_relock_writers ),
  538. SFPJ( journal_relock_wcount ),
  539. SFPJ( mark_dirty ),
  540. SFPJ( mark_dirty_already ),
  541. SFPJ( mark_dirty_notjournal ),
  542. SFPJ( restore_prepared ),
  543. SFPJ( prepare ),
  544. SFPJ( prepare_retry )
  545. );
  547. procinfo_epilogue( sb );
  548. return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
  549. }
  552. static struct proc_dir_entry *proc_info_root = NULL;
  553. static const char *proc_info_root_name = "fs/reiserfs";
  555. int reiserfs_proc_info_init( struct super_block *sb )
  556. {
  557. spin_lock_init( & __PINFO( sb ).lock );
  558. sb->u.reiserfs_sb.procdir = proc_mkdir( bdevname( sb -> s_dev ), 
  559. proc_info_root );
  560. if( sb->u.reiserfs_sb.procdir ) {
  561. sb->u.reiserfs_sb.procdir -> owner = THIS_MODULE;
  562. return 0;
  563. }
  564. reiserfs_warning( "reiserfs: cannot create /proc/%s/%sn",
  565.   proc_info_root_name, bdevname( sb -> s_dev ) );
  566. return 1;
  567. }
  570. int reiserfs_proc_info_done( struct super_block *sb )
  571. {
  572. spin_lock( & __PINFO( sb ).lock );
  573. __PINFO( sb ).exiting = 1;
  574. spin_unlock( & __PINFO( sb ).lock );
  575. if ( proc_info_root ) {
  576. remove_proc_entry( bdevname( sb -> s_dev ), proc_info_root );
  577. sb->u.reiserfs_sb.procdir = NULL;
  578. }
  579. return 0;
  580. }
  582. /* Create /proc/fs/reiserfs/DEV/name and attach read procedure @func
  583.    to it.  Other parts of reiserfs use this function to make their
  584.    per-device statistics available via /proc */
  586. struct proc_dir_entry *reiserfs_proc_register( struct super_block *sb, 
  587.        char *name, read_proc_t *func )
  588. {
  589. return ( sb->u.reiserfs_sb.procdir ) ? create_proc_read_entry
  590. ( name, 0, sb->u.reiserfs_sb.procdir, func, 
  591.   ( void * ) ( long ) sb -> s_dev ) : NULL;
  592. }
  594. void reiserfs_proc_unregister( struct super_block *sb, const char *name )
  595. {
  596. remove_proc_entry( name, sb->u.reiserfs_sb.procdir );
  597. }
  599. struct proc_dir_entry *reiserfs_proc_register_global( char *name, 
  600.       read_proc_t *func )
  601. {
  602. return ( proc_info_root ) ? create_proc_read_entry( name, 0, 
  603.     proc_info_root, 
  604.     func, NULL ) : NULL;
  605. }
  607. void reiserfs_proc_unregister_global( const char *name )
  608. {
  609. remove_proc_entry( name, proc_info_root );
  610. }
  612. int reiserfs_proc_info_global_init( void )
  613. {
  614. if( proc_info_root == NULL ) {
  615. proc_info_root = proc_mkdir( proc_info_root_name, 0 );
  616. if( proc_info_root ) {
  617. proc_info_root -> owner = THIS_MODULE;
  618. } else {
  619. reiserfs_warning( "reiserfs: cannot create /proc/%sn",
  620.   proc_info_root_name );
  621. return 1;
  622. }
  623. }
  624. return 0;
  625. }
  627. int reiserfs_proc_info_global_done( void )
  628. {
  629. if ( proc_info_root != NULL ) {
  630. proc_info_root = NULL;
  631. remove_proc_entry( proc_info_root_name, 0 );
  632. }
  633. return 0;
  634. }
  636. /* REISERFS_PROC_INFO */
  637. #else
  639. int reiserfs_proc_info_init( struct super_block *sb ) { return 0; }
  640. int reiserfs_proc_info_done( struct super_block *sb ) { return 0; }
  642. struct proc_dir_entry *reiserfs_proc_register( struct super_block *sb, 
  643.        char *name, 
  644.        read_proc_t *func ) 
  645. { return NULL; }
  647. void reiserfs_proc_unregister( struct super_block *sb, const char *name ) 
  648. {;}
  650. struct proc_dir_entry *reiserfs_proc_register_global( char *name, 
  651.       read_proc_t *func )
  652. { return NULL; }
  654. void reiserfs_proc_unregister_global( const char *name ) {;}
  656. int reiserfs_proc_info_global_init( void ) { return 0; }
  657. int reiserfs_proc_info_global_done( void ) { return 0; }
  659. int reiserfs_global_version_in_proc( char *buffer, char **start, 
  660.      off_t offset,
  661.      int count, int *eof, void *data )
  662. { return 0; }
  664. int reiserfs_version_in_proc( char *buffer, char **start, off_t offset,
  665.       int count, int *eof, void *data )
  666. { return 0; }
  668. int reiserfs_super_in_proc( char *buffer, char **start, off_t offset,
  669.     int count, int *eof, void *data )
  670. { return 0; }
  672. int reiserfs_per_level_in_proc( char *buffer, char **start, off_t offset,
  673. int count, int *eof, void *data )
  674. { return 0; }
  676. int reiserfs_bitmap_in_proc( char *buffer, char **start, off_t offset,
  677.      int count, int *eof, void *data )
  678. { return 0; }
  680. int reiserfs_on_disk_super_in_proc( char *buffer, char **start, off_t offset,
  681.     int count, int *eof, void *data )
  682. { return 0; }
  684. int reiserfs_oidmap_in_proc( char *buffer, char **start, off_t offset,
  685.      int count, int *eof, void *data )
  686. { return 0; }
  688. int reiserfs_journal_in_proc( char *buffer, char **start, off_t offset,
  689.       int count, int *eof, void *data )
  690. { return 0; }
  692. /* REISERFS_PROC_INFO */
  693. #endif
  695. /*
  696.  * $Log: procfs.c,v $
  697.  * Revision 1.1.8.2  2001/07/15 17:08:42  god
  698.  *  . use get_super() in procfs.c
  699.  *  . remove remove_save_link() from reiserfs_do_truncate()
  700.  *
  701.  * I accept terms and conditions stated in the Legal Agreement
  702.  * (available at http://www.namesys.com/legalese.html)
  703.  *
  704.  * Revision 1.1.8.1  2001/07/11 16:48:50  god
  705.  * proc info support
  706.  *
  707.  * I accept terms and conditions stated in the Legal Agreement
  708.  * (available at http://www.namesys.com/legalese.html)
  709.  *
  710.  */
  712. /* 
  713.  * Make Linus happy.
  714.  * Local variables:
  715.  * c-indentation-style: "K&R"
  716.  * mode-name: "LC"
  717.  * c-basic-offset: 8
  718.  * tab-width: 8
  719.  * End:
  720.  */