/core/10.5/fusefs/fuse_sysctl.c

http://macfuse.googlecode.com/ · C · 308 lines · 253 code · 41 blank · 14 comment · 30 complexity · ac2e17a9af13284f272aca12ee9586e1 MD5 · raw file 

    

  1. /*
    2. 

  2.  * Copyright (C) 2006-2008 Google. All Rights Reserved.
    3. 

  3.  * Amit Singh <singh@>
    4. 

  4.  */
    5. 

  5. 

  6. #include <sys/systm.h>
    7. 

  7. #include <sys/types.h>
    8. 

  8. #include <sys/sysctl.h>
    9. 

  9. 

  10. #include "fuse.h"
    11. 

  11. #include "fuse_device.h"
    12. 

  12. #include "fuse_sysctl.h"
    13. 

  13. #include <fuse_param.h>
    14. 

  14. #include <fuse_version.h>
    15. 

  15. 

  16. /* NB: none of these are bigger than unsigned 32-bit. */
    17. 

  17. 

  18. int32_t  fuse_admin_group            = 0;                                  // rw
    19. 

  19. int32_t  fuse_allow_other            = 0;                                  // rw
    20. 

  20. uint32_t fuse_api_major              = FUSE_KERNEL_VERSION;                // r
    21. 

  21. uint32_t fuse_api_minor              = FUSE_KERNEL_MINOR_VERSION;          // r
    22. 

  22. int32_t  fuse_fh_current             = 0;                                  // r
    23. 

  23. uint32_t fuse_fh_reuse_count         = 0;                                  // r
    24. 

  24. uint32_t fuse_fh_upcall_count        = 0;                                  // r
    25. 

  25. uint32_t fuse_fh_zombies             = 0;                                  // r
    26. 

  26. int32_t  fuse_iov_credit             = FUSE_DEFAULT_IOV_CREDIT;            // rw
    27. 

  27. int32_t  fuse_iov_current            = 0;                                  // r
    28. 

  28. uint32_t fuse_iov_permanent_bufsize  = FUSE_DEFAULT_IOV_PERMANENT_BUFSIZE; // rw
    29. 

  29. int32_t  fuse_kill                   = -1;                                 // w
    30. 

  30. int32_t  fuse_print_vnodes           = -1;                                 // w
    31. 

  31. uint32_t fuse_lookup_cache_hits      = 0;                                  // r
    32. 

  32. uint32_t fuse_lookup_cache_misses    = 0;                                  // r
    33. 

  33. uint32_t fuse_lookup_cache_overrides = 0;                                  // r
    34. 

  34. uint32_t fuse_max_freetickets        = FUSE_DEFAULT_MAX_FREE_TICKETS;      // rw
    35. 

  35. uint32_t fuse_max_tickets            = 0;                                  // rw
    36. 

  36. int32_t  fuse_mount_count            = 0;                                  // r
    37. 

  37. int32_t  fuse_memory_allocated       = 0;                                  // r
    38. 

  38. int32_t  fuse_realloc_count          = 0;                                  // r
    39. 

  39. int32_t  fuse_tickets_current        = 0;                                  // r
    40. 

  40. uint32_t fuse_userkernel_bufsize     = FUSE_DEFAULT_USERKERNEL_BUFSIZE;    // rw
    41. 

  41. int32_t  fuse_vnodes_current         = 0;                                  // r
    42. 

  42. 

  43. SYSCTL_DECL(_macfuse);
    44. 

  44. SYSCTL_NODE(, OID_AUTO, macfuse, CTLFLAG_RW, 0,
    45. 

  45.             "MacFUSE Sysctl Interface");
    46. 

  46. SYSCTL_NODE(_macfuse, OID_AUTO, control, CTLFLAG_RW, 0,
    47. 

  47.             "MacFUSE Controls");
    48. 

  48. SYSCTL_NODE(_macfuse, OID_AUTO, counters, CTLFLAG_RW, 0,
    49. 

  49.             "MacFUSE Monotonic Counters");
    50. 

  50. SYSCTL_NODE(_macfuse, OID_AUTO, resourceusage, CTLFLAG_RW, 0,
    51. 

  51.             "MacFUSE Resource Usage");
    52. 

  52. SYSCTL_NODE(_macfuse, OID_AUTO, tunables, CTLFLAG_RW, 0,
    53. 

  53.             "MacFUSE Tunables");
    54. 

  54. SYSCTL_NODE(_macfuse, OID_AUTO, version, CTLFLAG_RW, 0,
    55. 

  55.             "MacFUSE Version Information");
    56. 

  56. 

  57. /* fuse.control */
    58. 

  58. 

  59. int sysctl_macfuse_control_kill_handler SYSCTL_HANDLER_ARGS;
    60. 

  60. int sysctl_macfuse_control_print_vnodes_handler SYSCTL_HANDLER_ARGS;
    61. 

  61. int sysctl_macfuse_tunables_userkernel_bufsize_handler SYSCTL_HANDLER_ARGS;
    62. 

  62. 

  63. int
    64. 

  64. sysctl_macfuse_control_kill_handler SYSCTL_HANDLER_ARGS
    65. 

  65. {
    66. 

  66.     int error = 0;
    67. 

  67.     (void)oidp;
    68. 

  68. 

  69.     if (arg1) {
    70. 

  70.         error = SYSCTL_OUT(req, arg1, sizeof(int));
    71. 

  71.     } else {
    72. 

  72.         error = SYSCTL_OUT(req, &arg2, sizeof(int));
    73. 

  73.     }
    74. 

  74. 

  75.     if (error || !req->newptr) {
    76. 

  76.         return error;
    77. 

  77.     }
    78. 

  78. 

  79.     if (!arg1) {
    80. 

  80.         error = EPERM;
    81. 

  81.     } else {
    82. 

  82.         error = SYSCTL_IN(req, arg1, sizeof(int));
    83. 

  83.         if (error == 0) {
    84. 

  84.             error = fuse_device_kill(*(int *)arg1, req->p);
    85. 

  85.         }
    86. 

  86.         fuse_kill = -1; /* set it back */
    87. 

  87.     }
    88. 

  88. 

  89.     return error;
    90. 

  90. }
    91. 

  91. 

  92. int
    93. 

  93. sysctl_macfuse_control_print_vnodes_handler SYSCTL_HANDLER_ARGS
    94. 

  94. {
    95. 

  95.     int error = 0;
    96. 

  96.     (void)oidp;
    97. 

  97. 

  98.     if (arg1) {
    99. 

  99.         error = SYSCTL_OUT(req, arg1, sizeof(uint32_t));
    100. 

  100.     } else {
    101. 

  101.         error = SYSCTL_OUT(req, &arg2, sizeof(uint32_t));
    102. 

  102.     }
    103. 

  103. 

  104.     if (error || !req->newptr) {
    105. 

  105.         return error;
    106. 

  106.     }
    107. 

  107. 

  108.     if (!arg1) {
    109. 

  109.         error = EPERM;
    110. 

  110.     } else {
    111. 

  111.         error = SYSCTL_IN(req, arg1, sizeof(int));
    112. 

  112.         if (error == 0) {
    113. 

  113.             error = fuse_device_print_vnodes(*(int *)arg1, req->p);
    114. 

  114.         }
    115. 

  115.         fuse_print_vnodes = -1; /* set it back */
    116. 

  116.     }
    117. 

  117. 

  118.     return error;
    119. 

  119. }
    120. 

  120. 

  121. int
    122. 

  122. sysctl_macfuse_tunables_userkernel_bufsize_handler SYSCTL_HANDLER_ARGS
    123. 

  123. {
    124. 

  124.     int error = 0;
    125. 

  125.     (void)oidp;
    126. 

  126. 

  127.     if (arg1) {
    128. 

  128.         error = SYSCTL_OUT(req, arg1, sizeof(int));
    129. 

  129.     } else {
    130. 

  130.         error = SYSCTL_OUT(req, &arg2, sizeof(int));
    131. 

  131.     }
    132. 

  132. 

  133.     if (error || !req->newptr) {
    134. 

  134.         return error;
    135. 

  135.     }
    136. 

  136. 

  137.     if (!arg1) {
    138. 

  138.         error = EPERM;
    139. 

  139.     } else {
    140. 

  140.         error = SYSCTL_IN(req, arg1, sizeof(uint32_t));
    141. 

  141.         if (error == 0) {
    142. 

  142.             uint32_t incoming = *(uint32_t *)arg1;
    143. 

  143.             incoming = fuse_round_page_32(incoming);
    144. 

  144.             if (incoming > FUSE_MAX_USERKERNEL_BUFSIZE) {
    145. 

  145.                 error = E2BIG;
    146. 

  146.             } else if (incoming < FUSE_MIN_USERKERNEL_BUFSIZE) {
    147. 

  147.                 error = EINVAL;
    148. 

  148.             } else {
    149. 

  149.                 fuse_userkernel_bufsize = incoming;
    150. 

  150.             }
    151. 

  151.         }
    152. 

  152.     }
    153. 

  153. 

  154.     return error;
    155. 

  155. }
    156. 

  156. 

  157. SYSCTL_PROC(_macfuse_control, // our parent
    158. 

  158.             OID_AUTO,         // automatically assign object ID
    159. 

  159.             kill,             // our name
    160. 

  160. 

  161.             // type flag/access flag
    162. 

  162.             (CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_ANYBODY),
    163. 

  163. 

  164.             &fuse_kill,       // location of our data
    165. 

  165.             0,                // argument passed to our handler
    166. 

  166. 

  167.             // our handler function
    168. 

  168.             sysctl_macfuse_control_kill_handler,
    169. 

  169. 

  170.             "I",              // our data type (integer)
    171. 

  171.             "MacFUSE Controls: Kill the Given File System");
    172. 

  172. 

  173. SYSCTL_PROC(_macfuse_control,   // our parent
    174. 

  174.             OID_AUTO,           // automatically assign object ID
    175. 

  175.             print_vnodes,       // our name
    176. 

  176. 

  177.             // type flag/access flag
    178. 

  178.             (CTLTYPE_INT | CTLFLAG_WR),
    179. 

  179. 

  180.             &fuse_print_vnodes, // location of our data
    181. 

  181.             0,                  // argument passed to our handler
    182. 

  182. 

  183.             // our handler function
    184. 

  184.             sysctl_macfuse_control_print_vnodes_handler,
    185. 

  185. 

  186.             "I",                // our data type (integer)
    187. 

  187.             "MacFUSE Controls: Print Vnodes for the Given File System");
    188. 

  188. 

  189. /* fuse.counters */
    190. 

  190. SYSCTL_INT(_macfuse_counters, OID_AUTO, filehandle_reuse, CTLFLAG_RD,
    191. 

  191.            &fuse_fh_reuse_count, 0, "");
    192. 

  192. SYSCTL_INT(_macfuse_counters, OID_AUTO, filehandle_upcalls, CTLFLAG_RD,
    193. 

  193.            &fuse_fh_upcall_count, 0, "");
    194. 

  194. SYSCTL_INT(_macfuse_counters, OID_AUTO, lookup_cache_hits, CTLFLAG_RD,
    195. 

  195.            &fuse_lookup_cache_hits, 0, "");
    196. 

  196. SYSCTL_INT(_macfuse_counters, OID_AUTO, lookup_cache_misses, CTLFLAG_RD,
    197. 

  197.            &fuse_lookup_cache_misses, 0, "");
    198. 

  198. SYSCTL_INT(_macfuse_counters, OID_AUTO, lookup_cache_overrides,
    199. 

  199.            CTLFLAG_RD, &fuse_lookup_cache_overrides, 0, "");
    200. 

  200. SYSCTL_INT(_macfuse_counters, OID_AUTO, memory_reallocs, CTLFLAG_RD,
    201. 

  201.            &fuse_realloc_count, 0, "");
    202. 

  202. 

  203. /* fuse.resourceusage */
    204. 

  204. SYSCTL_INT(_macfuse_resourceusage, OID_AUTO, filehandles, CTLFLAG_RD,
    205. 

  205.            &fuse_fh_current, 0, "");
    206. 

  206. SYSCTL_INT(_macfuse_resourceusage, OID_AUTO, filehandles_zombies, CTLFLAG_RD,
    207. 

  207.            &fuse_fh_zombies, 0, "");
    208. 

  208. SYSCTL_INT(_macfuse_resourceusage, OID_AUTO, ipc_iovs, CTLFLAG_RD,
    209. 

  209.            &fuse_iov_current, 0, "");
    210. 

  210. SYSCTL_INT(_macfuse_resourceusage, OID_AUTO, ipc_tickets, CTLFLAG_RD,
    211. 

  211.            &fuse_tickets_current, 0, "");
    212. 

  212. SYSCTL_INT(_macfuse_resourceusage, OID_AUTO, memory_bytes, CTLFLAG_RD,
    213. 

  213.            &fuse_memory_allocated, 0, "");
    214. 

  214. SYSCTL_INT(_macfuse_resourceusage, OID_AUTO, mounts, CTLFLAG_RD,
    215. 

  215.            &fuse_mount_count, 0, "");
    216. 

  216. SYSCTL_INT(_macfuse_resourceusage, OID_AUTO, vnodes, CTLFLAG_RD,
    217. 

  217.            &fuse_vnodes_current, 0, "");
    218. 

  218. 

  219. /* fuse.tunables */
    220. 

  220. SYSCTL_INT(_macfuse_tunables, OID_AUTO, admin_group, CTLFLAG_RW,
    221. 

  221.            &fuse_admin_group, 0, "");
    222. 

  222. SYSCTL_INT(_macfuse_tunables, OID_AUTO, allow_other, CTLFLAG_RW,
    223. 

  223.            &fuse_allow_other, 0, "");
    224. 

  224. SYSCTL_INT(_macfuse_tunables, OID_AUTO, iov_credit, CTLFLAG_RW,
    225. 

  225.            &fuse_iov_credit, 0, "");
    226. 

  226. SYSCTL_INT(_macfuse_tunables, OID_AUTO, iov_permanent_bufsize, CTLFLAG_RW,
    227. 

  227.            &fuse_iov_permanent_bufsize, 0, "");
    228. 

  228. SYSCTL_INT(_macfuse_tunables, OID_AUTO, max_freetickets, CTLFLAG_RW,
    229. 

  229.            &fuse_max_freetickets, 0, "");
    230. 

  230. SYSCTL_INT(_macfuse_tunables, OID_AUTO, max_tickets, CTLFLAG_RW,
    231. 

  231.            &fuse_max_tickets, 0, "");
    232. 

  232. SYSCTL_PROC(_macfuse_tunables,          // our parent
    233. 

  233.             OID_AUTO,                   // automatically assign object ID
    234. 

  234.             userkernel_bufsize,         // our name
    235. 

  235.             (CTLTYPE_INT | CTLFLAG_WR), // type flag/access flag
    236. 

  236.             &fuse_userkernel_bufsize,   // location of our data
    237. 

  237.             0,                          // argument passed to our handler
    238. 

  238.             sysctl_macfuse_tunables_userkernel_bufsize_handler,    
    239. 

  239.             "I",                        // our data type (integer)
    240. 

  240.             "MacFUSE Tunables");        // our description
    241. 

  241. 

  242. /* fuse.version */
    243. 

  243. SYSCTL_INT(_macfuse_version, OID_AUTO, api_major, CTLFLAG_RD,
    244. 

  244.            &fuse_api_major, 0, "");
    245. 

  245. SYSCTL_INT(_macfuse_version, OID_AUTO, api_minor, CTLFLAG_RD,
    246. 

  246.            &fuse_api_minor, 0, "");
    247. 

  247. SYSCTL_STRING(_macfuse_version, OID_AUTO, number, CTLFLAG_RD,
    248. 

  248.               MACFUSE_VERSION, 0, "");
    249. 

  249. SYSCTL_STRING(_macfuse_version, OID_AUTO, string, CTLFLAG_RD,
    250. 

  250.               MACFUSE_VERSION ", " MACFUSE_TIMESTAMP, 0, "");
    251. 

  251. 

  252. static struct sysctl_oid *fuse_sysctl_list[] =
    253. 

  253. {
    254. 

  254.     &sysctl__macfuse_control,
    255. 

  255.     &sysctl__macfuse_counters,
    256. 

  256.     &sysctl__macfuse_resourceusage,
    257. 

  257.     &sysctl__macfuse_tunables,
    258. 

  258.     &sysctl__macfuse_version,
    259. 

  259.     &sysctl__macfuse_control_kill,
    260. 

  260.     &sysctl__macfuse_control_print_vnodes,
    261. 

  261.     &sysctl__macfuse_counters_filehandle_reuse,
    262. 

  262.     &sysctl__macfuse_counters_filehandle_upcalls,
    263. 

  263.     &sysctl__macfuse_counters_lookup_cache_hits,
    264. 

  264.     &sysctl__macfuse_counters_lookup_cache_misses,
    265. 

  265.     &sysctl__macfuse_counters_lookup_cache_overrides,
    266. 

  266.     &sysctl__macfuse_counters_memory_reallocs,
    267. 

  267.     &sysctl__macfuse_resourceusage_filehandles,
    268. 

  268.     &sysctl__macfuse_resourceusage_filehandles_zombies,
    269. 

  269.     &sysctl__macfuse_resourceusage_ipc_iovs,
    270. 

  270.     &sysctl__macfuse_resourceusage_ipc_tickets,
    271. 

  271.     &sysctl__macfuse_resourceusage_memory_bytes,
    272. 

  272.     &sysctl__macfuse_resourceusage_mounts,
    273. 

  273.     &sysctl__macfuse_resourceusage_vnodes,
    274. 

  274.     &sysctl__macfuse_tunables_admin_group,
    275. 

  275.     &sysctl__macfuse_tunables_allow_other,
    276. 

  276.     &sysctl__macfuse_tunables_iov_credit,
    277. 

  277.     &sysctl__macfuse_tunables_iov_permanent_bufsize,
    278. 

  278.     &sysctl__macfuse_tunables_max_freetickets,
    279. 

  279.     &sysctl__macfuse_tunables_max_tickets,
    280. 

  280.     &sysctl__macfuse_tunables_userkernel_bufsize,
    281. 

  281.     &sysctl__macfuse_version_api_major,
    282. 

  282.     &sysctl__macfuse_version_api_minor,
    283. 

  283.     &sysctl__macfuse_version_number,
    284. 

  284.     &sysctl__macfuse_version_string,
    285. 

  285.     (struct sysctl_oid *)0
    286. 

  286. };
    287. 

  287. 

  288. void
    289. 

  289. fuse_sysctl_start(void)
    290. 

  290. {
    291. 

  291.     int i;
    292. 

  292. 

  293.     sysctl_register_oid(&sysctl__macfuse);
    294. 

  294.     for (i = 0; fuse_sysctl_list[i]; i++) {
    295. 

  295.        sysctl_register_oid(fuse_sysctl_list[i]);
    296. 

  296.     }
    297. 

  297. }
    298. 

  298. 

  299. void
    300. 

  300. fuse_sysctl_stop(void)
    301. 

  301. {
    302. 

  302.     int i;
    303. 

  303. 

  304.     for (i = 0; fuse_sysctl_list[i]; i++) {
    305. 

  305.        sysctl_unregister_oid(fuse_sysctl_list[i]);
    306. 

  306.     }
    307. 

  307.     sysctl_unregister_oid(&sysctl__macfuse);
    308. 

  308. }
    309.