/include/linux/cleancache.h

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t · C Header · 122 lines · 87 code · 16 blank · 19 comment · 11 complexity · 113beeacd8fef11307e9bcda16f78c6e MD5 · raw file 

    

  1. #ifndef _LINUX_CLEANCACHE_H
    2. 

  2. #define _LINUX_CLEANCACHE_H
    3. 

  3. 

  4. #include <linux/fs.h>
    5. 

  5. #include <linux/exportfs.h>
    6. 

  6. #include <linux/mm.h>
    7. 

  7. 

  8. #define CLEANCACHE_KEY_MAX 6
    9. 

  9. 

  10. /*
    11. 

  11.  * cleancache requires every file with a page in cleancache to have a
    12. 

  12.  * unique key unless/until the file is removed/truncated.  For some
    13. 

  13.  * filesystems, the inode number is unique, but for "modern" filesystems
    14. 

  14.  * an exportable filehandle is required (see exportfs.h)
    15. 

  15.  */
    16. 

  16. struct cleancache_filekey {
    17. 

  17. 	union {
    18. 

  18. 		ino_t ino;
    19. 

  19. 		__u32 fh[CLEANCACHE_KEY_MAX];
    20. 

  20. 		u32 key[CLEANCACHE_KEY_MAX];
    21. 

  21. 	} u;
    22. 

  22. };
    23. 

  23. 

  24. struct cleancache_ops {
    25. 

  25. 	int (*init_fs)(size_t);
    26. 

  26. 	int (*init_shared_fs)(char *uuid, size_t);
    27. 

  27. 	int (*get_page)(int, struct cleancache_filekey,
    28. 

  28. 			pgoff_t, struct page *);
    29. 

  29. 	void (*put_page)(int, struct cleancache_filekey,
    30. 

  30. 			pgoff_t, struct page *);
    31. 

  31. 	void (*flush_page)(int, struct cleancache_filekey, pgoff_t);
    32. 

  32. 	void (*flush_inode)(int, struct cleancache_filekey);
    33. 

  33. 	void (*flush_fs)(int);
    34. 

  34. };
    35. 

  35. 

  36. extern struct cleancache_ops
    37. 

  37. 	cleancache_register_ops(struct cleancache_ops *ops);
    38. 

  38. extern void __cleancache_init_fs(struct super_block *);
    39. 

  39. extern void __cleancache_init_shared_fs(char *, struct super_block *);
    40. 

  40. extern int  __cleancache_get_page(struct page *);
    41. 

  41. extern void __cleancache_put_page(struct page *);
    42. 

  42. extern void __cleancache_flush_page(struct address_space *, struct page *);
    43. 

  43. extern void __cleancache_flush_inode(struct address_space *);
    44. 

  44. extern void __cleancache_flush_fs(struct super_block *);
    45. 

  45. extern int cleancache_enabled;
    46. 

  46. 

  47. #ifdef CONFIG_CLEANCACHE
    48. 

  48. static inline bool cleancache_fs_enabled(struct page *page)
    49. 

  49. {
    50. 

  50. 	return page->mapping->host->i_sb->cleancache_poolid >= 0;
    51. 

  51. }
    52. 

  52. static inline bool cleancache_fs_enabled_mapping(struct address_space *mapping)
    53. 

  53. {
    54. 

  54. 	return mapping->host->i_sb->cleancache_poolid >= 0;
    55. 

  55. }
    56. 

  56. #else
    57. 

  57. #define cleancache_enabled (0)
    58. 

  58. #define cleancache_fs_enabled(_page) (0)
    59. 

  59. #define cleancache_fs_enabled_mapping(_page) (0)
    60. 

  60. #endif
    61. 

  61. 

  62. /*
    63. 

  63.  * The shim layer provided by these inline functions allows the compiler
    64. 

  64.  * to reduce all cleancache hooks to nothingness if CONFIG_CLEANCACHE
    65. 

  65.  * is disabled, to a single global variable check if CONFIG_CLEANCACHE
    66. 

  66.  * is enabled but no cleancache "backend" has dynamically enabled it,
    67. 

  67.  * and, for the most frequent cleancache ops, to a single global variable
    68. 

  68.  * check plus a superblock element comparison if CONFIG_CLEANCACHE is enabled
    69. 

  69.  * and a cleancache backend has dynamically enabled cleancache, but the
    70. 

  70.  * filesystem referenced by that cleancache op has not enabled cleancache.
    71. 

  71.  * As a result, CONFIG_CLEANCACHE can be enabled by default with essentially
    72. 

  72.  * no measurable performance impact.
    73. 

  73.  */
    74. 

  74. 

  75. static inline void cleancache_init_fs(struct super_block *sb)
    76. 

  76. {
    77. 

  77. 	if (cleancache_enabled)
    78. 

  78. 		__cleancache_init_fs(sb);
    79. 

  79. }
    80. 

  80. 

  81. static inline void cleancache_init_shared_fs(char *uuid, struct super_block *sb)
    82. 

  82. {
    83. 

  83. 	if (cleancache_enabled)
    84. 

  84. 		__cleancache_init_shared_fs(uuid, sb);
    85. 

  85. }
    86. 

  86. 

  87. static inline int cleancache_get_page(struct page *page)
    88. 

  88. {
    89. 

  89. 	int ret = -1;
    90. 

  90. 

  91. 	if (cleancache_enabled && cleancache_fs_enabled(page))
    92. 

  92. 		ret = __cleancache_get_page(page);
    93. 

  93. 	return ret;
    94. 

  94. }
    95. 

  95. 

  96. static inline void cleancache_put_page(struct page *page)
    97. 

  97. {
    98. 

  98. 	if (cleancache_enabled && cleancache_fs_enabled(page))
    99. 

  99. 		__cleancache_put_page(page);
    100. 

  100. }
    101. 

  101. 

  102. static inline void cleancache_flush_page(struct address_space *mapping,
    103. 

  103. 					struct page *page)
    104. 

  104. {
    105. 

  105. 	/* careful... page->mapping is NULL sometimes when this is called */
    106. 

  106. 	if (cleancache_enabled && cleancache_fs_enabled_mapping(mapping))
    107. 

  107. 		__cleancache_flush_page(mapping, page);
    108. 

  108. }
    109. 

  109. 

  110. static inline void cleancache_flush_inode(struct address_space *mapping)
    111. 

  111. {
    112. 

  112. 	if (cleancache_enabled && cleancache_fs_enabled_mapping(mapping))
    113. 

  113. 		__cleancache_flush_inode(mapping);
    114. 

  114. }
    115. 

  115. 

  116. static inline void cleancache_flush_fs(struct super_block *sb)
    117. 

  117. {
    118. 

  118. 	if (cleancache_enabled)
    119. 

  119. 		__cleancache_flush_fs(sb);
    120. 

  120. }
    121. 

  121. 

  122. #endif /* _LINUX_CLEANCACHE_H */
    123.