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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
lock_stat.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：9k
源码类别：

MySQL数据库

开发平台：

Visual C++

lock_stat.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  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.32 2002/08/14 20:08:51 bostic Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  16. #include <string.h>
  17. #if TIME_WITH_SYS_TIME
  18. #include <sys/time.h>
  19. #include <time.h>
  20. #else
  21. #if HAVE_SYS_TIME_H
  22. #include <sys/time.h>
  23. #else
  24. #include <time.h>
  25. #endif
  26. #endif
  28. #include <ctype.h>
  29. #endif
  31. #include "db_int.h"
  32. #include "dbinc/db_shash.h"
  33. #include "dbinc/db_page.h"
  34. #include "dbinc/lock.h"
  35. #include "dbinc/log.h"
  36. #include "dbinc/db_am.h"
  38. static void __lock_dump_locker __P((DB_LOCKTAB *, DB_LOCKER *, FILE *));
  39. static void __lock_dump_object __P((DB_LOCKTAB *, DB_LOCKOBJ *, FILE *));
  40. static void __lock_printheader __P((void));
  42. /*
  43.  * __lock_stat --
  44.  * Return LOCK statistics.
  45.  *
  46.  * PUBLIC: int __lock_stat __P((DB_ENV *, DB_LOCK_STAT **, u_int32_t));
  47.  */
  48. int
  49. __lock_stat(dbenv, statp, flags)
  50. DB_ENV *dbenv;
  51. DB_LOCK_STAT **statp;
  52. u_int32_t flags;
  53. {
  54. DB_LOCKREGION *region;
  55. DB_LOCKTAB *lt;
  56. DB_LOCK_STAT *stats, tmp;
  57. int ret;
  59. PANIC_CHECK(dbenv);
  60. ENV_REQUIRES_CONFIG(dbenv,
  61.     dbenv->lk_handle, "DB_ENV->lock_stat", DB_INIT_LOCK);
  63. *statp = NULL;
  64. if ((ret = __db_fchk(dbenv,
  65.     "DB_ENV->lock_stat", flags, DB_STAT_CLEAR)) != 0)
  66. return (ret);
  68. lt = dbenv->lk_handle;
  70. if ((ret = __os_umalloc(dbenv, sizeof(*stats), &stats)) != 0)
  71. return (ret);
  73. /* Copy out the global statistics. */
  74. R_LOCK(dbenv, &lt->reginfo);
  76. region = lt->reginfo.primary;
  77. memcpy(stats, &region->stat, sizeof(*stats));
  78. stats->st_locktimeout = region->lk_timeout;
  79. stats->st_txntimeout = region->tx_timeout;
  81. stats->st_region_wait = lt->reginfo.rp->mutex.mutex_set_wait;
  82. stats->st_region_nowait = lt->reginfo.rp->mutex.mutex_set_nowait;
  83. stats->st_regsize = lt->reginfo.rp->size;
  84. if (LF_ISSET(DB_STAT_CLEAR)) {
  85. tmp = region->stat;
  86. memset(&region->stat, 0, sizeof(region->stat));
  87. lt->reginfo.rp->mutex.mutex_set_wait = 0;
  88. lt->reginfo.rp->mutex.mutex_set_nowait = 0;
  90. region->stat.st_id = tmp.st_id;
  91. region->stat.st_cur_maxid = tmp.st_cur_maxid;
  92. region->stat.st_maxlocks = tmp.st_maxlocks;
  93. region->stat.st_maxlockers = tmp.st_maxlockers;
  94. region->stat.st_maxobjects = tmp.st_maxobjects;
  95. region->stat.st_nlocks =
  96.     region->stat.st_maxnlocks = tmp.st_nlocks;
  97. region->stat.st_nlockers =
  98.     region->stat.st_maxnlockers = tmp.st_nlockers;
  99. region->stat.st_nobjects =
  100.     region->stat.st_maxnobjects = tmp.st_nobjects;
  101. region->stat.st_nmodes = tmp.st_nmodes;
  102. }
  104. R_UNLOCK(dbenv, &lt->reginfo);
  106. *statp = stats;
  107. return (0);
  108. }
  110. #define LOCK_DUMP_CONF 0x001 /* Conflict matrix. */
  111. #define LOCK_DUMP_LOCKERS 0x002 /* Display lockers. */
  112. #define LOCK_DUMP_MEM 0x004 /* Display region memory. */
  113. #define LOCK_DUMP_OBJECTS 0x008 /* Display objects. */
  114. #define LOCK_DUMP_PARAMS 0x010 /* Display params. */
  115. #define LOCK_DUMP_ALL /* All */
  116. (LOCK_DUMP_CONF | LOCK_DUMP_LOCKERS | LOCK_DUMP_MEM |
  117. LOCK_DUMP_OBJECTS | LOCK_DUMP_PARAMS)
  119. /*
  120.  * __lock_dump_region --
  121.  *
  122.  * PUBLIC: int __lock_dump_region __P((DB_ENV *, char *, FILE *));
  123.  */
  124. int
  125. __lock_dump_region(dbenv, area, fp)
  126. DB_ENV *dbenv;
  127. char *area;
  128. FILE *fp;
  129. {
  130. DB_LOCKER *lip;
  131. DB_LOCKOBJ *op;
  132. DB_LOCKREGION *lrp;
  133. DB_LOCKTAB *lt;
  134. u_int32_t flags, i, j;
  136. PANIC_CHECK(dbenv);
  137. ENV_REQUIRES_CONFIG(dbenv,
  138.     dbenv->lk_handle, "lock_dump_region", DB_INIT_LOCK);
  140. /* Make it easy to call from the debugger. */
  141. if (fp == NULL)
  142. fp = stderr;
  144. for (flags = 0; *area != ''; ++area)
  145. switch (*area) {
  146. case 'A':
  147. LF_SET(LOCK_DUMP_ALL);
  148. break;
  149. case 'c':
  150. LF_SET(LOCK_DUMP_CONF);
  151. break;
  152. case 'l':
  153. LF_SET(LOCK_DUMP_LOCKERS);
  154. break;
  155. case 'm':
  156. LF_SET(LOCK_DUMP_MEM);
  157. break;
  158. case 'o':
  159. LF_SET(LOCK_DUMP_OBJECTS);
  160. break;
  161. case 'p':
  162. LF_SET(LOCK_DUMP_PARAMS);
  163. break;
  164. }
  166. lt = dbenv->lk_handle;
  167. lrp = lt->reginfo.primary;
  168. LOCKREGION(dbenv, lt);
  170. if (LF_ISSET(LOCK_DUMP_PARAMS)) {
  171. fprintf(fp, "%snLock region parametersn", DB_LINE);
  172. fprintf(fp,
  173.     "%s: %lu, %s: %lu, %s: %lu,n%s: %lu, %s: %lu, %s: %lu, %s: %lun",
  174.     "locker table size", (u_long)lrp->locker_t_size,
  175.     "object table size", (u_long)lrp->object_t_size,
  176.     "obj_off", (u_long)lrp->obj_off,
  177.     "osynch_off", (u_long)lrp->osynch_off,
  178.     "locker_off", (u_long)lrp->locker_off,
  179.     "lsynch_off", (u_long)lrp->lsynch_off,
  180.     "need_dd", (u_long)lrp->need_dd);
  181. }
  183. if (LF_ISSET(LOCK_DUMP_CONF)) {
  184. fprintf(fp, "n%snConflict matrixn", DB_LINE);
  185. for (i = 0; i < lrp->stat.st_nmodes; i++) {
  186. for (j = 0; j < lrp->stat.st_nmodes; j++)
  187. fprintf(fp, "%lut", (u_long)
  188.     lt->conflicts[i * lrp->stat.st_nmodes + j]);
  189. fprintf(fp, "n");
  190. }
  191. }
  193. if (LF_ISSET(LOCK_DUMP_LOCKERS)) {
  194. fprintf(fp, "%snLocks grouped by lockersn", DB_LINE);
  195. __lock_printheader();
  196. for (i = 0; i < lrp->locker_t_size; i++)
  197. for (lip =
  198.     SH_TAILQ_FIRST(&lt->locker_tab[i], __db_locker);
  199.     lip != NULL;
  200.     lip = SH_TAILQ_NEXT(lip, links, __db_locker)) {
  201. __lock_dump_locker(lt, lip, fp);
  202. }
  203. }
  205. if (LF_ISSET(LOCK_DUMP_OBJECTS)) {
  206. fprintf(fp, "%snLocks grouped by objectn", DB_LINE);
  207. __lock_printheader();
  208. for (i = 0; i < lrp->object_t_size; i++) {
  209. for (op = SH_TAILQ_FIRST(&lt->obj_tab[i], __db_lockobj);
  210.     op != NULL;
  211.     op = SH_TAILQ_NEXT(op, links, __db_lockobj))
  212. __lock_dump_object(lt, op, fp);
  213. }
  214. }
  216. if (LF_ISSET(LOCK_DUMP_MEM))
  217. __db_shalloc_dump(lt->reginfo.addr, fp);
  219. UNLOCKREGION(dbenv, lt);
  221. return (0);
  222. }
  224. static void
  225. __lock_dump_locker(lt, lip, fp)
  226. DB_LOCKTAB *lt;
  227. DB_LOCKER *lip;
  228. FILE *fp;
  229. {
  230. struct __db_lock *lp;
  231. time_t s;
  232. char buf[64];
  234. fprintf(fp, "%8lx dd=%2ld locks held %-4d write locks %-4d",
  235.     (u_long)lip->id, (long)lip->dd_id, lip->nlocks, lip->nwrites);
  236. fprintf(fp, " %s ", F_ISSET(lip, DB_LOCKER_DELETED) ? "(D)" : "   ");
  237. if (LOCK_TIME_ISVALID(&lip->tx_expire)) {
  238. s = lip->tx_expire.tv_sec;
  239. strftime(buf, sizeof(buf), "%m-%d-%H:%M:%S", localtime(&s));
  240. fprintf(fp,
  241.     " expires %s.%lu", buf, (u_long)lip->tx_expire.tv_usec);
  242. }
  243. if (F_ISSET(lip, DB_LOCKER_TIMEOUT))
  244. fprintf(fp, " lk timeout %u", lip->lk_timeout);
  245. if (LOCK_TIME_ISVALID(&lip->lk_expire)) {
  246. s = lip->lk_expire.tv_sec;
  247. strftime(buf, sizeof(buf), "%m-%d-%H:%M:%S", localtime(&s));
  248. fprintf(fp,
  249.     " lk expires %s.%lu", buf, (u_long)lip->lk_expire.tv_usec);
  250. }
  251. fprintf(fp, "n");
  253. lp = SH_LIST_FIRST(&lip->heldby, __db_lock);
  254. if (lp != NULL) {
  255. for (; lp != NULL;
  256.     lp = SH_LIST_NEXT(lp, locker_links, __db_lock))
  257. __lock_printlock(lt, lp, 1);
  258. fprintf(fp, "n");
  259. }
  260. }
  262. static void
  263. __lock_dump_object(lt, op, fp)
  264. DB_LOCKTAB *lt;
  265. DB_LOCKOBJ *op;
  266. FILE *fp;
  267. {
  268. struct __db_lock *lp;
  270. for (lp =
  271.     SH_TAILQ_FIRST(&op->holders, __db_lock);
  272.     lp != NULL;
  273.     lp = SH_TAILQ_NEXT(lp, links, __db_lock))
  274. __lock_printlock(lt, lp, 1);
  275. for (lp =
  276.     SH_TAILQ_FIRST(&op->waiters, __db_lock);
  277.     lp != NULL;
  278.     lp = SH_TAILQ_NEXT(lp, links, __db_lock))
  279. __lock_printlock(lt, lp, 1);
  281. fprintf(fp, "n");
  282. }
  284. /*
  285.  * __lock_printheader --
  286.  */
  287. static void
  288. __lock_printheader()
  289. {
  290. printf("%-8s  %-6s  %-6s  %-10s  %sn",
  291.     "Locker", "Mode",
  292.     "Count", "Status", "----------- Object ----------");
  293. }
  295. /*
  296.  * __lock_printlock --
  297.  *
  298.  * PUBLIC: void __lock_printlock __P((DB_LOCKTAB *, struct __db_lock *, int));
  299.  */
  300. void
  301. __lock_printlock(lt, lp, ispgno)
  302. DB_LOCKTAB *lt;
  303. struct __db_lock *lp;
  304. int ispgno;
  305. {
  306. DB_LOCKOBJ *lockobj;
  307. db_pgno_t pgno;
  308. u_int32_t *fidp, type;
  309. u_int8_t *ptr;
  310. char *namep;
  311. const char *mode, *status;
  313. switch (lp->mode) {
  314. case DB_LOCK_DIRTY:
  315. mode = "DIRTY_READ";
  316. break;
  317. case DB_LOCK_IREAD:
  318. mode = "IREAD";
  319. break;
  320. case DB_LOCK_IWR:
  321. mode = "IWR";
  322. break;
  323. case DB_LOCK_IWRITE:
  324. mode = "IWRITE";
  325. break;
  326. case DB_LOCK_NG:
  327. mode = "NG";
  328. break;
  329. case DB_LOCK_READ:
  330. mode = "READ";
  331. break;
  332. case DB_LOCK_WRITE:
  333. mode = "WRITE";
  334. break;
  335. case DB_LOCK_WWRITE:
  336. mode = "WAS_WRITE";
  337. break;
  338. case DB_LOCK_WAIT:
  339. mode = "WAIT";
  340. break;
  341. default:
  342. mode = "UNKNOWN";
  343. break;
  344. }
  345. switch (lp->status) {
  346. case DB_LSTAT_ABORTED:
  347. status = "ABORT";
  348. break;
  349. case DB_LSTAT_ERR:
  350. status = "ERROR";
  351. break;
  352. case DB_LSTAT_FREE:
  353. status = "FREE";
  354. break;
  355. case DB_LSTAT_HELD:
  356. status = "HELD";
  357. break;
  358. case DB_LSTAT_WAITING:
  359. status = "WAIT";
  360. break;
  361. case DB_LSTAT_PENDING:
  362. status = "PENDING";
  363. break;
  364. case DB_LSTAT_EXPIRED:
  365. status = "EXPIRED";
  366. break;
  367. default:
  368. status = "UNKNOWN";
  369. break;
  370. }
  371. printf("%8lx  %-6s  %6lu  %-10s  ",
  372.     (u_long)lp->holder, mode, (u_long)lp->refcount, status);
  374. lockobj = (DB_LOCKOBJ *)((u_int8_t *)lp + lp->obj);
  375. ptr = SH_DBT_PTR(&lockobj->lockobj);
  376. if (ispgno && lockobj->lockobj.size == sizeof(struct __db_ilock)) {
  377. /* Assume this is a DBT lock. */
  378. memcpy(&pgno, ptr, sizeof(db_pgno_t));
  379. fidp = (u_int32_t *)(ptr + sizeof(db_pgno_t));
  380. type = *(u_int32_t *)(ptr + sizeof(db_pgno_t) + DB_FILE_ID_LEN);
  381. if (__dbreg_get_name(lt->dbenv, (u_int8_t *)fidp, &namep) != 0)
  382. namep = NULL;
  383. if (namep == NULL)
  384. printf("(%lx %lx %lx %lx %lx)",
  385. (u_long)fidp[0], (u_long)fidp[1], (u_long)fidp[2],
  386. (u_long)fidp[3], (u_long)fidp[4]);
  387. else
  388. printf("%-20s", namep);
  389. printf("%-7s  %lun",
  390. type == DB_PAGE_LOCK ? "page" :
  391. type == DB_RECORD_LOCK ? "record" : "handle",
  392. (u_long)pgno);
  393. } else {
  394. printf("0x%lx ", (u_long)R_OFFSET(&lt->reginfo, lockobj));
  395. __db_pr(ptr, lockobj->lockobj.size, stdout);
  396. printf("n");
  397. }
  398. }