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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
lock_stat.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：7k
源码类别：

MySQL数据库

开发平台：

Visual C++

lock_stat.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996, 1997, 1998, 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: lock_stat.c,v 11.4 2000/12/08 20:15:31 ubell Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #include <ctype.h>
  18. #endif
  20. #ifdef HAVE_RPC
  21. #include "db_server.h"
  22. #endif
  24. #include "db_int.h"
  25. #include "db_shash.h"
  26. #include "lock.h"
  28. #ifdef HAVE_RPC
  29. #include "gen_client_ext.h"
  30. #include "rpc_client_ext.h"
  31. #endif
  33. static void __lock_dump_locker __P((DB_LOCKTAB *, DB_LOCKER *, FILE *));
  34. static void __lock_dump_object __P((DB_LOCKTAB *, DB_LOCKOBJ *, FILE *));
  35. static const char *
  36.     __lock_dump_status __P((db_status_t));
  38. /*
  39.  * lock_stat --
  40.  * Return LOCK statistics.
  41.  */
  42. int
  43. lock_stat(dbenv, statp, db_malloc)
  44. DB_ENV *dbenv;
  45. DB_LOCK_STAT **statp;
  46. void *(*db_malloc) __P((size_t));
  47. {
  48. DB_LOCKREGION *region;
  49. DB_LOCKTAB *lt;
  50. DB_LOCK_STAT *stats;
  51. int ret;
  53. #ifdef HAVE_RPC
  54. if (F_ISSET(dbenv, DB_ENV_RPCCLIENT))
  55. return (__dbcl_lock_stat(dbenv, statp, db_malloc));
  56. #endif
  58. PANIC_CHECK(dbenv);
  59. ENV_REQUIRES_CONFIG(dbenv, dbenv->lk_handle, DB_INIT_LOCK);
  61. *statp = NULL;
  63. lt = dbenv->lk_handle;
  65. if ((ret = __os_malloc(dbenv, sizeof(*stats), db_malloc, &stats)) != 0)
  66. return (ret);
  68. /* Copy out the global statistics. */
  69. R_LOCK(dbenv, &lt->reginfo);
  71. region = lt->reginfo.primary;
  72. stats->st_lastid = region->id;
  73. stats->st_maxlocks = region->maxlocks;
  74. stats->st_maxlockers = region->maxlockers;
  75. stats->st_maxobjects = region->maxobjects;
  76. stats->st_nmodes = region->nmodes;
  77. stats->st_nlockers = region->nlockers;
  78. stats->st_maxnlockers = region->maxnlockers;
  79. stats->st_nobjects = region->nobjects;
  80. stats->st_maxnobjects = region->maxnobjects;
  81. stats->st_nlocks = region->nlocks;
  82. stats->st_maxnlocks = region->maxnlocks;
  83. stats->st_nconflicts = region->nconflicts;
  84. stats->st_nrequests = region->nrequests;
  85. stats->st_nreleases = region->nreleases;
  86. stats->st_nnowaits = region->nnowaits;
  87. stats->st_ndeadlocks = region->ndeadlocks;
  89. stats->st_region_wait = lt->reginfo.rp->mutex.mutex_set_wait;
  90. stats->st_region_nowait = lt->reginfo.rp->mutex.mutex_set_nowait;
  91. stats->st_regsize = lt->reginfo.rp->size;
  93. R_UNLOCK(dbenv, &lt->reginfo);
  95. *statp = stats;
  96. return (0);
  97. }
  99. #define LOCK_DUMP_CONF 0x001 /* Conflict matrix. */
  100. #define LOCK_DUMP_FREE 0x002 /* Display lock free list. */
  101. #define LOCK_DUMP_LOCKERS 0x004 /* Display lockers. */
  102. #define LOCK_DUMP_MEM 0x008 /* Display region memory. */
  103. #define LOCK_DUMP_OBJECTS 0x010 /* Display objects. */
  104. #define LOCK_DUMP_ALL 0x01f /* Display all. */
  106. /*
  107.  * __lock_dump_region --
  108.  *
  109.  * PUBLIC: void __lock_dump_region __P((DB_ENV *, char *, FILE *));
  110.  */
  111. void
  112. __lock_dump_region(dbenv, area, fp)
  113. DB_ENV *dbenv;
  114. char *area;
  115. FILE *fp;
  116. {
  117. struct __db_lock *lp;
  118. DB_LOCKER *lip;
  119. DB_LOCKOBJ *op;
  120. DB_LOCKREGION *lrp;
  121. DB_LOCKTAB *lt;
  122. u_int32_t flags, i, j;
  123. int label;
  125. /* Make it easy to call from the debugger. */
  126. if (fp == NULL)
  127. fp = stderr;
  129. for (flags = 0; *area != ''; ++area)
  130. switch (*area) {
  131. case 'A':
  132. LF_SET(LOCK_DUMP_ALL);
  133. break;
  134. case 'c':
  135. LF_SET(LOCK_DUMP_CONF);
  136. break;
  137. case 'f':
  138. LF_SET(LOCK_DUMP_FREE);
  139. break;
  140. case 'l':
  141. LF_SET(LOCK_DUMP_LOCKERS);
  142. break;
  143. case 'm':
  144. LF_SET(LOCK_DUMP_MEM);
  145. break;
  146. case 'o':
  147. LF_SET(LOCK_DUMP_OBJECTS);
  148. break;
  149. }
  151. lt = dbenv->lk_handle;
  152. lrp = lt->reginfo.primary;
  153. LOCKREGION(dbenv, lt);
  155. fprintf(fp, "%snLock region parametersn", DB_LINE);
  156. fprintf(fp, "%s: %lu, %s: %lu, %s: %lu, %s: %lu, %s: %lu, %s: %lu, %s: %lun",
  157.     "locker table size", (u_long)lrp->locker_t_size,
  158.     "object table size", (u_long)lrp->object_t_size,
  159.     "obj_off", (u_long)lrp->obj_off,
  160.     "osynch_off", (u_long)lrp->osynch_off,
  161.     "locker_off", (u_long)lrp->locker_off,
  162.     "lsynch_off", (u_long)lrp->lsynch_off,
  163.     "need_dd", (u_long)lrp->need_dd);
  165. if (LF_ISSET(LOCK_DUMP_CONF)) {
  166. fprintf(fp, "n%snConflict matrixn", DB_LINE);
  167. for (i = 0; i < lrp->nmodes; i++) {
  168. for (j = 0; j < lrp->nmodes; j++)
  169. fprintf(fp, "%lut",
  170.     (u_long)lt->conflicts[i * lrp->nmodes + j]);
  171. fprintf(fp, "n");
  172. }
  173. }
  175. if (LF_ISSET(LOCK_DUMP_LOCKERS)) {
  176. fprintf(fp, "%snLocker hash bucketsn", DB_LINE);
  177. for (i = 0; i < lrp->locker_t_size; i++) {
  178. label = 1;
  179. for (lip =
  180.     SH_TAILQ_FIRST(&lt->locker_tab[i], __db_locker);
  181.     lip != NULL;
  182.     lip = SH_TAILQ_NEXT(lip, links, __db_locker)) {
  183. if (label) {
  184. fprintf(fp, "Bucket %lu:n", (u_long)i);
  185. label = 0;
  186. }
  187. __lock_dump_locker(lt, lip, fp);
  188. }
  189. }
  190. }
  192. if (LF_ISSET(LOCK_DUMP_OBJECTS)) {
  193. fprintf(fp, "%snObject hash bucketsn", DB_LINE);
  194. for (i = 0; i < lrp->object_t_size; i++) {
  195. label = 1;
  196. for (op = SH_TAILQ_FIRST(&lt->obj_tab[i], __db_lockobj);
  197.     op != NULL;
  198.     op = SH_TAILQ_NEXT(op, links, __db_lockobj)) {
  199. if (label) {
  200. fprintf(fp, "Bucket %lu:n", (u_long)i);
  201. label = 0;
  202. }
  203. __lock_dump_object(lt, op, fp);
  204. }
  205. }
  206. }
  208. if (LF_ISSET(LOCK_DUMP_FREE)) {
  209. fprintf(fp, "%snLock free listn", DB_LINE);
  210. for (lp = SH_TAILQ_FIRST(&lrp->free_locks, __db_lock);
  211.     lp != NULL;
  212.     lp = SH_TAILQ_NEXT(lp, links, __db_lock))
  213. fprintf(fp, "0x%lx: %lut%lut%st0x%lxn", (u_long)lp,
  214.     (u_long)lp->holder, (u_long)lp->mode,
  215.     __lock_dump_status(lp->status), (u_long)lp->obj);
  217. fprintf(fp, "%snObject free listn", DB_LINE);
  218. for (op = SH_TAILQ_FIRST(&lrp->free_objs, __db_lockobj);
  219.     op != NULL;
  220.     op = SH_TAILQ_NEXT(op, links, __db_lockobj))
  221. fprintf(fp, "0x%lxn", (u_long)op);
  223. fprintf(fp, "%snLocker free listn", DB_LINE);
  224. for (lip = SH_TAILQ_FIRST(&lrp->free_lockers, __db_locker);
  225.     lip != NULL;
  226.     lip = SH_TAILQ_NEXT(lip, links, __db_locker))
  227. fprintf(fp, "0x%lxn", (u_long)lip);
  228. }
  230. if (LF_ISSET(LOCK_DUMP_MEM))
  231. __db_shalloc_dump(lt->reginfo.addr, fp);
  233. UNLOCKREGION(dbenv, lt);
  234. }
  236. static void
  237. __lock_dump_locker(lt, lip, fp)
  238. DB_LOCKTAB *lt;
  239. DB_LOCKER *lip;
  240. FILE *fp;
  241. {
  242. struct __db_lock *lp;
  244. fprintf(fp, "L %lx [%ld]", (u_long)lip->id, (long)lip->dd_id);
  245. fprintf(fp, " %s ", F_ISSET(lip, DB_LOCKER_DELETED) ? "(D)" : "   ");
  247. if ((lp = SH_LIST_FIRST(&lip->heldby, __db_lock)) == NULL)
  248. fprintf(fp, "n");
  249. else
  250. for (; lp != NULL;
  251.     lp = SH_LIST_NEXT(lp, locker_links, __db_lock))
  252. __lock_printlock(lt, lp, 1);
  253. }
  255. static void
  256. __lock_dump_object(lt, op, fp)
  257. DB_LOCKTAB *lt;
  258. DB_LOCKOBJ *op;
  259. FILE *fp;
  260. {
  261. struct __db_lock *lp;
  262. u_int32_t j;
  263. u_int8_t *ptr;
  264. u_int ch;
  266. ptr = SH_DBT_PTR(&op->lockobj);
  267. for (j = 0; j < op->lockobj.size; ptr++, j++) {
  268. ch = *ptr;
  269. fprintf(fp, isprint(ch) ? "%c" : "\%o", ch);
  270. }
  271. fprintf(fp, "n");
  273. fprintf(fp, "H:");
  274. for (lp =
  275.     SH_TAILQ_FIRST(&op->holders, __db_lock);
  276.     lp != NULL;
  277.     lp = SH_TAILQ_NEXT(lp, links, __db_lock))
  278. __lock_printlock(lt, lp, 1);
  279. lp = SH_TAILQ_FIRST(&op->waiters, __db_lock);
  280. if (lp != NULL) {
  281. fprintf(fp, "nW:");
  282. for (; lp != NULL; lp = SH_TAILQ_NEXT(lp, links, __db_lock))
  283. __lock_printlock(lt, lp, 1);
  284. }
  285. }
  287. static const char *
  288. __lock_dump_status(status)
  289. db_status_t status;
  290. {
  291. switch (status) {
  292. case DB_LSTAT_ABORTED:
  293. return ("aborted");
  294. case DB_LSTAT_ERR:
  295. return ("err");
  296. case DB_LSTAT_FREE:
  297. return ("free");
  298. case DB_LSTAT_HELD:
  299. return ("held");
  300. case DB_LSTAT_NOGRANT:
  301. return ("nogrant");
  302. case DB_LSTAT_PENDING:
  303. return ("pending");
  304. case DB_LSTAT_WAITING:
  305. return ("waiting");
  306. }
  307. return ("unknown status");
  308. }