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

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

MySQL数据库

开发平台：

Visual C++

hash_rec.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.  */
  7. /*
  8.  * Copyright (c) 1995, 1996
  9.  * Margo Seltzer.  All rights reserved.
  10.  */
  11. /*
  12.  * Copyright (c) 1995, 1996
  13.  * The President and Fellows of Harvard University.  All rights reserved.
  14.  *
  15.  * This code is derived from software contributed to Berkeley by
  16.  * Margo Seltzer.
  17.  *
  18.  * Redistribution and use in source and binary forms, with or without
  19.  * modification, are permitted provided that the following conditions
  20.  * are met:
  21.  * 1. Redistributions of source code must retain the above copyright
  22.  *    notice, this list of conditions and the following disclaimer.
  23.  * 2. Redistributions in binary form must reproduce the above copyright
  24.  *    notice, this list of conditions and the following disclaimer in the
  25.  *    documentation and/or other materials provided with the distribution.
  26.  * 3. Neither the name of the University nor the names of its contributors
  27.  *    may be used to endorse or promote products derived from this software
  28.  *    without specific prior written permission.
  29.  *
  30.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  31.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  32.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  33.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  34.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  36.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  37.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  38.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  39.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  40.  * SUCH DAMAGE.
  41.  */
  43. #include "db_config.h"
  45. #ifndef lint
  46. static const char revid[] = "$Id: hash_rec.c,v 11.34 2001/01/11 18:19:52 bostic Exp $";
  47. #endif /* not lint */
  49. #ifndef NO_SYSTEM_INCLUDES
  50. #include <sys/types.h>
  52. #include <string.h>
  53. #endif
  55. #include "db_int.h"
  56. #include "db_page.h"
  57. #include "db_shash.h"
  58. #include "btree.h"
  59. #include "hash.h"
  60. #include "lock.h"
  61. #include "log.h"
  62. #include "mp.h"
  64. static int __ham_alloc_pages __P((DB *, __ham_groupalloc_args *));
  66. /*
  67.  * __ham_insdel_recover --
  68.  *
  69.  * PUBLIC: int __ham_insdel_recover
  70.  * PUBLIC:     __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  71.  */
  72. int
  73. __ham_insdel_recover(dbenv, dbtp, lsnp, op, info)
  74. DB_ENV *dbenv;
  75. DBT *dbtp;
  76. DB_LSN *lsnp;
  77. db_recops op;
  78. void *info;
  79. {
  80. __ham_insdel_args *argp;
  81. DB *file_dbp;
  82. DBC *dbc;
  83. DB_MPOOLFILE *mpf;
  84. PAGE *pagep;
  85. u_int32_t opcode;
  86. int cmp_n, cmp_p, flags, getmeta, ret, type;
  88. COMPQUIET(info, NULL);
  90. getmeta = 0;
  91. REC_PRINT(__ham_insdel_print);
  92. REC_INTRO(__ham_insdel_read, 1);
  94. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
  95. if (DB_UNDO(op)) {
  96. /*
  97.  * We are undoing and the page doesn't exist.  That
  98.  * is equivalent to having a pagelsn of 0, so we
  99.  * would not have to undo anything.  In this case,
  100.  * don't bother creating a page.
  101.  */
  102. goto done;
  103. } else if ((ret = memp_fget(mpf, &argp->pgno,
  104.     DB_MPOOL_CREATE, &pagep)) != 0)
  105. goto out;
  106. }
  108. if ((ret = __ham_get_meta(dbc)) != 0)
  109. goto out;
  110. getmeta = 1;
  112. cmp_n = log_compare(lsnp, &LSN(pagep));
  113. cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
  114. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->pagelsn);
  115. /*
  116.  * Two possible things going on:
  117.  * redo a delete/undo a put: delete the item from the page.
  118.  * redo a put/undo a delete: add the item to the page.
  119.  * If we are undoing a delete, then the information logged is the
  120.  * entire entry off the page, not just the data of a dbt.  In
  121.  * this case, we want to copy it back onto the page verbatim.
  122.  * We do this by calling __putitem with the type H_OFFPAGE instead
  123.  * of H_KEYDATA.
  124.  */
  125. opcode = OPCODE_OF(argp->opcode);
  127. flags = 0;
  128. if ((opcode == DELPAIR && cmp_n == 0 && DB_UNDO(op)) ||
  129.     (opcode == PUTPAIR && cmp_p == 0 && DB_REDO(op))) {
  130. /*
  131.  * Need to redo a PUT or undo a delete.  If we are undoing a
  132.  * delete, we've got to restore the item back to its original
  133.  * position.  That's a royal pain in the butt (because we do
  134.  * not store item lengths on the page), but there's no choice.
  135.  */
  136. if (opcode != DELPAIR ||
  137.     argp->ndx == (u_int32_t)NUM_ENT(pagep)) {
  138. __ham_putitem(pagep, &argp->key,
  139.     DB_UNDO(op) || PAIR_ISKEYBIG(argp->opcode) ?
  140.     H_OFFPAGE : H_KEYDATA);
  142. if (PAIR_ISDATADUP(argp->opcode))
  143. type = H_DUPLICATE;
  144. else if (DB_UNDO(op) || PAIR_ISDATABIG(argp->opcode))
  145. type = H_OFFPAGE;
  146. else
  147. type = H_KEYDATA;
  148. __ham_putitem(pagep, &argp->data, type);
  149. } else
  150. (void)__ham_reputpair(pagep, file_dbp->pgsize,
  151.     argp->ndx, &argp->key, &argp->data);
  153. LSN(pagep) = DB_REDO(op) ? *lsnp : argp->pagelsn;
  154. flags = DB_MPOOL_DIRTY;
  156. } else if ((opcode == DELPAIR && cmp_p == 0 && DB_REDO(op))
  157.     || (opcode == PUTPAIR && cmp_n == 0 && DB_UNDO(op))) {
  158. /* Need to undo a put or redo a delete. */
  159. __ham_dpair(file_dbp, pagep, argp->ndx);
  160. LSN(pagep) = DB_REDO(op) ? *lsnp : argp->pagelsn;
  161. flags = DB_MPOOL_DIRTY;
  162. }
  164. if ((ret = memp_fput(file_dbp->mpf, pagep, flags)) != 0)
  165. goto out;
  167. /* Return the previous LSN. */
  168. done: *lsnp = argp->prev_lsn;
  169. ret = 0;
  171. out: if (getmeta)
  172. (void)__ham_release_meta(dbc);
  173. REC_CLOSE;
  174. }
  176. /*
  177.  * __ham_newpage_recover --
  178.  * This log message is used when we add/remove overflow pages.  This
  179.  * message takes care of the pointer chains, not the data on the pages.
  180.  *
  181.  * PUBLIC: int __ham_newpage_recover
  182.  * PUBLIC:     __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  183.  */
  184. int
  185. __ham_newpage_recover(dbenv, dbtp, lsnp, op, info)
  186. DB_ENV *dbenv;
  187. DBT *dbtp;
  188. DB_LSN *lsnp;
  189. db_recops op;
  190. void *info;
  191. {
  192. __ham_newpage_args *argp;
  193. DB *file_dbp;
  194. DBC *dbc;
  195. DB_MPOOLFILE *mpf;
  196. PAGE *pagep;
  197. int cmp_n, cmp_p, flags, getmeta, ret;
  199. COMPQUIET(info, NULL);
  201. getmeta = 0;
  202. REC_PRINT(__ham_newpage_print);
  203. REC_INTRO(__ham_newpage_read, 1);
  205. if ((ret = memp_fget(mpf, &argp->new_pgno, 0, &pagep)) != 0) {
  206. if (DB_UNDO(op)) {
  207. /*
  208.  * We are undoing and the page doesn't exist.  That
  209.  * is equivalent to having a pagelsn of 0, so we
  210.  * would not have to undo anything.  In this case,
  211.  * don't bother creating a page.
  212.  */
  213. ret = 0;
  214. goto ppage;
  215. } else if ((ret = memp_fget(mpf, &argp->new_pgno,
  216.     DB_MPOOL_CREATE, &pagep)) != 0)
  217. goto out;
  218. }
  220. if ((ret = __ham_get_meta(dbc)) != 0)
  221. goto out;
  222. getmeta = 1;
  224. /*
  225.  * There are potentially three pages we need to check: the one
  226.  * that we created/deleted, the one before it and the one after
  227.  * it.
  228.  */
  230. cmp_n = log_compare(lsnp, &LSN(pagep));
  231. cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
  232. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->pagelsn);
  234. flags = 0;
  235. if ((cmp_p == 0 && DB_REDO(op) && argp->opcode == PUTOVFL) ||
  236.     (cmp_n == 0 && DB_UNDO(op) && argp->opcode == DELOVFL)) {
  237. /* Redo a create new page or undo a delete new page. */
  238. P_INIT(pagep, file_dbp->pgsize, argp->new_pgno,
  239.     argp->prev_pgno, argp->next_pgno, 0, P_HASH);
  240. flags = DB_MPOOL_DIRTY;
  241. } else if ((cmp_p == 0 && DB_REDO(op) && argp->opcode == DELOVFL) ||
  242.     (cmp_n == 0 && DB_UNDO(op) && argp->opcode == PUTOVFL)) {
  243. /*
  244.  * Redo a delete or undo a create new page.  All we
  245.  * really need to do is change the LSN.
  246.  */
  247. flags = DB_MPOOL_DIRTY;
  248. }
  250. if (flags)
  251. LSN(pagep) = DB_REDO(op) ? *lsnp : argp->pagelsn;
  253. if ((ret = memp_fput(file_dbp->mpf, pagep, flags)) != 0)
  254. goto out;
  256. /* Now do the prev page. */
  257. ppage: if (argp->prev_pgno != PGNO_INVALID) {
  258. if ((ret = memp_fget(mpf, &argp->prev_pgno, 0, &pagep)) != 0) {
  259. if (DB_UNDO(op)) {
  260. /*
  261.  * We are undoing and the page doesn't exist.
  262.  * That is equivalent to having a pagelsn of 0,
  263.  * so we would not have to undo anything.  In
  264.  * this case, don't bother creating a page.
  265.  */
  266. ret = 0;
  267. goto npage;
  268. } else if ((ret =
  269.     memp_fget(mpf, &argp->prev_pgno,
  270.     DB_MPOOL_CREATE, &pagep)) != 0)
  271. goto out;
  272. }
  274. cmp_n = log_compare(lsnp, &LSN(pagep));
  275. cmp_p = log_compare(&LSN(pagep), &argp->prevlsn);
  276. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->prevlsn);
  277. flags = 0;
  279. if ((cmp_p == 0 && DB_REDO(op) && argp->opcode == PUTOVFL) ||
  280.     (cmp_n == 0 && DB_UNDO(op) && argp->opcode == DELOVFL)) {
  281. /* Redo a create new page or undo a delete new page. */
  282. pagep->next_pgno = argp->new_pgno;
  283. flags = DB_MPOOL_DIRTY;
  284. } else if ((cmp_p == 0 && DB_REDO(op) && argp->opcode == DELOVFL) ||
  285.     (cmp_n == 0 && DB_UNDO(op) && argp->opcode == PUTOVFL)) {
  286. /* Redo a delete or undo a create new page. */
  287. pagep->next_pgno = argp->next_pgno;
  288. flags = DB_MPOOL_DIRTY;
  289. }
  291. if (flags)
  292. LSN(pagep) = DB_REDO(op) ? *lsnp : argp->prevlsn;
  294. if ((ret = memp_fput(file_dbp->mpf, pagep, flags)) != 0)
  295. goto out;
  296. }
  298. /* Now time to do the next page */
  299. npage: if (argp->next_pgno != PGNO_INVALID) {
  300. if ((ret = memp_fget(mpf, &argp->next_pgno, 0, &pagep)) != 0) {
  301. if (DB_UNDO(op)) {
  302. /*
  303.  * We are undoing and the page doesn't exist.
  304.  * That is equivalent to having a pagelsn of 0,
  305.  * so we would not have to undo anything.  In
  306.  * this case, don't bother creating a page.
  307.  */
  308. goto done;
  309. } else if ((ret =
  310.     memp_fget(mpf, &argp->next_pgno,
  311.     DB_MPOOL_CREATE, &pagep)) != 0)
  312. goto out;
  313. }
  315. cmp_n = log_compare(lsnp, &LSN(pagep));
  316. cmp_p = log_compare(&LSN(pagep), &argp->nextlsn);
  317. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->nextlsn);
  318. flags = 0;
  320. if ((cmp_p == 0 && DB_REDO(op) && argp->opcode == PUTOVFL) ||
  321.     (cmp_n == 0 && DB_UNDO(op) && argp->opcode == DELOVFL)) {
  322. /* Redo a create new page or undo a delete new page. */
  323. pagep->prev_pgno = argp->new_pgno;
  324. flags = DB_MPOOL_DIRTY;
  325. } else if ((cmp_p == 0 && DB_REDO(op) && argp->opcode == DELOVFL) ||
  326.     (cmp_n == 0 && DB_UNDO(op) && argp->opcode == PUTOVFL)) {
  327. /* Redo a delete or undo a create new page. */
  328. pagep->prev_pgno = argp->prev_pgno;
  329. flags = DB_MPOOL_DIRTY;
  330. }
  332. if (flags)
  333. LSN(pagep) = DB_REDO(op) ? *lsnp : argp->nextlsn;
  335. if ((ret = memp_fput(file_dbp->mpf, pagep, flags)) != 0)
  336. goto out;
  337. }
  338. done: *lsnp = argp->prev_lsn;
  339. ret = 0;
  341. out: if (getmeta)
  342. (void)__ham_release_meta(dbc);
  343. REC_CLOSE;
  344. }
  346. /*
  347.  * __ham_replace_recover --
  348.  * This log message refers to partial puts that are local to a single
  349.  * page.  You can think of them as special cases of the more general
  350.  * insdel log message.
  351.  *
  352.  * PUBLIC: int __ham_replace_recover
  353.  * PUBLIC:    __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  354.  */
  355. int
  356. __ham_replace_recover(dbenv, dbtp, lsnp, op, info)
  357. DB_ENV *dbenv;
  358. DBT *dbtp;
  359. DB_LSN *lsnp;
  360. db_recops op;
  361. void *info;
  362. {
  363. __ham_replace_args *argp;
  364. DB *file_dbp;
  365. DBC *dbc;
  366. DB_MPOOLFILE *mpf;
  367. DBT dbt;
  368. PAGE *pagep;
  369. int32_t grow;
  370. int cmp_n, cmp_p, flags, getmeta, ret;
  371. u_int8_t *hk;
  373. COMPQUIET(info, NULL);
  375. getmeta = 0;
  376. REC_PRINT(__ham_replace_print);
  377. REC_INTRO(__ham_replace_read, 1);
  379. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
  380. if (DB_UNDO(op)) {
  381. /*
  382.  * We are undoing and the page doesn't exist.  That
  383.  * is equivalent to having a pagelsn of 0, so we
  384.  * would not have to undo anything.  In this case,
  385.  * don't bother creating a page.
  386.  */
  387. goto done;
  388. } else if ((ret = memp_fget(mpf, &argp->pgno,
  389.     DB_MPOOL_CREATE, &pagep)) != 0)
  390. goto out;
  391. }
  393. if ((ret = __ham_get_meta(dbc)) != 0)
  394. goto out;
  395. getmeta = 1;
  397. cmp_n = log_compare(lsnp, &LSN(pagep));
  398. cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
  399. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->pagelsn);
  401. memset(&dbt, 0, sizeof(dbt));
  402. flags = 0;
  403. grow = 1;
  405. if (cmp_p == 0 && DB_REDO(op)) {
  406. /* Reapply the change as specified. */
  407. dbt.data = argp->newitem.data;
  408. dbt.size = argp->newitem.size;
  409. grow = argp->newitem.size - argp->olditem.size;
  410. LSN(pagep) = *lsnp;
  411. flags = DB_MPOOL_DIRTY;
  412. } else if (cmp_n == 0 && DB_UNDO(op)) {
  413. /* Undo the already applied change. */
  414. dbt.data = argp->olditem.data;
  415. dbt.size = argp->olditem.size;
  416. grow = argp->olditem.size - argp->newitem.size;
  417. LSN(pagep) = argp->pagelsn;
  418. flags = DB_MPOOL_DIRTY;
  419. }
  421. if (flags) {
  422. __ham_onpage_replace(pagep,
  423.     file_dbp->pgsize, argp->ndx, argp->off, grow, &dbt);
  424. if (argp->makedup) {
  425. hk = P_ENTRY(pagep, argp->ndx);
  426. if (DB_REDO(op))
  427. HPAGE_PTYPE(hk) = H_DUPLICATE;
  428. else
  429. HPAGE_PTYPE(hk) = H_KEYDATA;
  430. }
  431. }
  433. if ((ret = memp_fput(file_dbp->mpf, pagep, flags)) != 0)
  434. goto out;
  436. done: *lsnp = argp->prev_lsn;
  437. ret = 0;
  439. out: if (getmeta)
  440. (void)__ham_release_meta(dbc);
  441. REC_CLOSE;
  442. }
  444. /*
  445.  * __ham_splitdata_recover --
  446.  *
  447.  * PUBLIC: int __ham_splitdata_recover
  448.  * PUBLIC:    __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  449.  */
  450. int
  451. __ham_splitdata_recover(dbenv, dbtp, lsnp, op, info)
  452. DB_ENV *dbenv;
  453. DBT *dbtp;
  454. DB_LSN *lsnp;
  455. db_recops op;
  456. void *info;
  457. {
  458. __ham_splitdata_args *argp;
  459. DB *file_dbp;
  460. DBC *dbc;
  461. DB_MPOOLFILE *mpf;
  462. PAGE *pagep;
  463. int cmp_n, cmp_p, flags, getmeta, ret;
  465. COMPQUIET(info, NULL);
  467. getmeta = 0;
  468. REC_PRINT(__ham_splitdata_print);
  469. REC_INTRO(__ham_splitdata_read, 1);
  471. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
  472. if (DB_UNDO(op)) {
  473. /*
  474.  * We are undoing and the page doesn't exist.  That
  475.  * is equivalent to having a pagelsn of 0, so we
  476.  * would not have to undo anything.  In this case,
  477.  * don't bother creating a page.
  478.  */
  479. goto done;
  480. } else if ((ret = memp_fget(mpf, &argp->pgno,
  481.     DB_MPOOL_CREATE, &pagep)) != 0)
  482. goto out;
  483. }
  485. if ((ret = __ham_get_meta(dbc)) != 0)
  486. goto out;
  487. getmeta = 1;
  489. cmp_n = log_compare(lsnp, &LSN(pagep));
  490. cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
  491. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->pagelsn);
  493. /*
  494.  * There are two types of log messages here, one for the old page
  495.  * and one for the new pages created.  The original image in the
  496.  * SPLITOLD record is used for undo.  The image in the SPLITNEW
  497.  * is used for redo.  We should never have a case where there is
  498.  * a redo operation and the SPLITOLD record is on disk, but not
  499.  * the SPLITNEW record.  Therefore, we only have work to do when
  500.  * redo NEW messages and undo OLD messages, but we have to update
  501.  * LSNs in both cases.
  502.  */
  503. flags = 0;
  504. if (cmp_p == 0 && DB_REDO(op)) {
  505. if (argp->opcode == SPLITNEW)
  506. /* Need to redo the split described. */
  507. memcpy(pagep, argp->pageimage.data,
  508.     argp->pageimage.size);
  509. LSN(pagep) = *lsnp;
  510. flags = DB_MPOOL_DIRTY;
  511. } else if (cmp_n == 0 && DB_UNDO(op)) {
  512. if (argp->opcode == SPLITOLD) {
  513. /* Put back the old image. */
  514. memcpy(pagep, argp->pageimage.data,
  515.     argp->pageimage.size);
  516. } else
  517. P_INIT(pagep, file_dbp->pgsize, argp->pgno,
  518.     PGNO_INVALID, PGNO_INVALID, 0, P_HASH);
  519. LSN(pagep) = argp->pagelsn;
  520. flags = DB_MPOOL_DIRTY;
  521. }
  522. if ((ret = memp_fput(file_dbp->mpf, pagep, flags)) != 0)
  523. goto out;
  525. done: *lsnp = argp->prev_lsn;
  526. ret = 0;
  528. out: if (getmeta)
  529. (void)__ham_release_meta(dbc);
  530. REC_CLOSE;
  531. }
  533. /*
  534.  * __ham_copypage_recover --
  535.  * Recovery function for copypage.
  536.  *
  537.  * PUBLIC: int __ham_copypage_recover
  538.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  539.  */
  540. int
  541. __ham_copypage_recover(dbenv, dbtp, lsnp, op, info)
  542. DB_ENV *dbenv;
  543. DBT *dbtp;
  544. DB_LSN *lsnp;
  545. db_recops op;
  546. void *info;
  547. {
  548. __ham_copypage_args *argp;
  549. DB *file_dbp;
  550. DBC *dbc;
  551. DB_MPOOLFILE *mpf;
  552. PAGE *pagep;
  553. int cmp_n, cmp_p, flags, getmeta, ret;
  555. COMPQUIET(info, NULL);
  557. getmeta = 0;
  558. REC_PRINT(__ham_copypage_print);
  559. REC_INTRO(__ham_copypage_read, 1);
  561. if ((ret = __ham_get_meta(dbc)) != 0)
  562. goto out;
  563. getmeta = 1;
  564. flags = 0;
  566. /* This is the bucket page. */
  567. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
  568. if (DB_UNDO(op)) {
  569. /*
  570.  * We are undoing and the page doesn't exist.  That
  571.  * is equivalent to having a pagelsn of 0, so we
  572.  * would not have to undo anything.  In this case,
  573.  * don't bother creating a page.
  574.  */
  575. ret = 0;
  576. goto donext;
  577. } else if ((ret = memp_fget(mpf, &argp->pgno,
  578.     DB_MPOOL_CREATE, &pagep)) != 0)
  579. goto out;
  580. }
  582. cmp_n = log_compare(lsnp, &LSN(pagep));
  583. cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
  584. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->pagelsn);
  586. if (cmp_p == 0 && DB_REDO(op)) {
  587. /* Need to redo update described. */
  588. memcpy(pagep, argp->page.data, argp->page.size);
  589. PGNO(pagep) = argp->pgno;
  590. PREV_PGNO(pagep) = PGNO_INVALID;
  591. LSN(pagep) = *lsnp;
  592. flags = DB_MPOOL_DIRTY;
  593. } else if (cmp_n == 0 && DB_UNDO(op)) {
  594. /* Need to undo update described. */
  595. P_INIT(pagep, file_dbp->pgsize, argp->pgno, PGNO_INVALID,
  596.     argp->next_pgno, 0, P_HASH);
  597. LSN(pagep) = argp->pagelsn;
  598. flags = DB_MPOOL_DIRTY;
  599. }
  600. if ((ret = memp_fput(mpf, pagep, flags)) != 0)
  601. goto out;
  603. donext: /* Now fix up the "next" page. */
  604. if ((ret = memp_fget(mpf, &argp->next_pgno, 0, &pagep)) != 0) {
  605. if (DB_UNDO(op)) {
  606. /*
  607.  * We are undoing and the page doesn't exist.  That
  608.  * is equivalent to having a pagelsn of 0, so we
  609.  * would not have to undo anything.  In this case,
  610.  * don't bother creating a page.
  611.  */
  612. ret = 0;
  613. goto do_nn;
  614. } else if ((ret = memp_fget(mpf, &argp->next_pgno,
  615.     DB_MPOOL_CREATE, &pagep)) != 0)
  616. goto out;
  617. }
  619. /* For REDO just update the LSN. For UNDO copy page back. */
  620. cmp_n = log_compare(lsnp, &LSN(pagep));
  621. cmp_p = log_compare(&LSN(pagep), &argp->nextlsn);
  622. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->nextlsn);
  623. flags = 0;
  624. if (cmp_p == 0 && DB_REDO(op)) {
  625. LSN(pagep) = *lsnp;
  626. flags = DB_MPOOL_DIRTY;
  627. } else if (cmp_n == 0 && DB_UNDO(op)) {
  628. /* Need to undo update described. */
  629. memcpy(pagep, argp->page.data, argp->page.size);
  630. flags = DB_MPOOL_DIRTY;
  631. }
  632. if ((ret = memp_fput(mpf, pagep, flags)) != 0)
  633. goto out;
  635. /* Now fix up the next's next page. */
  636. do_nn: if (argp->nnext_pgno == PGNO_INVALID)
  637. goto done;
  639. if ((ret = memp_fget(mpf, &argp->nnext_pgno, 0, &pagep)) != 0) {
  640. if (DB_UNDO(op)) {
  641. /*
  642.  * We are undoing and the page doesn't exist.  That
  643.  * is equivalent to having a pagelsn of 0, so we
  644.  * would not have to undo anything.  In this case,
  645.  * don't bother creating a page.
  646.  */
  647. goto done;
  648. } else if ((ret = memp_fget(mpf, &argp->nnext_pgno,
  649.     DB_MPOOL_CREATE, &pagep)) != 0)
  650. goto out;
  651. }
  653. cmp_n = log_compare(lsnp, &LSN(pagep));
  654. cmp_p = log_compare(&LSN(pagep), &argp->nnextlsn);
  655. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->nnextlsn);
  657. flags = 0;
  658. if (cmp_p == 0 && DB_REDO(op)) {
  659. /* Need to redo update described. */
  660. PREV_PGNO(pagep) = argp->pgno;
  661. LSN(pagep) = *lsnp;
  662. flags = DB_MPOOL_DIRTY;
  663. } else if (cmp_n == 0 && DB_UNDO(op)) {
  664. /* Need to undo update described. */
  665. PREV_PGNO(pagep) = argp->next_pgno;
  666. LSN(pagep) = argp->nnextlsn;
  667. flags = DB_MPOOL_DIRTY;
  668. }
  669. if ((ret = memp_fput(mpf, pagep, flags)) != 0)
  670. goto out;
  672. done: *lsnp = argp->prev_lsn;
  673. ret = 0;
  675. out: if (getmeta)
  676. (void)__ham_release_meta(dbc);
  677. REC_CLOSE;
  678. }
  680. /*
  681.  * __ham_metagroup_recover --
  682.  * Recovery function for metagroup.
  683.  *
  684.  * PUBLIC: int __ham_metagroup_recover
  685.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  686.  */
  687. int
  688. __ham_metagroup_recover(dbenv, dbtp, lsnp, op, info)
  689. DB_ENV *dbenv;
  690. DBT *dbtp;
  691. DB_LSN *lsnp;
  692. db_recops op;
  693. void *info;
  694. {
  695. __ham_metagroup_args *argp;
  696. HASH_CURSOR *hcp;
  697. DB *file_dbp;
  698. DBC *dbc;
  699. DB_MPOOLFILE *mpf;
  700. PAGE *pagep;
  701. db_pgno_t last_pgno;
  702. int cmp_n, cmp_p, flags, groupgrow, ret;
  704. COMPQUIET(info, NULL);
  705. REC_PRINT(__ham_metagroup_print);
  706. REC_INTRO(__ham_metagroup_read, 1);
  708. /*
  709.  * This logs the virtual create of pages pgno to pgno + bucket
  710.  * Since the mpool page-allocation is not really able to be
  711.  * transaction protected, we can never undo it.  Even in an abort,
  712.  * we have to allocate these pages to the hash table.
  713.  * The log record contains:
  714.  * bucket: new bucket being allocated.
  715.  * pgno: page number of the new bucket.
  716.  * if bucket is a power of 2, then we allocated a whole batch of
  717.  * pages; if it's not, then we simply allocated one new page.
  718.  */
  719. groupgrow =
  720.     (u_int32_t)(1 << __db_log2(argp->bucket + 1)) == argp->bucket + 1;
  722. last_pgno = argp->pgno;
  723. if (groupgrow)
  724. /* Read the last page. */
  725. last_pgno += argp->bucket;
  727. if ((ret = memp_fget(mpf, &last_pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  728. goto out;
  730. cmp_n = log_compare(lsnp, &LSN(pagep));
  731. cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
  732. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->pagelsn);
  734. flags = 0;
  735. if ((cmp_p == 0 && DB_REDO(op)) || (cmp_n == 0 && DB_UNDO(op))) {
  736. /*
  737.  * We need to make sure that we redo the allocation of the
  738.  * pages.
  739.  */
  740. if (DB_REDO(op))
  741. pagep->lsn = *lsnp;
  742. else
  743. pagep->lsn = argp->pagelsn;
  744. flags = DB_MPOOL_DIRTY;
  745. }
  746. if ((ret = memp_fput(mpf, pagep, flags)) != 0)
  747. goto out;
  749. /* Now we have to update the meta-data page. */
  750. hcp = (HASH_CURSOR *)dbc->internal;
  751. if ((ret = __ham_get_meta(dbc)) != 0)
  752. goto out;
  753. cmp_n = log_compare(lsnp, &hcp->hdr->dbmeta.lsn);
  754. cmp_p = log_compare(&hcp->hdr->dbmeta.lsn, &argp->metalsn);
  755. CHECK_LSN(op, cmp_p, &hcp->hdr->dbmeta.lsn, &argp->metalsn);
  756. if ((cmp_p == 0 && DB_REDO(op)) || (cmp_n == 0 && DB_UNDO(op))) {
  757. if (DB_REDO(op)) {
  758. /* Redo the actual updating of bucket counts. */
  759. ++hcp->hdr->max_bucket;
  760. if (groupgrow) {
  761. hcp->hdr->low_mask = hcp->hdr->high_mask;
  762. hcp->hdr->high_mask =
  763.     (argp->bucket + 1) | hcp->hdr->low_mask;
  764. }
  765. hcp->hdr->dbmeta.lsn = *lsnp;
  766. } else {
  767. /* Undo the actual updating of bucket counts. */
  768. --hcp->hdr->max_bucket;
  769. if (groupgrow) {
  770. hcp->hdr->high_mask = hcp->hdr->low_mask;
  771. hcp->hdr->low_mask = hcp->hdr->high_mask >> 1;
  772. }
  773. hcp->hdr->dbmeta.lsn = argp->metalsn;
  774. }
  775. if (groupgrow &&
  776.     hcp->hdr->spares[__db_log2(argp->bucket + 1) + 1] ==
  777.     PGNO_INVALID)
  778. hcp->hdr->spares[__db_log2(argp->bucket + 1) + 1] =
  779.     argp->pgno - argp->bucket - 1;
  780. F_SET(hcp, H_DIRTY);
  781. }
  782. if ((ret = __ham_release_meta(dbc)) != 0)
  783. goto out;
  785. done: *lsnp = argp->prev_lsn;
  786. ret = 0;
  788. out: REC_CLOSE;
  789. }
  791. /*
  792.  * __ham_groupalloc_recover --
  793.  * Recover the batch creation of a set of pages for a new database.
  794.  *
  795.  * PUBLIC: int __ham_groupalloc_recover
  796.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  797.  */
  798. int
  799. __ham_groupalloc_recover(dbenv, dbtp, lsnp, op, info)
  800. DB_ENV *dbenv;
  801. DBT *dbtp;
  802. DB_LSN *lsnp;
  803. db_recops op;
  804. void *info;
  805. {
  806. __ham_groupalloc_args *argp;
  807. DBMETA *mmeta;
  808. DB_MPOOLFILE *mpf;
  809. DB *file_dbp;
  810. DBC *dbc;
  811. db_pgno_t pgno;
  812. int cmp_n, cmp_p, flags, ret;
  814. REC_PRINT(__ham_groupalloc_print);
  815. REC_INTRO(__ham_groupalloc_read, 0);
  817. pgno = PGNO_BASE_MD;
  818. if ((ret = memp_fget(mpf, &pgno, 0, &mmeta)) != 0) {
  819. if (DB_REDO(op)) {
  820. /* Page should have existed. */
  821. (void)__db_pgerr(file_dbp, pgno);
  822. goto out;
  823. } else {
  824. ret = 0;
  825. goto done;
  826. }
  827. }
  829. cmp_n = log_compare(lsnp, &LSN(mmeta));
  830. cmp_p = log_compare(&LSN(mmeta), &argp->meta_lsn);
  831. CHECK_LSN(op, cmp_p, &LSN(mmeta), &argp->meta_lsn);
  833. /*
  834.  * Basically, we used mpool to allocate a chunk of pages.
  835.  * We need to either add those to a free list (in the undo
  836.  * case) or initialize them (in the redo case).
  837.  *
  838.  * If we are redoing and this is a hash subdatabase, it's possible
  839.  * that the pages were never allocated, so we'd better check for
  840.  * that and handle it here.
  841.  */
  843. flags = 0;
  844. if (DB_REDO(op)) {
  845. if ((ret = __ham_alloc_pages(file_dbp, argp)) != 0)
  846. goto out1;
  847. if (cmp_p == 0) {
  848. LSN(mmeta) = *lsnp;
  849. flags = DB_MPOOL_DIRTY;
  850. }
  851. }
  853. /*
  854.  * Always put the pages into the limbo list and free them later.
  855.  */
  856. else if (DB_UNDO(op)) {
  857. if ((ret = __db_add_limbo(dbenv,
  858.     info, argp->fileid, argp->start_pgno, argp->num)) != 0)
  859. goto out;
  860. if (cmp_n == 0) {
  861. LSN(mmeta) = argp->meta_lsn;
  862. flags = DB_MPOOL_DIRTY;
  863. }
  864. }
  866. out1: if ((ret = memp_fput(mpf, mmeta, flags)) != 0)
  867. goto out;
  869. done: if (ret == 0)
  870. *lsnp = argp->prev_lsn;
  872. out: REC_CLOSE;
  873. }
  875. /*
  876.  * __ham_alloc_pages --
  877.  *
  878.  * Called during redo of a file create.  We create new pages in the file
  879.  * using the MPOOL_NEW_GROUP flag.  We then log the meta-data page with a
  880.  * __crdel_metasub message.  If we manage to crash without the newly written
  881.  * pages getting to disk (I'm not sure this can happen anywhere except our
  882.  * test suite?!), then we need to go through a recreate the final pages.
  883.  * Hash normally has holes in its files and handles them appropriately.
  884.  */
  885. static int
  886. __ham_alloc_pages(dbp, argp)
  887. DB *dbp;
  888. __ham_groupalloc_args *argp;
  889. {
  890. DB_MPOOLFILE *mpf;
  891. PAGE *pagep;
  892. db_pgno_t pgno;
  893. int ret;
  895. mpf = dbp->mpf;
  897. /* Read the last page of the allocation. */
  898. pgno = argp->start_pgno + argp->num - 1;
  900. /* If the page exists, and it has been initialized, then we're done. */
  901. if ((ret = memp_fget(mpf, &pgno, 0, &pagep)) == 0) {
  902. if ((pagep->type == P_INVALID) && IS_ZERO_LSN(pagep->lsn))
  903. goto reinit_page;
  904. if ((ret = memp_fput(mpf, pagep, 0)) != 0)
  905. return (ret);
  906. return (0);
  907. }
  909. /*
  910.  * Had to create the page.  On some systems (read "Windows"),
  911.  * you can find random garbage on pages to which you haven't
  912.  * yet written.  So, we have an os layer that will do the
  913.  * right thing for group allocations.  We call that directly
  914.  * to make sure all the pages are allocated and then continue
  915.  * merrily on our way with normal recovery.
  916.  */
  917. if ((ret = __os_fpinit(dbp->dbenv, &mpf->fh,
  918.     argp->start_pgno, argp->num, dbp->pgsize)) != 0)
  919. return (ret);
  921. if ((ret = memp_fget(mpf, &pgno, DB_MPOOL_CREATE, &pagep)) != 0) {
  922. (void)__db_pgerr(dbp, pgno);
  923. return (ret);
  924. }
  926. reinit_page:
  927. /* Initialize the newly allocated page. */
  928. P_INIT(pagep,
  929.     dbp->pgsize, pgno, PGNO_INVALID, PGNO_INVALID, 0, P_HASH);
  930. ZERO_LSN(pagep->lsn);
  932. if ((ret = memp_fput(mpf, pagep, DB_MPOOL_DIRTY)) != 0)
  933. return (ret);
  935. return (0);
  936. }
  938. /*
  939.  * __ham_curadj_recover --
  940.  * Undo cursor adjustments if a subtransaction fails.
  941.  *
  942.  * PUBLIC: int __ham_curadj_recover
  943.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  944.  */
  946. int
  947. __ham_curadj_recover(dbenv, dbtp, lsnp, op, info)
  948. DB_ENV *dbenv;
  949. DBT *dbtp;
  950. DB_LSN *lsnp;
  951. db_recops op;
  952. void *info;
  953. {
  954. __ham_curadj_args *argp;
  955. DB_MPOOLFILE *mpf;
  956. DB *file_dbp;
  957. DBC *dbc;
  958. int ret;
  959. HASH_CURSOR *hcp;
  961. REC_PRINT(__ham_groupalloc_print);
  963. ret = 0;
  964. if (op != DB_TXN_ABORT)
  965. goto done;
  966. REC_INTRO(__ham_curadj_read, 0);
  968. COMPQUIET(info, NULL);
  969. /*
  970.  * Undo the adjustment by reinitializing the the cursor
  971.  * to look like the one that was used to do the adustment,
  972.  * then we invert the add so that undo the adjustment.
  973.  */
  974. hcp = (HASH_CURSOR *)dbc->internal;
  975. hcp->pgno = argp->pgno;
  976. hcp->indx = argp->indx;
  977. hcp->dup_off = argp->dup_off;
  978. hcp->order = argp->order;
  979. if (!argp->add)
  980. F_SET(hcp, H_DELETED);
  981. (void)__ham_c_update(dbc, argp->len, !argp->add, argp->is_dup);
  983. done: *lsnp = argp->prev_lsn;
  984. out: REC_CLOSE;
  985. }
  987. /*
  988.  * __ham_chgpg_recover --
  989.  * Undo cursor adjustments if a subtransaction fails.
  990.  *
  991.  * PUBLIC: int __ham_chgpg_recover
  992.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  993.  */
  995. int
  996. __ham_chgpg_recover(dbenv, dbtp, lsnp, op, info)
  997. DB_ENV *dbenv;
  998. DBT *dbtp;
  999. DB_LSN *lsnp;
  1000. db_recops op;
  1001. void *info;
  1002. {
  1003. __ham_chgpg_args *argp;
  1004. BTREE_CURSOR *opdcp;
  1005. DB_MPOOLFILE *mpf;
  1006. DB *file_dbp, *ldbp;
  1007. DBC *dbc;
  1008. int ret;
  1009. DBC *cp;
  1010. HASH_CURSOR *lcp;
  1012. REC_PRINT(__ham_chgpg_print);
  1014. ret = 0;
  1015. if (op != DB_TXN_ABORT)
  1016. goto out;
  1017. REC_INTRO(__ham_chgpg_read, 0);
  1019. COMPQUIET(info, NULL);
  1021. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  1022. for (ldbp = __dblist_get(dbenv, file_dbp->adj_fileid);
  1023.     ldbp != NULL && ldbp->adj_fileid == file_dbp->adj_fileid;
  1024.     ldbp = LIST_NEXT(ldbp, dblistlinks)) {
  1025. MUTEX_THREAD_LOCK(dbenv, file_dbp->mutexp);
  1027. for (cp = TAILQ_FIRST(&ldbp->active_queue); cp != NULL;
  1028.     cp = TAILQ_NEXT(cp, links)) {
  1029. lcp = (HASH_CURSOR *)cp->internal;
  1031. switch (argp->mode) {
  1032. case DB_HAM_CHGPG:
  1033. if (lcp->pgno != argp->new_pgno)
  1034. break;
  1036. if (argp->old_indx == NDX_INVALID)
  1037. lcp->pgno = argp->old_pgno;
  1038. else if (lcp->indx == argp->new_indx) {
  1039. lcp->indx = argp->old_indx;
  1040. lcp->pgno = argp->old_pgno;
  1041. }
  1042. break;
  1044. case DB_HAM_SPLIT:
  1045. if (lcp->pgno == argp->new_pgno
  1046.      && lcp->indx == argp->new_indx) {
  1047. lcp->indx = argp->old_indx;
  1048. lcp->pgno = argp->old_pgno;
  1049. }
  1050. break;
  1052. case DB_HAM_DUP:
  1053. if (lcp->opd != NULL) {
  1054. opdcp =
  1055.     (BTREE_CURSOR *)lcp->opd->internal;
  1056. if (opdcp->pgno == argp->new_pgno &&
  1057.      opdcp->indx == argp->new_indx) {
  1058. if (F_ISSET(opdcp, C_DELETED))
  1059. F_SET(lcp, H_DELETED);
  1060. if ((ret =
  1061.     lcp->opd->c_close(
  1062.     lcp->opd)) != 0)
  1063. goto out;
  1064. lcp->opd = NULL;
  1065. }
  1066. }
  1067. break;
  1068. }
  1069. }
  1071. MUTEX_THREAD_UNLOCK(dbenv, file_dbp->mutexp);
  1072. }
  1073. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  1075. done: *lsnp = argp->prev_lsn;
  1076. ret = 0;
  1077. out: REC_CLOSE;
  1078. }