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

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

MySQL数据库

开发平台：

Visual C++

tcl_lock.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1999-2001
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: tcl_lock.c,v 11.47 2002/08/08 15:27:10 bostic Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #include <stdlib.h>
  18. #include <string.h>
  19. #include <tcl.h>
  20. #endif
  22. #include "db_int.h"
  23. #include "dbinc/tcl_db.h"
  25. /*
  26.  * Prototypes for procedures defined later in this file:
  27.  */
  28. static int      lock_Cmd __P((ClientData, Tcl_Interp *, int, Tcl_Obj * CONST*));
  29. static int _LockMode __P((Tcl_Interp *, Tcl_Obj *, db_lockmode_t *));
  30. static int _GetThisLock __P((Tcl_Interp *, DB_ENV *, u_int32_t,
  31.      u_int32_t, DBT *, db_lockmode_t, char *));
  32. static void _LockPutInfo __P((Tcl_Interp *, db_lockop_t, DB_LOCK *,
  33.      u_int32_t, DBT *));
  34. #if CONFIG_TEST
  35. static char *lkmode[] = {
  36. "ng",
  37. "read",
  38. "write",
  39. "iwrite",
  40. "iread",
  41. "iwr",
  42.  NULL
  43. };
  44. enum lkmode {
  45. LK_NG,
  46. LK_READ,
  47. LK_WRITE,
  48. LK_IWRITE,
  49. LK_IREAD,
  50. LK_IWR
  51. };
  53. /*
  54.  * tcl_LockDetect --
  55.  *
  56.  * PUBLIC: int tcl_LockDetect __P((Tcl_Interp *, int,
  57.  * PUBLIC:    Tcl_Obj * CONST*, DB_ENV *));
  58.  */
  59. int
  60. tcl_LockDetect(interp, objc, objv, envp)
  61. Tcl_Interp *interp; /* Interpreter */
  62. int objc; /* How many arguments? */
  63. Tcl_Obj *CONST objv[]; /* The argument objects */
  64. DB_ENV *envp; /* Environment pointer */
  65. {
  66. static char *ldopts[] = {
  67. "expire",
  68. "default",
  69. "maxlocks",
  70. "minlocks",
  71. "minwrites",
  72. "oldest",
  73. "random",
  74. "youngest",
  75.  NULL
  76. };
  77. enum ldopts {
  78. LD_EXPIRE,
  79. LD_DEFAULT,
  80. LD_MAXLOCKS,
  81. LD_MINLOCKS,
  82. LD_MINWRITES,
  83. LD_OLDEST,
  84. LD_RANDOM,
  85. LD_YOUNGEST
  86. };
  87. u_int32_t flag, policy;
  88. int i, optindex, result, ret;
  90. result = TCL_OK;
  91. flag = policy = 0;
  92. i = 2;
  93. while (i < objc) {
  94. if (Tcl_GetIndexFromObj(interp, objv[i],
  95.     ldopts, "option", TCL_EXACT, &optindex) != TCL_OK)
  96. return (IS_HELP(objv[i]));
  97. i++;
  98. switch ((enum ldopts)optindex) {
  99. case LD_EXPIRE:
  100. FLAG_CHECK(policy);
  101. policy = DB_LOCK_EXPIRE;
  102. break;
  103. case LD_DEFAULT:
  104. FLAG_CHECK(policy);
  105. policy = DB_LOCK_DEFAULT;
  106. break;
  107. case LD_MAXLOCKS:
  108. FLAG_CHECK(policy);
  109. policy = DB_LOCK_MAXLOCKS;
  110. break;
  111. case LD_MINWRITES:
  112. FLAG_CHECK(policy);
  113. policy = DB_LOCK_MINWRITE;
  114. break;
  115. case LD_MINLOCKS:
  116. FLAG_CHECK(policy);
  117. policy = DB_LOCK_MINLOCKS;
  118. break;
  119. case LD_OLDEST:
  120. FLAG_CHECK(policy);
  121. policy = DB_LOCK_OLDEST;
  122. break;
  123. case LD_YOUNGEST:
  124. FLAG_CHECK(policy);
  125. policy = DB_LOCK_YOUNGEST;
  126. break;
  127. case LD_RANDOM:
  128. FLAG_CHECK(policy);
  129. policy = DB_LOCK_RANDOM;
  130. break;
  131. }
  132. }
  134. _debug_check();
  135. ret = envp->lock_detect(envp, flag, policy, NULL);
  136. result = _ReturnSetup(interp, ret, DB_RETOK_STD(ret), "lock detect");
  137. return (result);
  138. }
  140. /*
  141.  * tcl_LockGet --
  142.  *
  143.  * PUBLIC: int tcl_LockGet __P((Tcl_Interp *, int,
  144.  * PUBLIC:    Tcl_Obj * CONST*, DB_ENV *));
  145.  */
  146. int
  147. tcl_LockGet(interp, objc, objv, envp)
  148. Tcl_Interp *interp; /* Interpreter */
  149. int objc; /* How many arguments? */
  150. Tcl_Obj *CONST objv[]; /* The argument objects */
  151. DB_ENV *envp; /* Environment pointer */
  152. {
  153. static char *lgopts[] = {
  154. "-nowait",
  155.  NULL
  156. };
  157. enum lgopts {
  158. LGNOWAIT
  159. };
  160. DBT obj;
  161. Tcl_Obj *res;
  162. void *otmp;
  163. db_lockmode_t mode;
  164. u_int32_t flag, lockid;
  165. int freeobj, optindex, result, ret;
  166. char newname[MSG_SIZE];
  168. result = TCL_OK;
  169. freeobj = 0;
  170. memset(newname, 0, MSG_SIZE);
  171. if (objc != 5 && objc != 6) {
  172. Tcl_WrongNumArgs(interp, 2, objv, "?-nowait? mode id obj");
  173. return (TCL_ERROR);
  174. }
  175. /*
  176.  * Work back from required args.
  177.  * Last arg is obj.
  178.  * Second last is lock id.
  179.  * Third last is lock mode.
  180.  */
  181. memset(&obj, 0, sizeof(obj));
  183. if ((result =
  184.     _GetUInt32(interp, objv[objc-2], &lockid)) != TCL_OK)
  185. return (result);
  187. ret = _CopyObjBytes(interp, objv[objc-1], &otmp,
  188.     &obj.size, &freeobj);
  189. if (ret != 0) {
  190. result = _ReturnSetup(interp, ret,
  191.     DB_RETOK_STD(ret), "lock get");
  192. return (result);
  193. }
  194. obj.data = otmp;
  195. if ((result = _LockMode(interp, objv[(objc - 3)], &mode)) != TCL_OK)
  196. goto out;
  198. /*
  199.  * Any left over arg is the flag.
  200.  */
  201. flag = 0;
  202. if (objc == 6) {
  203. if (Tcl_GetIndexFromObj(interp, objv[(objc - 4)],
  204.     lgopts, "option", TCL_EXACT, &optindex) != TCL_OK)
  205. return (IS_HELP(objv[(objc - 4)]));
  206. switch ((enum lgopts)optindex) {
  207. case LGNOWAIT:
  208. flag |= DB_LOCK_NOWAIT;
  209. break;
  210. }
  211. }
  213. result = _GetThisLock(interp, envp, lockid, flag, &obj, mode, newname);
  214. if (result == TCL_OK) {
  215. res = Tcl_NewStringObj(newname, strlen(newname));
  216. Tcl_SetObjResult(interp, res);
  217. }
  218. out:
  219. if (freeobj)
  220. (void)__os_free(envp, otmp);
  221. return (result);
  222. }
  224. /*
  225.  * tcl_LockStat --
  226.  *
  227.  * PUBLIC: int tcl_LockStat __P((Tcl_Interp *, int,
  228.  * PUBLIC:    Tcl_Obj * CONST*, DB_ENV *));
  229.  */
  230. int
  231. tcl_LockStat(interp, objc, objv, envp)
  232. Tcl_Interp *interp; /* Interpreter */
  233. int objc; /* How many arguments? */
  234. Tcl_Obj *CONST objv[]; /* The argument objects */
  235. DB_ENV *envp; /* Environment pointer */
  236. {
  237. DB_LOCK_STAT *sp;
  238. Tcl_Obj *res;
  239. int result, ret;
  241. result = TCL_OK;
  242. /*
  243.  * No args for this.  Error if there are some.
  244.  */
  245. if (objc != 2) {
  246. Tcl_WrongNumArgs(interp, 2, objv, NULL);
  247. return (TCL_ERROR);
  248. }
  249. _debug_check();
  250. ret = envp->lock_stat(envp, &sp, 0);
  251. result = _ReturnSetup(interp, ret, DB_RETOK_STD(ret), "lock stat");
  252. if (result == TCL_ERROR)
  253. return (result);
  254. /*
  255.  * Have our stats, now construct the name value
  256.  * list pairs and free up the memory.
  257.  */
  258. res = Tcl_NewObj();
  259. /*
  260.  * MAKE_STAT_LIST assumes 'res' and 'error' label.
  261.  */
  262. MAKE_STAT_LIST("Region size", sp->st_regsize);
  263. MAKE_STAT_LIST("Last allocated locker ID", sp->st_id);
  264. MAKE_STAT_LIST("Current maximum unused locker ID", sp->st_cur_maxid);
  265. MAKE_STAT_LIST("Maximum locks", sp->st_maxlocks);
  266. MAKE_STAT_LIST("Maximum lockers", sp->st_maxlockers);
  267. MAKE_STAT_LIST("Maximum objects", sp->st_maxobjects);
  268. MAKE_STAT_LIST("Lock modes", sp->st_nmodes);
  269. MAKE_STAT_LIST("Current number of locks", sp->st_nlocks);
  270. MAKE_STAT_LIST("Maximum number of locks so far", sp->st_maxnlocks);
  271. MAKE_STAT_LIST("Current number of lockers", sp->st_nlockers);
  272. MAKE_STAT_LIST("Maximum number of lockers so far", sp->st_maxnlockers);
  273. MAKE_STAT_LIST("Current number of objects", sp->st_nobjects);
  274. MAKE_STAT_LIST("Maximum number of objects so far", sp->st_maxnobjects);
  275. MAKE_STAT_LIST("Number of conflicts", sp->st_nconflicts);
  276. MAKE_STAT_LIST("Lock requests", sp->st_nrequests);
  277. MAKE_STAT_LIST("Lock releases", sp->st_nreleases);
  278. MAKE_STAT_LIST("Lock requests that would have waited", sp->st_nnowaits);
  279. MAKE_STAT_LIST("Deadlocks detected", sp->st_ndeadlocks);
  280. MAKE_STAT_LIST("Number of region lock waits", sp->st_region_wait);
  281. MAKE_STAT_LIST("Number of region lock nowaits", sp->st_region_nowait);
  282. MAKE_STAT_LIST("Lock timeout value", sp->st_locktimeout);
  283. MAKE_STAT_LIST("Number of lock timeouts", sp->st_nlocktimeouts);
  284. MAKE_STAT_LIST("Transaction timeout value", sp->st_txntimeout);
  285. MAKE_STAT_LIST("Number of transaction timeouts", sp->st_ntxntimeouts);
  286. Tcl_SetObjResult(interp, res);
  287. error:
  288. free(sp);
  289. return (result);
  290. }
  292. /*
  293.  * tcl_LockTimeout --
  294.  *
  295.  * PUBLIC: int tcl_LockTimeout __P((Tcl_Interp *, int,
  296.  * PUBLIC:    Tcl_Obj * CONST*, DB_ENV *));
  297.  */
  298. int
  299. tcl_LockTimeout(interp, objc, objv, envp)
  300. Tcl_Interp *interp; /* Interpreter */
  301. int objc; /* How many arguments? */
  302. Tcl_Obj *CONST objv[]; /* The argument objects */
  303. DB_ENV *envp; /* Environment pointer */
  304. {
  305. long timeout;
  306. int result, ret;
  308. /*
  309.  * One arg, the timeout.
  310.  */
  311. if (objc != 3) {
  312. Tcl_WrongNumArgs(interp, 2, objv, "?timeout?");
  313. return (TCL_ERROR);
  314. }
  315. result = Tcl_GetLongFromObj(interp, objv[2], &timeout);
  316. if (result != TCL_OK)
  317. return (result);
  318. _debug_check();
  319. ret = envp->set_timeout(envp, (u_int32_t)timeout, DB_SET_LOCK_TIMEOUT);
  320. result = _ReturnSetup(interp, ret, DB_RETOK_STD(ret), "lock timeout");
  321. return (result);
  322. }
  324. /*
  325.  * lock_Cmd --
  326.  * Implements the "lock" widget.
  327.  */
  328. static int
  329. lock_Cmd(clientData, interp, objc, objv)
  330. ClientData clientData; /* Lock handle */
  331. Tcl_Interp *interp; /* Interpreter */
  332. int objc; /* How many arguments? */
  333. Tcl_Obj *CONST objv[]; /* The argument objects */
  334. {
  335. static char *lkcmds[] = {
  336. "put",
  337. NULL
  338. };
  339. enum lkcmds {
  340. LKPUT
  341. };
  342. DB_ENV *env;
  343. DB_LOCK *lock;
  344. DBTCL_INFO *lkip;
  345. int cmdindex, result, ret;
  347. Tcl_ResetResult(interp);
  348. lock = (DB_LOCK *)clientData;
  349. lkip = _PtrToInfo((void *)lock);
  350. result = TCL_OK;
  352. if (lock == NULL) {
  353. Tcl_SetResult(interp, "NULL lock", TCL_STATIC);
  354. return (TCL_ERROR);
  355. }
  356. if (lkip == NULL) {
  357. Tcl_SetResult(interp, "NULL lock info pointer", TCL_STATIC);
  358. return (TCL_ERROR);
  359. }
  361. env = NAME_TO_ENV(lkip->i_parent->i_name);
  362. /*
  363.  * No args for this.  Error if there are some.
  364.  */
  365. if (objc != 2) {
  366. Tcl_WrongNumArgs(interp, 2, objv, NULL);
  367. return (TCL_ERROR);
  368. }
  369. /*
  370.  * Get the command name index from the object based on the dbcmds
  371.  * defined above.
  372.  */
  373. if (Tcl_GetIndexFromObj(interp,
  374.     objv[1], lkcmds, "command", TCL_EXACT, &cmdindex) != TCL_OK)
  375. return (IS_HELP(objv[1]));
  377. switch ((enum lkcmds)cmdindex) {
  378. case LKPUT:
  379. _debug_check();
  380. ret = env->lock_put(env, lock);
  381. result = _ReturnSetup(interp, ret, DB_RETOK_STD(ret),
  382.     "lock put");
  383. (void)Tcl_DeleteCommand(interp, lkip->i_name);
  384. _DeleteInfo(lkip);
  385. __os_free(env, lock);
  386. break;
  387. }
  388. return (result);
  389. }
  391. /*
  392.  * tcl_LockVec --
  393.  *
  394.  * PUBLIC: int tcl_LockVec __P((Tcl_Interp *, int, Tcl_Obj * CONST*, DB_ENV *));
  395.  */
  396. int
  397. tcl_LockVec(interp, objc, objv, envp)
  398. Tcl_Interp *interp; /* Interpreter */
  399. int objc; /* How many arguments? */
  400. Tcl_Obj *CONST objv[]; /* The argument objects */
  401. DB_ENV *envp; /* environment pointer */
  402. {
  403. static char *lvopts[] = {
  404. "-nowait",
  405.  NULL
  406. };
  407. enum lvopts {
  408. LVNOWAIT
  409. };
  410. static char *lkops[] = {
  411. "get",
  412. "put",
  413. "put_all",
  414. "put_obj",
  415. "timeout",
  416.  NULL
  417. };
  418. enum lkops {
  419. LKGET,
  420. LKPUT,
  421. LKPUTALL,
  422. LKPUTOBJ,
  423. LKTIMEOUT
  424. };
  425. DB_LOCK *lock;
  426. DB_LOCKREQ list;
  427. DBT obj;
  428. Tcl_Obj **myobjv, *res, *thisop;
  429. void *otmp;
  430. u_int32_t flag, lockid;
  431. int freeobj, i, myobjc, optindex, result, ret;
  432. char *lockname, msg[MSG_SIZE], newname[MSG_SIZE];
  434. result = TCL_OK;
  435. memset(newname, 0, MSG_SIZE);
  436. flag = 0;
  437. freeobj = 0;
  439. /*
  440.  * If -nowait is given, it MUST be first arg.
  441.  */
  442. if (Tcl_GetIndexFromObj(interp, objv[2],
  443.     lvopts, "option", TCL_EXACT, &optindex) == TCL_OK) {
  444. switch ((enum lvopts)optindex) {
  445. case LVNOWAIT:
  446. flag |= DB_LOCK_NOWAIT;
  447. break;
  448. }
  449. i = 3;
  450. } else {
  451. if (IS_HELP(objv[2]) == TCL_OK)
  452. return (TCL_OK);
  453. Tcl_ResetResult(interp);
  454. i = 2;
  455. }
  457. /*
  458.  * Our next arg MUST be the locker ID.
  459.  */
  460. result = _GetUInt32(interp, objv[i++], &lockid);
  461. if (result != TCL_OK)
  462. return (result);
  464. /*
  465.  * All other remaining args are operation tuples.
  466.  * Go through sequentially to decode, execute and build
  467.  * up list of return values.
  468.  */
  469. res = Tcl_NewListObj(0, NULL);
  470. while (i < objc) {
  471. /*
  472.  * Get the list of the tuple.
  473.  */
  474. lock = NULL;
  475. result = Tcl_ListObjGetElements(interp, objv[i],
  476.     &myobjc, &myobjv);
  477. if (result == TCL_OK)
  478. i++;
  479. else
  480. break;
  481. /*
  482.  * First we will set up the list of requests.
  483.  * We will make a "second pass" after we get back
  484.  * the results from the lock_vec call to create
  485.  * the return list.
  486.  */
  487. if (Tcl_GetIndexFromObj(interp, myobjv[0],
  488.     lkops, "option", TCL_EXACT, &optindex) != TCL_OK) {
  489. result = IS_HELP(myobjv[0]);
  490. goto error;
  491. }
  492. switch ((enum lkops)optindex) {
  493. case LKGET:
  494. if (myobjc != 3) {
  495. Tcl_WrongNumArgs(interp, 1, myobjv,
  496.     "{get obj mode}");
  497. result = TCL_ERROR;
  498. goto error;
  499. }
  500. result = _LockMode(interp, myobjv[2], &list.mode);
  501. if (result != TCL_OK)
  502. goto error;
  503. ret = _CopyObjBytes(interp, myobjv[1], &otmp,
  504.     &obj.size, &freeobj);
  505. if (ret != 0) {
  506. result = _ReturnSetup(interp, ret,
  507.     DB_RETOK_STD(ret), "lock vec");
  508. return (result);
  509. }
  510. obj.data = otmp;
  511. ret = _GetThisLock(interp, envp, lockid, flag,
  512.     &obj, list.mode, newname);
  513. if (ret != 0) {
  514. result = _ReturnSetup(interp, ret,
  515.     DB_RETOK_STD(ret), "lock vec");
  516. thisop = Tcl_NewIntObj(ret);
  517. (void)Tcl_ListObjAppendElement(interp, res,
  518.     thisop);
  519. goto error;
  520. }
  521. thisop = Tcl_NewStringObj(newname, strlen(newname));
  522. (void)Tcl_ListObjAppendElement(interp, res, thisop);
  523. if (freeobj) {
  524. (void)__os_free(envp, otmp);
  525. freeobj = 0;
  526. }
  527. continue;
  528. case LKPUT:
  529. if (myobjc != 2) {
  530. Tcl_WrongNumArgs(interp, 1, myobjv,
  531.     "{put lock}");
  532. result = TCL_ERROR;
  533. goto error;
  534. }
  535. list.op = DB_LOCK_PUT;
  536. lockname = Tcl_GetStringFromObj(myobjv[1], NULL);
  537. lock = NAME_TO_LOCK(lockname);
  538. if (lock == NULL) {
  539. snprintf(msg, MSG_SIZE, "Invalid lock: %sn",
  540.     lockname);
  541. Tcl_SetResult(interp, msg, TCL_VOLATILE);
  542. result = TCL_ERROR;
  543. goto error;
  544. }
  545. list.lock = *lock;
  546. break;
  547. case LKPUTALL:
  548. if (myobjc != 1) {
  549. Tcl_WrongNumArgs(interp, 1, myobjv,
  550.     "{put_all}");
  551. result = TCL_ERROR;
  552. goto error;
  553. }
  554. list.op = DB_LOCK_PUT_ALL;
  555. break;
  556. case LKPUTOBJ:
  557. if (myobjc != 2) {
  558. Tcl_WrongNumArgs(interp, 1, myobjv,
  559.     "{put_obj obj}");
  560. result = TCL_ERROR;
  561. goto error;
  562. }
  563. list.op = DB_LOCK_PUT_OBJ;
  564. ret = _CopyObjBytes(interp, myobjv[1], &otmp,
  565.     &obj.size, &freeobj);
  566. if (ret != 0) {
  567. result = _ReturnSetup(interp, ret,
  568.     DB_RETOK_STD(ret), "lock vec");
  569. return (result);
  570. }
  571. obj.data = otmp;
  572. list.obj = &obj;
  573. break;
  574. case LKTIMEOUT:
  575. list.op = DB_LOCK_TIMEOUT;
  576. break;
  578. }
  579. /*
  580.  * We get here, we have set up our request, now call
  581.  * lock_vec.
  582.  */
  583. _debug_check();
  584. ret = envp->lock_vec(envp, lockid, flag, &list, 1, NULL);
  585. /*
  586.  * Now deal with whether or not the operation succeeded.
  587.  * Get's were done above, all these are only puts.
  588.  */
  589. thisop = Tcl_NewIntObj(ret);
  590. result = Tcl_ListObjAppendElement(interp, res, thisop);
  591. if (ret != 0 && result == TCL_OK)
  592. result = _ReturnSetup(interp, ret,
  593.     DB_RETOK_STD(ret), "lock put");
  594. if (freeobj) {
  595. (void)__os_free(envp, otmp);
  596. freeobj = 0;
  597. }
  598. /*
  599.  * We did a put of some kind.  Since we did that,
  600.  * we have to delete the commands associated with
  601.  * any of the locks we just put.
  602.  */
  603. _LockPutInfo(interp, list.op, lock, lockid, &obj);
  604. }
  606. if (result == TCL_OK && res)
  607. Tcl_SetObjResult(interp, res);
  608. error:
  609. return (result);
  610. }
  612. static int
  613. _LockMode(interp, obj, mode)
  614. Tcl_Interp *interp;
  615. Tcl_Obj *obj;
  616. db_lockmode_t *mode;
  617. {
  618. int optindex;
  620. if (Tcl_GetIndexFromObj(interp, obj, lkmode, "option",
  621.     TCL_EXACT, &optindex) != TCL_OK)
  622. return (IS_HELP(obj));
  623. switch ((enum lkmode)optindex) {
  624. case LK_NG:
  625. *mode = DB_LOCK_NG;
  626. break;
  627. case LK_READ:
  628. *mode = DB_LOCK_READ;
  629. break;
  630. case LK_WRITE:
  631. *mode = DB_LOCK_WRITE;
  632. break;
  633. case LK_IREAD:
  634. *mode = DB_LOCK_IREAD;
  635. break;
  636. case LK_IWRITE:
  637. *mode = DB_LOCK_IWRITE;
  638. break;
  639. case LK_IWR:
  640. *mode = DB_LOCK_IWR;
  641. break;
  642. }
  643. return (TCL_OK);
  644. }
  646. static void
  647. _LockPutInfo(interp, op, lock, lockid, objp)
  648. Tcl_Interp *interp;
  649. db_lockop_t op;
  650. DB_LOCK *lock;
  651. u_int32_t lockid;
  652. DBT *objp;
  653. {
  654. DBTCL_INFO *p, *nextp;
  655. int found;
  657. for (p = LIST_FIRST(&__db_infohead); p != NULL; p = nextp) {
  658. found = 0;
  659. nextp = LIST_NEXT(p, entries);
  660. if ((op == DB_LOCK_PUT && (p->i_lock == lock)) ||
  661.     (op == DB_LOCK_PUT_ALL && p->i_locker == lockid) ||
  662.     (op == DB_LOCK_PUT_OBJ && p->i_lockobj.data &&
  663. memcmp(p->i_lockobj.data, objp->data, objp->size) == 0))
  664. found = 1;
  665. if (found) {
  666. (void)Tcl_DeleteCommand(interp, p->i_name);
  667. __os_free(NULL, p->i_lock);
  668. _DeleteInfo(p);
  669. }
  670. }
  671. }
  673. static int
  674. _GetThisLock(interp, envp, lockid, flag, objp, mode, newname)
  675. Tcl_Interp *interp; /* Interpreter */
  676. DB_ENV *envp; /* Env handle */
  677. u_int32_t lockid; /* Locker ID */
  678. u_int32_t flag; /* Lock flag */
  679. DBT *objp; /* Object to lock */
  680. db_lockmode_t mode; /* Lock mode */
  681. char *newname; /* New command name */
  682. {
  683. DB_LOCK *lock;
  684. DBTCL_INFO *envip, *ip;
  685. int result, ret;
  687. result = TCL_OK;
  688. envip = _PtrToInfo((void *)envp);
  689. if (envip == NULL) {
  690. Tcl_SetResult(interp, "Could not find env infon", TCL_STATIC);
  691. return (TCL_ERROR);
  692. }
  693. snprintf(newname, MSG_SIZE, "%s.lock%d",
  694.     envip->i_name, envip->i_envlockid);
  695. ip = _NewInfo(interp, NULL, newname, I_LOCK);
  696. if (ip == NULL) {
  697. Tcl_SetResult(interp, "Could not set up info",
  698.     TCL_STATIC);
  699. return (TCL_ERROR);
  700. }
  701. ret = __os_malloc(envp, sizeof(DB_LOCK), &lock);
  702. if (ret != 0) {
  703. Tcl_SetResult(interp, db_strerror(ret), TCL_STATIC);
  704. return (TCL_ERROR);
  705. }
  706. _debug_check();
  707. ret = envp->lock_get(envp, lockid, flag, objp, mode, lock);
  708. result = _ReturnSetup(interp, ret, DB_RETOK_STD(ret), "lock get");
  709. if (result == TCL_ERROR) {
  710. __os_free(envp, lock);
  711. _DeleteInfo(ip);
  712. return (result);
  713. }
  714. /*
  715.  * Success.  Set up return.  Set up new info
  716.  * and command widget for this lock.
  717.  */
  718. ret = __os_malloc(envp, objp->size, &ip->i_lockobj.data);
  719. if (ret != 0) {
  720. Tcl_SetResult(interp, "Could not duplicate obj",
  721.     TCL_STATIC);
  722. (void)envp->lock_put(envp, lock);
  723. __os_free(envp, lock);
  724. _DeleteInfo(ip);
  725. result = TCL_ERROR;
  726. goto error;
  727. }
  728. memcpy(ip->i_lockobj.data, objp->data, objp->size);
  729. ip->i_lockobj.size = objp->size;
  730. envip->i_envlockid++;
  731. ip->i_parent = envip;
  732. ip->i_locker = lockid;
  733. _SetInfoData(ip, lock);
  734. Tcl_CreateObjCommand(interp, newname,
  735.     (Tcl_ObjCmdProc *)lock_Cmd, (ClientData)lock, NULL);
  736. error:
  737. return (result);
  738. }
  739. #endif