debug_fs.c 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387
  1. /******************************************************************************
  2. *******************************************************************************
  3. **
  4. ** Copyright (C) 2005 Red Hat, Inc. All rights reserved.
  5. **
  6. ** This copyrighted material is made available to anyone wishing to use,
  7. ** modify, copy, or redistribute it subject to the terms and conditions
  8. ** of the GNU General Public License v.2.
  9. **
  10. *******************************************************************************
  11. ******************************************************************************/
  12. #include <linux/pagemap.h>
  13. #include <linux/seq_file.h>
  14. #include <linux/module.h>
  15. #include <linux/ctype.h>
  16. #include <linux/debugfs.h>
  17. #include "dlm_internal.h"
  18. #define DLM_DEBUG_BUF_LEN 4096
  19. static char debug_buf[DLM_DEBUG_BUF_LEN];
  20. static struct mutex debug_buf_lock;
  21. static struct dentry *dlm_root;
  22. struct rsb_iter {
  23. int entry;
  24. struct dlm_ls *ls;
  25. struct list_head *next;
  26. struct dlm_rsb *rsb;
  27. };
  28. /*
  29. * dump all rsb's in the lockspace hash table
  30. */
  31. static char *print_lockmode(int mode)
  32. {
  33. switch (mode) {
  34. case DLM_LOCK_IV:
  35. return "--";
  36. case DLM_LOCK_NL:
  37. return "NL";
  38. case DLM_LOCK_CR:
  39. return "CR";
  40. case DLM_LOCK_CW:
  41. return "CW";
  42. case DLM_LOCK_PR:
  43. return "PR";
  44. case DLM_LOCK_PW:
  45. return "PW";
  46. case DLM_LOCK_EX:
  47. return "EX";
  48. default:
  49. return "??";
  50. }
  51. }
  52. static void print_lock(struct seq_file *s, struct dlm_lkb *lkb,
  53. struct dlm_rsb *res)
  54. {
  55. seq_printf(s, "%08x %s", lkb->lkb_id, print_lockmode(lkb->lkb_grmode));
  56. if (lkb->lkb_status == DLM_LKSTS_CONVERT
  57. || lkb->lkb_status == DLM_LKSTS_WAITING)
  58. seq_printf(s, " (%s)", print_lockmode(lkb->lkb_rqmode));
  59. if (lkb->lkb_nodeid) {
  60. if (lkb->lkb_nodeid != res->res_nodeid)
  61. seq_printf(s, " Remote: %3d %08x", lkb->lkb_nodeid,
  62. lkb->lkb_remid);
  63. else
  64. seq_printf(s, " Master: %08x", lkb->lkb_remid);
  65. }
  66. if (lkb->lkb_wait_type)
  67. seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
  68. seq_printf(s, "\n");
  69. }
  70. static int print_resource(struct dlm_rsb *res, struct seq_file *s)
  71. {
  72. struct dlm_lkb *lkb;
  73. int i, lvblen = res->res_ls->ls_lvblen, recover_list, root_list;
  74. seq_printf(s, "\nResource %p Name (len=%d) \"", res, res->res_length);
  75. for (i = 0; i < res->res_length; i++) {
  76. if (isprint(res->res_name[i]))
  77. seq_printf(s, "%c", res->res_name[i]);
  78. else
  79. seq_printf(s, "%c", '.');
  80. }
  81. if (res->res_nodeid > 0)
  82. seq_printf(s, "\" \nLocal Copy, Master is node %d\n",
  83. res->res_nodeid);
  84. else if (res->res_nodeid == 0)
  85. seq_printf(s, "\" \nMaster Copy\n");
  86. else if (res->res_nodeid == -1)
  87. seq_printf(s, "\" \nLooking up master (lkid %x)\n",
  88. res->res_first_lkid);
  89. else
  90. seq_printf(s, "\" \nInvalid master %d\n", res->res_nodeid);
  91. /* Print the LVB: */
  92. if (res->res_lvbptr) {
  93. seq_printf(s, "LVB: ");
  94. for (i = 0; i < lvblen; i++) {
  95. if (i == lvblen / 2)
  96. seq_printf(s, "\n ");
  97. seq_printf(s, "%02x ",
  98. (unsigned char) res->res_lvbptr[i]);
  99. }
  100. if (rsb_flag(res, RSB_VALNOTVALID))
  101. seq_printf(s, " (INVALID)");
  102. seq_printf(s, "\n");
  103. }
  104. root_list = !list_empty(&res->res_root_list);
  105. recover_list = !list_empty(&res->res_recover_list);
  106. if (root_list || recover_list) {
  107. seq_printf(s, "Recovery: root %d recover %d flags %lx "
  108. "count %d\n", root_list, recover_list,
  109. res->res_flags, res->res_recover_locks_count);
  110. }
  111. /* Print the locks attached to this resource */
  112. seq_printf(s, "Granted Queue\n");
  113. list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue)
  114. print_lock(s, lkb, res);
  115. seq_printf(s, "Conversion Queue\n");
  116. list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue)
  117. print_lock(s, lkb, res);
  118. seq_printf(s, "Waiting Queue\n");
  119. list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue)
  120. print_lock(s, lkb, res);
  121. if (list_empty(&res->res_lookup))
  122. goto out;
  123. seq_printf(s, "Lookup Queue\n");
  124. list_for_each_entry(lkb, &res->res_lookup, lkb_rsb_lookup) {
  125. seq_printf(s, "%08x %s", lkb->lkb_id,
  126. print_lockmode(lkb->lkb_rqmode));
  127. if (lkb->lkb_wait_type)
  128. seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
  129. seq_printf(s, "\n");
  130. }
  131. out:
  132. return 0;
  133. }
  134. static int rsb_iter_next(struct rsb_iter *ri)
  135. {
  136. struct dlm_ls *ls = ri->ls;
  137. int i;
  138. if (!ri->next) {
  139. top:
  140. /* Find the next non-empty hash bucket */
  141. for (i = ri->entry; i < ls->ls_rsbtbl_size; i++) {
  142. read_lock(&ls->ls_rsbtbl[i].lock);
  143. if (!list_empty(&ls->ls_rsbtbl[i].list)) {
  144. ri->next = ls->ls_rsbtbl[i].list.next;
  145. read_unlock(&ls->ls_rsbtbl[i].lock);
  146. break;
  147. }
  148. read_unlock(&ls->ls_rsbtbl[i].lock);
  149. }
  150. ri->entry = i;
  151. if (ri->entry >= ls->ls_rsbtbl_size)
  152. return 1;
  153. } else {
  154. i = ri->entry;
  155. read_lock(&ls->ls_rsbtbl[i].lock);
  156. ri->next = ri->next->next;
  157. if (ri->next->next == ls->ls_rsbtbl[i].list.next) {
  158. /* End of list - move to next bucket */
  159. ri->next = NULL;
  160. ri->entry++;
  161. read_unlock(&ls->ls_rsbtbl[i].lock);
  162. goto top;
  163. }
  164. read_unlock(&ls->ls_rsbtbl[i].lock);
  165. }
  166. ri->rsb = list_entry(ri->next, struct dlm_rsb, res_hashchain);
  167. return 0;
  168. }
  169. static void rsb_iter_free(struct rsb_iter *ri)
  170. {
  171. kfree(ri);
  172. }
  173. static struct rsb_iter *rsb_iter_init(struct dlm_ls *ls)
  174. {
  175. struct rsb_iter *ri;
  176. ri = kmalloc(sizeof *ri, GFP_KERNEL);
  177. if (!ri)
  178. return NULL;
  179. ri->ls = ls;
  180. ri->entry = 0;
  181. ri->next = NULL;
  182. if (rsb_iter_next(ri)) {
  183. rsb_iter_free(ri);
  184. return NULL;
  185. }
  186. return ri;
  187. }
  188. static void *rsb_seq_start(struct seq_file *file, loff_t *pos)
  189. {
  190. struct rsb_iter *ri;
  191. loff_t n = *pos;
  192. ri = rsb_iter_init(file->private);
  193. if (!ri)
  194. return NULL;
  195. while (n--) {
  196. if (rsb_iter_next(ri)) {
  197. rsb_iter_free(ri);
  198. return NULL;
  199. }
  200. }
  201. return ri;
  202. }
  203. static void *rsb_seq_next(struct seq_file *file, void *iter_ptr, loff_t *pos)
  204. {
  205. struct rsb_iter *ri = iter_ptr;
  206. (*pos)++;
  207. if (rsb_iter_next(ri)) {
  208. rsb_iter_free(ri);
  209. return NULL;
  210. }
  211. return ri;
  212. }
  213. static void rsb_seq_stop(struct seq_file *file, void *iter_ptr)
  214. {
  215. /* nothing for now */
  216. }
  217. static int rsb_seq_show(struct seq_file *file, void *iter_ptr)
  218. {
  219. struct rsb_iter *ri = iter_ptr;
  220. print_resource(ri->rsb, file);
  221. return 0;
  222. }
  223. static struct seq_operations rsb_seq_ops = {
  224. .start = rsb_seq_start,
  225. .next = rsb_seq_next,
  226. .stop = rsb_seq_stop,
  227. .show = rsb_seq_show,
  228. };
  229. static int rsb_open(struct inode *inode, struct file *file)
  230. {
  231. struct seq_file *seq;
  232. int ret;
  233. ret = seq_open(file, &rsb_seq_ops);
  234. if (ret)
  235. return ret;
  236. seq = file->private_data;
  237. seq->private = inode->i_private;
  238. return 0;
  239. }
  240. static const struct file_operations rsb_fops = {
  241. .owner = THIS_MODULE,
  242. .open = rsb_open,
  243. .read = seq_read,
  244. .llseek = seq_lseek,
  245. .release = seq_release
  246. };
  247. /*
  248. * dump lkb's on the ls_waiters list
  249. */
  250. static int waiters_open(struct inode *inode, struct file *file)
  251. {
  252. file->private_data = inode->i_private;
  253. return 0;
  254. }
  255. static ssize_t waiters_read(struct file *file, char __user *userbuf,
  256. size_t count, loff_t *ppos)
  257. {
  258. struct dlm_ls *ls = file->private_data;
  259. struct dlm_lkb *lkb;
  260. size_t len = DLM_DEBUG_BUF_LEN, pos = 0, ret, rv;
  261. mutex_lock(&debug_buf_lock);
  262. mutex_lock(&ls->ls_waiters_mutex);
  263. memset(debug_buf, 0, sizeof(debug_buf));
  264. list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) {
  265. ret = snprintf(debug_buf + pos, len - pos, "%x %d %d %s\n",
  266. lkb->lkb_id, lkb->lkb_wait_type,
  267. lkb->lkb_nodeid, lkb->lkb_resource->res_name);
  268. if (ret >= len - pos)
  269. break;
  270. pos += ret;
  271. }
  272. mutex_unlock(&ls->ls_waiters_mutex);
  273. rv = simple_read_from_buffer(userbuf, count, ppos, debug_buf, pos);
  274. mutex_unlock(&debug_buf_lock);
  275. return rv;
  276. }
  277. static const struct file_operations waiters_fops = {
  278. .owner = THIS_MODULE,
  279. .open = waiters_open,
  280. .read = waiters_read
  281. };
  282. int dlm_create_debug_file(struct dlm_ls *ls)
  283. {
  284. char name[DLM_LOCKSPACE_LEN+8];
  285. ls->ls_debug_rsb_dentry = debugfs_create_file(ls->ls_name,
  286. S_IFREG | S_IRUGO,
  287. dlm_root,
  288. ls,
  289. &rsb_fops);
  290. if (!ls->ls_debug_rsb_dentry)
  291. return -ENOMEM;
  292. memset(name, 0, sizeof(name));
  293. snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_waiters", ls->ls_name);
  294. ls->ls_debug_waiters_dentry = debugfs_create_file(name,
  295. S_IFREG | S_IRUGO,
  296. dlm_root,
  297. ls,
  298. &waiters_fops);
  299. if (!ls->ls_debug_waiters_dentry) {
  300. debugfs_remove(ls->ls_debug_rsb_dentry);
  301. return -ENOMEM;
  302. }
  303. return 0;
  304. }
  305. void dlm_delete_debug_file(struct dlm_ls *ls)
  306. {
  307. if (ls->ls_debug_rsb_dentry)
  308. debugfs_remove(ls->ls_debug_rsb_dentry);
  309. if (ls->ls_debug_waiters_dentry)
  310. debugfs_remove(ls->ls_debug_waiters_dentry);
  311. }
  312. int dlm_register_debugfs(void)
  313. {
  314. mutex_init(&debug_buf_lock);
  315. dlm_root = debugfs_create_dir("dlm", NULL);
  316. return dlm_root ? 0 : -ENOMEM;
  317. }
  318. void dlm_unregister_debugfs(void)
  319. {
  320. debugfs_remove(dlm_root);
  321. }