bt_recno.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:34k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1997-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  8. #ifndef lint
  9. static const char revid[] = "$Id: bt_recno.c,v 11.106 2002/08/16 04:56:30 ubell Exp $";
  10. #endif /* not lint */
  11. #ifndef NO_SYSTEM_INCLUDES
  12. #include <sys/types.h>
  13. #include <limits.h>
  14. #include <stdio.h>
  15. #include <string.h>
  16. #endif
  17. #include "db_int.h"
  18. #include "dbinc/db_page.h"
  19. #include "dbinc/btree.h"
  20. #include "dbinc/db_shash.h"
  21. #include "dbinc/lock.h"
  22. static int  __ram_add __P((DBC *, db_recno_t *, DBT *, u_int32_t, u_int32_t));
  23. static int  __ram_source __P((DB *));
  24. static int  __ram_sread __P((DBC *, db_recno_t));
  25. static int  __ram_update __P((DBC *, db_recno_t, int));
  26. /*
  27.  * In recno, there are two meanings to the on-page "deleted" flag.  If we're
  28.  * re-numbering records, it means the record was implicitly created.  We skip
  29.  * over implicitly created records if doing a cursor "next" or "prev", and
  30.  * return DB_KEYEMPTY if they're explicitly requested..  If not re-numbering
  31.  * records, it means that the record was implicitly created, or was deleted.
  32.  * We skip over implicitly created or deleted records if doing a cursor "next"
  33.  * or "prev", and return DB_KEYEMPTY if they're explicitly requested.
  34.  *
  35.  * If we're re-numbering records, then we have to detect in the cursor that
  36.  * a record was deleted, and adjust the cursor as necessary on the next get.
  37.  * If we're not re-numbering records, then we can detect that a record has
  38.  * been deleted by looking at the actual on-page record, so we completely
  39.  * ignore the cursor's delete flag.  This is different from the B+tree code.
  40.  * It also maintains whether the cursor references a deleted record in the
  41.  * cursor, and it doesn't always check the on-page value.
  42.  */
  43. #define CD_SET(cp) {
  44. if (F_ISSET(cp, C_RENUMBER))
  45. F_SET(cp, C_DELETED);
  46. }
  47. #define CD_CLR(cp) {
  48. if (F_ISSET(cp, C_RENUMBER)) {
  49. F_CLR(cp, C_DELETED);
  50. cp->order = INVALID_ORDER;
  51. }
  52. }
  53. #define CD_ISSET(cp)
  54. (F_ISSET(cp, C_RENUMBER) && F_ISSET(cp, C_DELETED))
  55. /*
  56.  * Macros for comparing the ordering of two cursors.
  57.  * cp1 comes before cp2 iff one of the following holds:
  58.  * cp1's recno is less than cp2's recno
  59.  * recnos are equal, both deleted, and cp1's order is less than cp2's
  60.  * recnos are equal, cp1 deleted, and cp2 not deleted
  61.  */
  62. #define C_LESSTHAN(cp1, cp2)
  63.     (((cp1)->recno < (cp2)->recno) ||
  64.     (((cp1)->recno == (cp2)->recno) &&
  65.     ((CD_ISSET((cp1)) && CD_ISSET((cp2)) && (cp1)->order < (cp2)->order) || 
  66.     (CD_ISSET((cp1)) && !CD_ISSET((cp2))))))
  67. /*
  68.  * cp1 is equal to cp2 iff their recnos and delete flags are identical,
  69.  * and if the delete flag is set their orders are also identical.
  70.  */
  71. #define C_EQUAL(cp1, cp2)
  72.     ((cp1)->recno == (cp2)->recno && CD_ISSET((cp1)) == CD_ISSET((cp2)) && 
  73.     (!CD_ISSET((cp1)) || (cp1)->order == (cp2)->order))
  74. /*
  75.  * Do we need to log the current cursor adjustment?
  76.  */
  77. #define CURADJ_LOG(dbc)
  78. (DBC_LOGGING((dbc)) && (dbc)->txn != NULL && (dbc)->txn->parent != NULL)
  79. /*
  80.  * After a search, copy the found page into the cursor, discarding any
  81.  * currently held lock.
  82.  */
  83. #define STACK_TO_CURSOR(cp) {
  84. (cp)->page = (cp)->csp->page;
  85. (cp)->pgno = (cp)->csp->page->pgno;
  86. (cp)->indx = (cp)->csp->indx;
  87. (void)__TLPUT(dbc, (cp)->lock);
  88. (cp)->lock = (cp)->csp->lock;
  89. (cp)->lock_mode = (cp)->csp->lock_mode;
  90. }
  91. /*
  92.  * __ram_open --
  93.  * Recno open function.
  94.  *
  95.  * PUBLIC: int __ram_open __P((DB *,
  96.  * PUBLIC:      DB_TXN *, const char *, db_pgno_t, u_int32_t));
  97.  */
  98. int
  99. __ram_open(dbp, txn, name, base_pgno, flags)
  100. DB *dbp;
  101. DB_TXN *txn;
  102. const char *name;
  103. db_pgno_t base_pgno;
  104. u_int32_t flags;
  105. {
  106. BTREE *t;
  107. DBC *dbc;
  108. int ret, t_ret;
  109. COMPQUIET(name, NULL);
  110. t = dbp->bt_internal;
  111. /* Initialize the remaining fields/methods of the DB. */
  112. dbp->stat = __bam_stat;
  113. /* Start up the tree. */
  114. if ((ret = __bam_read_root(dbp, txn, base_pgno, flags)) != 0)
  115. return (ret);
  116. /*
  117.  * If the user specified a source tree, open it and map it in.
  118.  *
  119.  * !!!
  120.  * We don't complain if the user specified transactions or threads.
  121.  * It's possible to make it work, but you'd better know what you're
  122.  * doing!
  123.  */
  124. if (t->re_source != NULL && (ret = __ram_source(dbp)) != 0)
  125. return (ret);
  126. /* If we're snapshotting an underlying source file, do it now. */
  127. if (F_ISSET(dbp, DB_AM_SNAPSHOT)) {
  128. /* Allocate a cursor. */
  129. if ((ret = dbp->cursor(dbp, NULL, &dbc, 0)) != 0)
  130. return (ret);
  131. /* Do the snapshot. */
  132. if ((ret = __ram_update(dbc,
  133.     DB_MAX_RECORDS, 0)) != 0 && ret == DB_NOTFOUND)
  134. ret = 0;
  135. /* Discard the cursor. */
  136. if ((t_ret = dbc->c_close(dbc)) != 0 && ret == 0)
  137. ret = t_ret;
  138. }
  139. return (ret);
  140. }
  141. /*
  142.  * __ram_append --
  143.  * Recno append function.
  144.  *
  145.  * PUBLIC: int __ram_append __P((DBC *, DBT *, DBT *));
  146.  */
  147. int
  148. __ram_append(dbc, key, data)
  149. DBC *dbc;
  150. DBT *key, *data;
  151. {
  152. BTREE_CURSOR *cp;
  153. int ret;
  154. cp = (BTREE_CURSOR *)dbc->internal;
  155. /*
  156.  * Make sure we've read in all of the backing source file.  If
  157.  * we found the record or it simply didn't exist, add the
  158.  * user's record.
  159.  */
  160. ret = __ram_update(dbc, DB_MAX_RECORDS, 0);
  161. if (ret == 0 || ret == DB_NOTFOUND)
  162. ret = __ram_add(dbc, &cp->recno, data, DB_APPEND, 0);
  163. /* Return the record number. */
  164. if (ret == 0)
  165. ret = __db_retcopy(dbc->dbp->dbenv, key, &cp->recno,
  166.     sizeof(cp->recno), &dbc->rkey->data, &dbc->rkey->ulen);
  167. return (ret);
  168. }
  169. /*
  170.  * __ram_c_del --
  171.  * Recno cursor->c_del function.
  172.  *
  173.  * PUBLIC: int __ram_c_del __P((DBC *));
  174.  */
  175. int
  176. __ram_c_del(dbc)
  177. DBC *dbc;
  178. {
  179. BKEYDATA bk;
  180. BTREE *t;
  181. BTREE_CURSOR *cp;
  182. DB *dbp;
  183. DB_LSN lsn;
  184. DBT hdr, data;
  185. EPG *epg;
  186. int exact, ret, stack;
  187. dbp = dbc->dbp;
  188. cp = (BTREE_CURSOR *)dbc->internal;
  189. t = dbp->bt_internal;
  190. stack = 0;
  191. /*
  192.  * The semantics of cursors during delete are as follows: in
  193.  * non-renumbering recnos, records are replaced with a marker
  194.  * containing a delete flag.  If the record referenced by this cursor
  195.  * has already been deleted, we will detect that as part of the delete
  196.  * operation, and fail.
  197.  *
  198.  * In renumbering recnos, cursors which represent deleted items
  199.  * are flagged with the C_DELETED flag, and it is an error to
  200.  * call c_del a second time without an intervening cursor motion.
  201.  */
  202. if (CD_ISSET(cp))
  203. return (DB_KEYEMPTY);
  204. /* Search the tree for the key; delete only deletes exact matches. */
  205. if ((ret = __bam_rsearch(dbc, &cp->recno, S_DELETE, 1, &exact)) != 0)
  206. goto err;
  207. if (!exact) {
  208. ret = DB_NOTFOUND;
  209. goto err;
  210. }
  211. stack = 1;
  212. /* Copy the page into the cursor. */
  213. STACK_TO_CURSOR(cp);
  214. /*
  215.  * If re-numbering records, the on-page deleted flag can only mean
  216.  * that this record was implicitly created.  Applications aren't
  217.  * permitted to delete records they never created, return an error.
  218.  *
  219.  * If not re-numbering records, the on-page deleted flag means that
  220.  * this record was implicitly created, or, was deleted at some time.
  221.  * The former is an error because applications aren't permitted to
  222.  * delete records they never created, the latter is an error because
  223.  * if the record was "deleted", we could never have found it.
  224.  */
  225. if (B_DISSET(GET_BKEYDATA(dbp, cp->page, cp->indx)->type)) {
  226. ret = DB_KEYEMPTY;
  227. goto err;
  228. }
  229. if (F_ISSET(cp, C_RENUMBER)) {
  230. /* Delete the item, adjust the counts, adjust the cursors. */
  231. if ((ret = __bam_ditem(dbc, cp->page, cp->indx)) != 0)
  232. goto err;
  233. __bam_adjust(dbc, -1);
  234. if (__ram_ca(dbc, CA_DELETE) > 0 &&
  235.     CURADJ_LOG(dbc) && (ret = __bam_rcuradj_log(dbp, dbc->txn,
  236.     &lsn, 0, CA_DELETE, cp->root, cp->recno, cp->order)) != 0)
  237. goto err;
  238. /*
  239.  * If the page is empty, delete it.
  240.  *
  241.  * We never delete a root page.  First, root pages of primary
  242.  * databases never go away, recno or otherwise.  However, if
  243.  * it's the root page of an off-page duplicates database, then
  244.  * it can be deleted.   We don't delete it here because we have
  245.  * no way of telling the primary database page holder (e.g.,
  246.  * the hash access method) that its page element should cleaned
  247.  * up because the underlying tree is gone.  So, we keep the page
  248.  * around until the last cursor referencing the empty tree is
  249.  * are closed, and then clean it up.
  250.  */
  251. if (NUM_ENT(cp->page) == 0 && PGNO(cp->page) != cp->root) {
  252. /*
  253.  * We already have a locked stack of pages.  However,
  254.  * there are likely entries in the stack that aren't
  255.  * going to be emptied by removing the single reference
  256.  * to the emptied page (or one of its parents).
  257.  */
  258. for (epg = cp->csp; epg >= cp->sp; --epg)
  259. if (NUM_ENT(epg->page) > 1)
  260. break;
  261. /*
  262.  * We want to delete a single item out of the last page
  263.  * that we're not deleting.
  264.  */
  265. ret = __bam_dpages(dbc, epg);
  266. /*
  267.  * Regardless of the return from __bam_dpages, it will
  268.  * discard our stack and pinned page.
  269.  */
  270. stack = 0;
  271. cp->page = NULL;
  272. }
  273. } else {
  274. /* Use a delete/put pair to replace the record with a marker. */
  275. if ((ret = __bam_ditem(dbc, cp->page, cp->indx)) != 0)
  276. goto err;
  277. B_TSET(bk.type, B_KEYDATA, 1);
  278. bk.len = 0;
  279. memset(&hdr, 0, sizeof(hdr));
  280. hdr.data = &bk;
  281. hdr.size = SSZA(BKEYDATA, data);
  282. memset(&data, 0, sizeof(data));
  283. data.data = (void *)"";
  284. data.size = 0;
  285. if ((ret = __db_pitem(dbc,
  286.     cp->page, cp->indx, BKEYDATA_SIZE(0), &hdr, &data)) != 0)
  287. goto err;
  288. }
  289. t->re_modified = 1;
  290. err: if (stack)
  291. __bam_stkrel(dbc, STK_CLRDBC);
  292. return (ret);
  293. }
  294. /*
  295.  * __ram_c_get --
  296.  * Recno cursor->c_get function.
  297.  *
  298.  * PUBLIC: int __ram_c_get
  299.  * PUBLIC:     __P((DBC *, DBT *, DBT *, u_int32_t, db_pgno_t *));
  300.  */
  301. int
  302. __ram_c_get(dbc, key, data, flags, pgnop)
  303. DBC *dbc;
  304. DBT *key, *data;
  305. u_int32_t flags;
  306. db_pgno_t *pgnop;
  307. {
  308. BTREE_CURSOR *cp;
  309. DB *dbp;
  310. int cmp, exact, ret;
  311. COMPQUIET(pgnop, NULL);
  312. dbp = dbc->dbp;
  313. cp = (BTREE_CURSOR *)dbc->internal;
  314. LF_CLR(DB_MULTIPLE|DB_MULTIPLE_KEY);
  315. retry: switch (flags) {
  316. case DB_CURRENT:
  317. /*
  318.  * If we're using mutable records and the deleted flag is
  319.  * set, the cursor is pointing at a nonexistent record;
  320.  * return an error.
  321.  */
  322. if (CD_ISSET(cp))
  323. return (DB_KEYEMPTY);
  324. break;
  325. case DB_NEXT_DUP:
  326. /*
  327.  * If we're not in an off-page dup set, we know there's no
  328.  * next duplicate since recnos don't have them.  If we
  329.  * are in an off-page dup set, the next item assuredly is
  330.  * a dup, so we set flags to DB_NEXT and keep going.
  331.  */
  332. if (!F_ISSET(dbc, DBC_OPD))
  333. return (DB_NOTFOUND);
  334. /* FALLTHROUGH */
  335. case DB_NEXT_NODUP:
  336. /*
  337.  * Recno databases don't have duplicates, set flags to DB_NEXT
  338.  * and keep going.
  339.  */
  340. /* FALLTHROUGH */
  341. case DB_NEXT:
  342. flags = DB_NEXT;
  343. /*
  344.  * If record numbers are mutable: if we just deleted a record,
  345.  * we have to avoid incrementing the record number so that we
  346.  * return the right record by virtue of renumbering the tree.
  347.  */
  348. if (CD_ISSET(cp))
  349. break;
  350. if (cp->recno != RECNO_OOB) {
  351. ++cp->recno;
  352. break;
  353. }
  354. /* FALLTHROUGH */
  355. case DB_FIRST:
  356. flags = DB_NEXT;
  357. cp->recno = 1;
  358. break;
  359. case DB_PREV_NODUP:
  360. /*
  361.  * Recno databases don't have duplicates, set flags to DB_PREV
  362.  * and keep going.
  363.  */
  364. /* FALLTHROUGH */
  365. case DB_PREV:
  366. flags = DB_PREV;
  367. if (cp->recno != RECNO_OOB) {
  368. if (cp->recno == 1) {
  369. ret = DB_NOTFOUND;
  370. goto err;
  371. }
  372. --cp->recno;
  373. break;
  374. }
  375. /* FALLTHROUGH */
  376. case DB_LAST:
  377. flags = DB_PREV;
  378. if (((ret = __ram_update(dbc,
  379.     DB_MAX_RECORDS, 0)) != 0) && ret != DB_NOTFOUND)
  380. goto err;
  381. if ((ret = __bam_nrecs(dbc, &cp->recno)) != 0)
  382. goto err;
  383. if (cp->recno == 0) {
  384. ret = DB_NOTFOUND;
  385. goto err;
  386. }
  387. break;
  388. case DB_GET_BOTHC:
  389. /*
  390.  * If we're doing a join and these are offpage dups,
  391.  * we want to keep searching forward from after the
  392.  * current cursor position.  Increment the recno by 1,
  393.  * then proceed as for a DB_SET.
  394.  *
  395.  * Otherwise, we know there are no additional matching
  396.  * data, as recnos don't have dups.  return DB_NOTFOUND.
  397.  */
  398. if (F_ISSET(dbc, DBC_OPD)) {
  399. cp->recno++;
  400. break;
  401. }
  402. ret = DB_NOTFOUND;
  403. goto err;
  404. /* NOTREACHED */
  405. case DB_GET_BOTH:
  406. case DB_GET_BOTH_RANGE:
  407. /*
  408.  * If we're searching a set of off-page dups, we start
  409.  * a new linear search from the first record.  Otherwise,
  410.  * we compare the single data item associated with the
  411.  * requested record for a match.
  412.  */
  413. if (F_ISSET(dbc, DBC_OPD)) {
  414. cp->recno = 1;
  415. break;
  416. }
  417. /* FALLTHROUGH */
  418. case DB_SET:
  419. case DB_SET_RANGE:
  420. if ((ret = __ram_getno(dbc, key, &cp->recno, 0)) != 0)
  421. goto err;
  422. break;
  423. default:
  424. ret = __db_unknown_flag(dbp->dbenv, "__ram_c_get", flags);
  425. goto err;
  426. }
  427. /*
  428.  * For DB_PREV, DB_LAST, DB_SET and DB_SET_RANGE, we have already
  429.  * called __ram_update() to make sure sufficient records have been
  430.  * read from the backing source file.  Do it now for DB_CURRENT (if
  431.  * the current record was deleted we may need more records from the
  432.  * backing file for a DB_CURRENT operation), DB_FIRST and DB_NEXT.
  433.  * (We don't have to test for flags == DB_FIRST, because the switch
  434.  * statement above re-set flags to DB_NEXT in that case.)
  435.  */
  436. if ((flags == DB_NEXT || flags == DB_CURRENT) && ((ret =
  437.     __ram_update(dbc, cp->recno, 0)) != 0) && ret != DB_NOTFOUND)
  438. goto err;
  439. for (;; ++cp->recno) {
  440. /* Search the tree for the record. */
  441. if ((ret = __bam_rsearch(dbc, &cp->recno,
  442.     F_ISSET(dbc, DBC_RMW) ? S_FIND_WR : S_FIND,
  443.     1, &exact)) != 0)
  444. goto err;
  445. if (!exact) {
  446. ret = DB_NOTFOUND;
  447. goto err;
  448. }
  449. /* Copy the page into the cursor. */
  450. STACK_TO_CURSOR(cp);
  451. /*
  452.  * If re-numbering records, the on-page deleted flag means this
  453.  * record was implicitly created.  If not re-numbering records,
  454.  * the on-page deleted flag means this record was implicitly
  455.  * created, or, it was deleted at some time.  Regardless, we
  456.  * skip such records if doing cursor next/prev operations or
  457.  * walking through off-page duplicates, and fail if they were
  458.  * requested explicitly by the application.
  459.  */
  460. if (B_DISSET(GET_BKEYDATA(dbp, cp->page, cp->indx)->type))
  461. switch (flags) {
  462. case DB_NEXT:
  463. case DB_PREV:
  464. (void)__bam_stkrel(dbc, STK_CLRDBC);
  465. goto retry;
  466. case DB_GET_BOTH:
  467. case DB_GET_BOTH_RANGE:
  468. /*
  469.  * If we're an OPD tree, we don't care about
  470.  * matching a record number on a DB_GET_BOTH
  471.  * -- everything belongs to the same tree.  A
  472.  * normal recno should give up and return
  473.  * DB_NOTFOUND if the matching recno is deleted.
  474.  */
  475. if (F_ISSET(dbc, DBC_OPD)) {
  476. (void)__bam_stkrel(dbc, STK_CLRDBC);
  477. continue;
  478. }
  479. ret = DB_NOTFOUND;
  480. goto err;
  481. default:
  482. ret = DB_KEYEMPTY;
  483. goto err;
  484. }
  485. if (flags == DB_GET_BOTH ||
  486.     flags == DB_GET_BOTHC || flags == DB_GET_BOTH_RANGE) {
  487. if ((ret = __bam_cmp(dbp, data,
  488.     cp->page, cp->indx, __bam_defcmp, &cmp)) != 0)
  489. return (ret);
  490. if (cmp == 0)
  491. break;
  492. if (!F_ISSET(dbc, DBC_OPD)) {
  493. ret = DB_NOTFOUND;
  494. goto err;
  495. }
  496. (void)__bam_stkrel(dbc, STK_CLRDBC);
  497. } else
  498. break;
  499. }
  500. /* Return the key if the user didn't give us one. */
  501. if (!F_ISSET(dbc, DBC_OPD)) {
  502. if (flags != DB_GET_BOTH && flags != DB_GET_BOTH_RANGE &&
  503.     flags != DB_SET && flags != DB_SET_RANGE)
  504. ret = __db_retcopy(dbp->dbenv,
  505.     key, &cp->recno, sizeof(cp->recno),
  506.     &dbc->rkey->data, &dbc->rkey->ulen);
  507. F_SET(key, DB_DBT_ISSET);
  508. }
  509. /* The cursor was reset, no further delete adjustment is necessary. */
  510. err: CD_CLR(cp);
  511. return (ret);
  512. }
  513. /*
  514.  * __ram_c_put --
  515.  * Recno cursor->c_put function.
  516.  *
  517.  * PUBLIC: int __ram_c_put __P((DBC *, DBT *, DBT *, u_int32_t, db_pgno_t *));
  518.  */
  519. int
  520. __ram_c_put(dbc, key, data, flags, pgnop)
  521. DBC *dbc;
  522. DBT *key, *data;
  523. u_int32_t flags;
  524. db_pgno_t *pgnop;
  525. {
  526. BTREE_CURSOR *cp;
  527. DB *dbp;
  528. DB_LSN lsn;
  529. int exact, nc, ret, t_ret;
  530. u_int32_t iiflags;
  531. void *arg;
  532. COMPQUIET(pgnop, NULL);
  533. dbp = dbc->dbp;
  534. cp = (BTREE_CURSOR *)dbc->internal;
  535. /*
  536.  * DB_KEYFIRST and DB_KEYLAST mean different things if they're
  537.  * used in an off-page duplicate tree.  If we're an off-page
  538.  * duplicate tree, they really mean "put at the beginning of the
  539.  * tree" and "put at the end of the tree" respectively, so translate
  540.  * them to something else.
  541.  */
  542. if (F_ISSET(dbc, DBC_OPD))
  543. switch (flags) {
  544. case DB_KEYFIRST:
  545. cp->recno = 1;
  546. flags = DB_BEFORE;
  547. break;
  548. case DB_KEYLAST:
  549. if ((ret = __ram_add(dbc,
  550.     &cp->recno, data, DB_APPEND, 0)) != 0)
  551. return (ret);
  552. if (CURADJ_LOG(dbc) &&
  553.     (ret = __bam_rcuradj_log(dbp, dbc->txn, &lsn, 0,
  554.     CA_ICURRENT, cp->root, cp->recno, cp->order)))
  555. return (ret);
  556. return (0);
  557. }
  558. /*
  559.  * Handle normal DB_KEYFIRST/DB_KEYLAST;  for a recno, which has
  560.  * no duplicates, these are identical and mean "put the given
  561.  * datum at the given recno".
  562.  *
  563.  * Note that the code here used to be in __ram_put;  now, we
  564.  * go through the access-method-common __db_put function, which
  565.  * handles DB_NOOVERWRITE, so we and __ram_add don't have to.
  566.  */
  567. if (flags == DB_KEYFIRST || flags == DB_KEYLAST) {
  568. ret = __ram_getno(dbc, key, &cp->recno, 1);
  569. if (ret == 0 || ret == DB_NOTFOUND)
  570. ret = __ram_add(dbc, &cp->recno, data, 0, 0);
  571. return (ret);
  572. }
  573. /*
  574.  * If we're putting with a cursor that's marked C_DELETED, we need to
  575.  * take special care;  the cursor doesn't "really" reference the item
  576.  * corresponding to its current recno, but instead is "between" that
  577.  * record and the current one.  Translate the actual insert into
  578.  * DB_BEFORE, and let the __ram_ca work out the gory details of what
  579.  * should wind up pointing where.
  580.  */
  581. if (CD_ISSET(cp))
  582. iiflags = DB_BEFORE;
  583. else
  584. iiflags = flags;
  585. split: if ((ret = __bam_rsearch(dbc, &cp->recno, S_INSERT, 1, &exact)) != 0)
  586. goto err;
  587. /*
  588.  * An inexact match is okay;  it just means we're one record past the
  589.  * end, which is reasonable if we're marked deleted.
  590.  */
  591. DB_ASSERT(exact || CD_ISSET(cp));
  592. /* Copy the page into the cursor. */
  593. STACK_TO_CURSOR(cp);
  594. ret = __bam_iitem(dbc, key, data, iiflags, 0);
  595. t_ret = __bam_stkrel(dbc, STK_CLRDBC);
  596. if (t_ret != 0 && (ret == 0 || ret == DB_NEEDSPLIT))
  597. ret = t_ret;
  598. else if (ret == DB_NEEDSPLIT) {
  599. arg = &cp->recno;
  600. if ((ret = __bam_split(dbc, arg, NULL)) != 0)
  601. goto err;
  602. goto split;
  603. }
  604. if (ret != 0)
  605. goto err;
  606. switch (flags) { /* Adjust the cursors. */
  607. case DB_AFTER:
  608. nc = __ram_ca(dbc, CA_IAFTER);
  609. /*
  610.  * We only need to adjust this cursor forward if we truly added
  611.  * the item after the current recno, rather than remapping it
  612.  * to DB_BEFORE.
  613.  */
  614. if (iiflags == DB_AFTER)
  615. ++cp->recno;
  616. /* Only log if __ram_ca found any relevant cursors. */
  617. if (nc > 0 && CURADJ_LOG(dbc) &&
  618.     (ret = __bam_rcuradj_log(dbp, dbc->txn, &lsn, 0, CA_IAFTER,
  619.     cp->root, cp->recno, cp->order)) != 0)
  620. goto err;
  621. break;
  622. case DB_BEFORE:
  623. nc = __ram_ca(dbc, CA_IBEFORE);
  624. --cp->recno;
  625. /* Only log if __ram_ca found any relevant cursors. */
  626. if (nc > 0 && CURADJ_LOG(dbc) &&
  627.     (ret = __bam_rcuradj_log(dbp, dbc->txn, &lsn, 0, CA_IBEFORE,
  628.     cp->root, cp->recno, cp->order)) != 0)
  629. goto err;
  630. break;
  631. case DB_CURRENT:
  632. /*
  633.  * We only need to do an adjustment if we actually
  634.  * added an item, which we only would have done if the
  635.  * cursor was marked deleted.
  636.  *
  637.  * Only log if __ram_ca found any relevant cursors.
  638.  */
  639. if (CD_ISSET(cp) && __ram_ca(dbc, CA_ICURRENT) > 0 &&
  640.     CURADJ_LOG(dbc) &&
  641.     (ret = __bam_rcuradj_log(dbp, dbc->txn, &lsn, 0,
  642.     CA_ICURRENT, cp->root, cp->recno, cp->order)) != 0)
  643. goto err;
  644. break;
  645. }
  646. /* Return the key if we've created a new record. */
  647. if (!F_ISSET(dbc, DBC_OPD) && (flags == DB_AFTER || flags == DB_BEFORE))
  648. ret = __db_retcopy(dbp->dbenv, key, &cp->recno,
  649.     sizeof(cp->recno), &dbc->rkey->data, &dbc->rkey->ulen);
  650. /* The cursor was reset, no further delete adjustment is necessary. */
  651. err: CD_CLR(cp);
  652. return (ret);
  653. }
  654. /*
  655.  * __ram_ca --
  656.  * Adjust cursors.  Returns the number of relevant cursors.
  657.  *
  658.  * PUBLIC: int __ram_ca __P((DBC *, ca_recno_arg));
  659.  */
  660. int
  661. __ram_ca(dbc_arg, op)
  662. DBC *dbc_arg;
  663. ca_recno_arg op;
  664. {
  665. BTREE_CURSOR *cp, *cp_arg;
  666. DB *dbp, *ldbp;
  667. DB_ENV *dbenv;
  668. DBC *dbc;
  669. db_recno_t recno;
  670. int adjusted, found;
  671. u_int32_t order;
  672. dbp = dbc_arg->dbp;
  673. dbenv = dbp->dbenv;
  674. cp_arg = (BTREE_CURSOR *)dbc_arg->internal;
  675. recno = cp_arg->recno;
  676. found = 0;
  677. /*
  678.  * It only makes sense to adjust cursors if we're a renumbering
  679.  * recno;  we should only be called if this is one.
  680.  */
  681. DB_ASSERT(F_ISSET(cp_arg, C_RENUMBER));
  682. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  683. /*
  684.  * Adjust the cursors.  See the comment in __bam_ca_delete().
  685.  */
  686. /*
  687.  * If we're doing a delete, we need to find the highest
  688.  * order of any cursor currently pointing at this item,
  689.  * so we can assign a higher order to the newly deleted
  690.  * cursor.  Unfortunately, this requires a second pass through
  691.  * the cursor list.
  692.  */
  693. if (op == CA_DELETE) {
  694. order = 1;
  695. for (ldbp = __dblist_get(dbenv, dbp->adj_fileid);
  696.     ldbp != NULL && ldbp->adj_fileid == dbp->adj_fileid;
  697.     ldbp = LIST_NEXT(ldbp, dblistlinks)) {
  698. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  699. for (dbc = TAILQ_FIRST(&ldbp->active_queue);
  700.     dbc != NULL; dbc = TAILQ_NEXT(dbc, links)) {
  701. cp = (BTREE_CURSOR *)dbc->internal;
  702. if (cp_arg->root == cp->root &&
  703.     recno == cp->recno && CD_ISSET(cp) &&
  704.     order <= cp->order)
  705. order = cp->order + 1;
  706. }
  707. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  708. }
  709. } else
  710. order = INVALID_ORDER;
  711. /* Now go through and do the actual adjustments. */
  712. for (ldbp = __dblist_get(dbenv, dbp->adj_fileid);
  713.     ldbp != NULL && ldbp->adj_fileid == dbp->adj_fileid;
  714.     ldbp = LIST_NEXT(ldbp, dblistlinks)) {
  715. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  716. for (dbc = TAILQ_FIRST(&ldbp->active_queue);
  717.     dbc != NULL; dbc = TAILQ_NEXT(dbc, links)) {
  718. cp = (BTREE_CURSOR *)dbc->internal;
  719. if (cp_arg->root != cp->root)
  720. continue;
  721. ++found;
  722. adjusted = 0;
  723. switch (op) {
  724. case CA_DELETE:
  725. if (recno < cp->recno) {
  726. --cp->recno;
  727. /*
  728.  * If the adjustment made them equal,
  729.  * we have to merge the orders.
  730.  */
  731. if (recno == cp->recno && CD_ISSET(cp))
  732. cp->order += order;
  733. } else if (recno == cp->recno &&
  734.     !CD_ISSET(cp)) {
  735. CD_SET(cp);
  736. cp->order = order;
  737. }
  738. break;
  739. case CA_IBEFORE:
  740. /*
  741.  * IBEFORE is just like IAFTER, except that we
  742.  * adjust cursors on the current record too.
  743.  */
  744. if (C_EQUAL(cp_arg, cp)) {
  745. ++cp->recno;
  746. adjusted = 1;
  747. }
  748. goto iafter;
  749. case CA_ICURRENT:
  750. /*
  751.  * If the original cursor wasn't deleted, we
  752.  * just did a replacement and so there's no
  753.  * need to adjust anything--we shouldn't have
  754.  * gotten this far.  Otherwise, we behave
  755.  * much like an IAFTER, except that all
  756.  * cursors pointing to the current item get
  757.  * marked undeleted and point to the new
  758.  * item.
  759.  */
  760. DB_ASSERT(CD_ISSET(cp_arg));
  761. if (C_EQUAL(cp_arg, cp)) {
  762. CD_CLR(cp);
  763. break;
  764. }
  765. /* FALLTHROUGH */
  766. case CA_IAFTER:
  767. iafter: if (!adjusted && C_LESSTHAN(cp_arg, cp)) {
  768. ++cp->recno;
  769. adjusted = 1;
  770. }
  771. if (recno == cp->recno && adjusted)
  772. /*
  773.  * If we've moved this cursor's recno,
  774.  * split its order number--i.e.,
  775.  * decrement it by enough so that
  776.  * the lowest cursor moved has order 1.
  777.  * cp_arg->order is the split point,
  778.  * so decrement by one less than that.
  779.  */
  780. cp->order -= (cp_arg->order - 1);
  781. break;
  782. }
  783. }
  784. MUTEX_THREAD_UNLOCK(dbp->dbenv, dbp->mutexp);
  785. }
  786. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  787. return (found);
  788. }
  789. /*
  790.  * __ram_getno --
  791.  * Check the user's record number, and make sure we've seen it.
  792.  *
  793.  * PUBLIC: int __ram_getno __P((DBC *, const DBT *, db_recno_t *, int));
  794.  */
  795. int
  796. __ram_getno(dbc, key, rep, can_create)
  797. DBC *dbc;
  798. const DBT *key;
  799. db_recno_t *rep;
  800. int can_create;
  801. {
  802. DB *dbp;
  803. db_recno_t recno;
  804. dbp = dbc->dbp;
  805. /* Check the user's record number. */
  806. if ((recno = *(db_recno_t *)key->data) == 0) {
  807. __db_err(dbp->dbenv, "illegal record number of 0");
  808. return (EINVAL);
  809. }
  810. if (rep != NULL)
  811. *rep = recno;
  812. /*
  813.  * Btree can neither create records nor read them in.  Recno can
  814.  * do both, see if we can find the record.
  815.  */
  816. return (dbc->dbtype == DB_RECNO ?
  817.     __ram_update(dbc, recno, can_create) : 0);
  818. }
  819. /*
  820.  * __ram_update --
  821.  * Ensure the tree has records up to and including the specified one.
  822.  */
  823. static int
  824. __ram_update(dbc, recno, can_create)
  825. DBC *dbc;
  826. db_recno_t recno;
  827. int can_create;
  828. {
  829. BTREE *t;
  830. DB *dbp;
  831. DBT *rdata;
  832. db_recno_t nrecs;
  833. int ret;
  834. dbp = dbc->dbp;
  835. t = dbp->bt_internal;
  836. /*
  837.  * If we can't create records and we've read the entire backing input
  838.  * file, we're done.
  839.  */
  840. if (!can_create && t->re_eof)
  841. return (0);
  842. /*
  843.  * If we haven't seen this record yet, try to get it from the original
  844.  * file.
  845.  */
  846. if ((ret = __bam_nrecs(dbc, &nrecs)) != 0)
  847. return (ret);
  848. if (!t->re_eof && recno > nrecs) {
  849. if ((ret = __ram_sread(dbc, recno)) != 0 && ret != DB_NOTFOUND)
  850. return (ret);
  851. if ((ret = __bam_nrecs(dbc, &nrecs)) != 0)
  852. return (ret);
  853. }
  854. /*
  855.  * If we can create records, create empty ones up to the requested
  856.  * record.
  857.  */
  858. if (!can_create || recno <= nrecs + 1)
  859. return (0);
  860. rdata = &dbc->my_rdata;
  861. rdata->flags = 0;
  862. rdata->size = 0;
  863. while (recno > ++nrecs)
  864. if ((ret = __ram_add(dbc,
  865.     &nrecs, rdata, 0, BI_DELETED)) != 0)
  866. return (ret);
  867. return (0);
  868. }
  869. /*
  870.  * __ram_source --
  871.  * Load information about the backing file.
  872.  */
  873. static int
  874. __ram_source(dbp)
  875. DB *dbp;
  876. {
  877. BTREE *t;
  878. char *source;
  879. int ret;
  880. t = dbp->bt_internal;
  881. /* Find the real name, and swap out the one we had before. */
  882. if ((ret = __db_appname(dbp->dbenv,
  883.     DB_APP_DATA, t->re_source, 0, NULL, &source)) != 0)
  884. return (ret);
  885. __os_free(dbp->dbenv, t->re_source);
  886. t->re_source = source;
  887. /*
  888.  * !!!
  889.  * It's possible that the backing source file is read-only.  We don't
  890.  * much care other than we'll complain if there are any modifications
  891.  * when it comes time to write the database back to the source.
  892.  */
  893. if ((t->re_fp = fopen(t->re_source, "r")) == NULL) {
  894. ret = errno;
  895. __db_err(dbp->dbenv, "%s: %s", t->re_source, db_strerror(ret));
  896. return (ret);
  897. }
  898. t->re_eof = 0;
  899. return (0);
  900. }
  901. /*
  902.  * __ram_writeback --
  903.  * Rewrite the backing file.
  904.  *
  905.  * PUBLIC: int __ram_writeback __P((DB *));
  906.  */
  907. int
  908. __ram_writeback(dbp)
  909. DB *dbp;
  910. {
  911. BTREE *t;
  912. DB_ENV *dbenv;
  913. DBC *dbc;
  914. DBT key, data;
  915. FILE *fp;
  916. db_recno_t keyno;
  917. int ret, t_ret;
  918. u_int8_t delim, *pad;
  919. t = dbp->bt_internal;
  920. dbenv = dbp->dbenv;
  921. fp = NULL;
  922. pad = NULL;
  923. /* If the file wasn't modified, we're done. */
  924. if (!t->re_modified)
  925. return (0);
  926. /* If there's no backing source file, we're done. */
  927. if (t->re_source == NULL) {
  928. t->re_modified = 0;
  929. return (0);
  930. }
  931. /* Allocate a cursor. */
  932. if ((ret = dbp->cursor(dbp, NULL, &dbc, 0)) != 0)
  933. return (ret);
  934. /*
  935.  * Read any remaining records into the tree.
  936.  *
  937.  * !!!
  938.  * This is why we can't support transactions when applications specify
  939.  * backing (re_source) files.  At this point we have to read in the
  940.  * rest of the records from the file so that we can write all of the
  941.  * records back out again, which could modify a page for which we'd
  942.  * have to log changes and which we don't have locked.  This could be
  943.  * partially fixed by taking a snapshot of the entire file during the
  944.  * DB->open as DB->open is transaction protected.  But, if a checkpoint
  945.  * occurs then, the part of the log holding the copy of the file could
  946.  * be discarded, and that would make it impossible to recover in the
  947.  * face of disaster.  This could all probably be fixed, but it would
  948.  * require transaction protecting the backing source file.
  949.  *
  950.  * XXX
  951.  * This could be made to work now that we have transactions protecting
  952.  * file operations.  Margo has specifically asked for the privilege of
  953.  * doing this work.
  954.  */
  955. if ((ret =
  956.     __ram_update(dbc, DB_MAX_RECORDS, 0)) != 0 && ret != DB_NOTFOUND)
  957. return (ret);
  958. /*
  959.  * Close any existing file handle and re-open the file, truncating it.
  960.  */
  961. if (t->re_fp != NULL) {
  962. if (fclose(t->re_fp) != 0) {
  963. ret = errno;
  964. goto err;
  965. }
  966. t->re_fp = NULL;
  967. }
  968. if ((fp = fopen(t->re_source, "w")) == NULL) {
  969. ret = errno;
  970. __db_err(dbenv, "%s: %s", t->re_source, db_strerror(ret));
  971. goto err;
  972. }
  973. /*
  974.  * We step through the records, writing each one out.  Use the record
  975.  * number and the dbp->get() function, instead of a cursor, so we find
  976.  * and write out "deleted" or non-existent records.  The DB handle may
  977.  * be threaded, so allocate memory as we go.
  978.  */
  979. memset(&key, 0, sizeof(key));
  980. key.size = sizeof(db_recno_t);
  981. key.data = &keyno;
  982. memset(&data, 0, sizeof(data));
  983. F_SET(&data, DB_DBT_REALLOC);
  984. /*
  985.  * We'll need the delimiter if we're doing variable-length records,
  986.  * and the pad character if we're doing fixed-length records.
  987.  */
  988. delim = t->re_delim;
  989. if (F_ISSET(dbp, DB_AM_FIXEDLEN)) {
  990. if ((ret = __os_malloc(dbenv, t->re_len, &pad)) != 0)
  991. goto err;
  992. memset(pad, t->re_pad, t->re_len);
  993. }
  994. for (keyno = 1;; ++keyno) {
  995. switch (ret = dbp->get(dbp, NULL, &key, &data, 0)) {
  996. case 0:
  997. if (data.size != 0 && (u_int32_t)fwrite(
  998.     data.data, 1, data.size, fp) != data.size)
  999. goto write_err;
  1000. break;
  1001. case DB_KEYEMPTY:
  1002. if (F_ISSET(dbp, DB_AM_FIXEDLEN) &&
  1003.     (u_int32_t)fwrite(pad, 1, t->re_len, fp) !=
  1004.     t->re_len)
  1005. goto write_err;
  1006. break;
  1007. case DB_NOTFOUND:
  1008. ret = 0;
  1009. goto done;
  1010. default:
  1011. goto err;
  1012. }
  1013. if (!F_ISSET(dbp, DB_AM_FIXEDLEN) &&
  1014.     fwrite(&delim, 1, 1, fp) != 1) {
  1015. write_err: ret = errno;
  1016. __db_err(dbp->dbenv,
  1017.     "%s: write failed to backing file: %s",
  1018.     t->re_source, strerror(ret));
  1019. goto err;
  1020. }
  1021. }
  1022. err:
  1023. done: /* Close the file descriptor. */
  1024. if (fp != NULL && fclose(fp) != 0) {
  1025. if (ret == 0)
  1026. ret = errno;
  1027. __db_err(dbenv, "%s: %s", t->re_source, db_strerror(errno));
  1028. }
  1029. /* Discard the cursor. */
  1030. if ((t_ret = dbc->c_close(dbc)) != 0 && ret == 0)
  1031. ret = t_ret;
  1032. /* Discard memory allocated to hold the data items. */
  1033. if (data.data != NULL)
  1034. __os_ufree(dbenv, data.data);
  1035. if (pad != NULL)
  1036. __os_free(dbenv, pad);
  1037. if (ret == 0)
  1038. t->re_modified = 0;
  1039. return (ret);
  1040. }
  1041. /*
  1042.  * __ram_sread --
  1043.  * Read records from a source file.
  1044.  */
  1045. static int
  1046. __ram_sread(dbc, top)
  1047. DBC *dbc;
  1048. db_recno_t top;
  1049. {
  1050. BTREE *t;
  1051. DB *dbp;
  1052. DBT data, *rdata;
  1053. db_recno_t recno;
  1054. size_t len;
  1055. int ch, ret, was_modified;
  1056. t = dbc->dbp->bt_internal;
  1057. dbp = dbc->dbp;
  1058. was_modified = t->re_modified;
  1059. if ((ret = __bam_nrecs(dbc, &recno)) != 0)
  1060. return (ret);
  1061. /*
  1062.  * Use the record key return memory, it's only a short-term use.
  1063.  * The record data return memory is used by __bam_iitem, which
  1064.  * we'll indirectly call, so use the key so as not to collide.
  1065.  */
  1066. len = F_ISSET(dbp, DB_AM_FIXEDLEN) ? t->re_len : 256;
  1067. rdata = &dbc->my_rkey;
  1068. if (rdata->ulen < len) {
  1069. if ((ret = __os_realloc(
  1070.     dbp->dbenv, len, &rdata->data)) != 0) {
  1071. rdata->ulen = 0;
  1072. rdata->data = NULL;
  1073. return (ret);
  1074. }
  1075. rdata->ulen = (u_int32_t)len;
  1076. }
  1077. memset(&data, 0, sizeof(data));
  1078. while (recno < top) {
  1079. data.data = rdata->data;
  1080. data.size = 0;
  1081. if (F_ISSET(dbp, DB_AM_FIXEDLEN))
  1082. for (len = t->re_len; len > 0; --len) {
  1083. if ((ch = getc(t->re_fp)) == EOF) {
  1084. if (data.size == 0)
  1085. goto eof;
  1086. break;
  1087. }
  1088. ((u_int8_t *)data.data)[data.size++] = ch;
  1089. }
  1090. else
  1091. for (;;) {
  1092. if ((ch = getc(t->re_fp)) == EOF) {
  1093. if (data.size == 0)
  1094. goto eof;
  1095. break;
  1096. }
  1097. if (ch == t->re_delim)
  1098. break;
  1099. ((u_int8_t *)data.data)[data.size++] = ch;
  1100. if (data.size == rdata->ulen) {
  1101. if ((ret = __os_realloc(dbp->dbenv,
  1102.     rdata->ulen *= 2,
  1103.     &rdata->data)) != 0) {
  1104. rdata->ulen = 0;
  1105. rdata->data = NULL;
  1106. return (ret);
  1107. } else
  1108. data.data = rdata->data;
  1109. }
  1110. }
  1111. /*
  1112.  * Another process may have read this record from the input
  1113.  * file and stored it into the database already, in which
  1114.  * case we don't need to repeat that operation.  We detect
  1115.  * this by checking if the last record we've read is greater
  1116.  * or equal to the number of records in the database.
  1117.  */
  1118. if (t->re_last >= recno) {
  1119. ++recno;
  1120. if ((ret = __ram_add(dbc, &recno, &data, 0, 0)) != 0)
  1121. goto err;
  1122. }
  1123. ++t->re_last;
  1124. }
  1125. if (0) {
  1126. eof: t->re_eof = 1;
  1127. ret = DB_NOTFOUND;
  1128. }
  1129. err: if (!was_modified)
  1130. t->re_modified = 0;
  1131. return (ret);
  1132. }
  1133. /*
  1134.  * __ram_add --
  1135.  * Add records into the tree.
  1136.  */
  1137. static int
  1138. __ram_add(dbc, recnop, data, flags, bi_flags)
  1139. DBC *dbc;
  1140. db_recno_t *recnop;
  1141. DBT *data;
  1142. u_int32_t flags, bi_flags;
  1143. {
  1144. BTREE_CURSOR *cp;
  1145. int exact, ret, stack;
  1146. cp = (BTREE_CURSOR *)dbc->internal;
  1147. retry: /* Find the slot for insertion. */
  1148. if ((ret = __bam_rsearch(dbc, recnop,
  1149.     S_INSERT | (flags == DB_APPEND ? S_APPEND : 0), 1, &exact)) != 0)
  1150. return (ret);
  1151. stack = 1;
  1152. /* Copy the page into the cursor. */
  1153. STACK_TO_CURSOR(cp);
  1154. /*
  1155.  * The application may modify the data based on the selected record
  1156.  * number.
  1157.  */
  1158. if (flags == DB_APPEND && dbc->dbp->db_append_recno != NULL &&
  1159.     (ret = dbc->dbp->db_append_recno(dbc->dbp, data, *recnop)) != 0)
  1160. goto err;
  1161. /*
  1162.  * Select the arguments for __bam_iitem() and do the insert.  If the
  1163.  * key is an exact match, or we're replacing the data item with a
  1164.  * new data item, replace the current item.  If the key isn't an exact
  1165.  * match, we're inserting a new key/data pair, before the search
  1166.  * location.
  1167.  */
  1168. switch (ret = __bam_iitem(dbc,
  1169.     NULL, data, exact ? DB_CURRENT : DB_BEFORE, bi_flags)) {
  1170. case 0:
  1171. /*
  1172.  * Don't adjust anything.
  1173.  *
  1174.  * If we inserted a record, no cursors need adjusting because
  1175.  * the only new record it's possible to insert is at the very
  1176.  * end of the tree.  The necessary adjustments to the internal
  1177.  * page counts were made by __bam_iitem().
  1178.  *
  1179.  * If we overwrote a record, no cursors need adjusting because
  1180.  * future DBcursor->get calls will simply return the underlying
  1181.  * record (there's no adjustment made for the DB_CURRENT flag
  1182.  * when a cursor get operation immediately follows a cursor
  1183.  * delete operation, and the normal adjustment for the DB_NEXT
  1184.  * flag is still correct).
  1185.  */
  1186. break;
  1187. case DB_NEEDSPLIT:
  1188. /* Discard the stack of pages and split the page. */
  1189. (void)__bam_stkrel(dbc, STK_CLRDBC);
  1190. stack = 0;
  1191. if ((ret = __bam_split(dbc, recnop, NULL)) != 0)
  1192. goto err;
  1193. goto retry;
  1194. /* NOTREACHED */
  1195. default:
  1196. goto err;
  1197. }
  1198. err: if (stack)
  1199. __bam_stkrel(dbc, STK_CLRDBC);
  1200. return (ret);
  1201. }