db2/mp/mp_bh.c

   1 /*-
   2  * See the file LICENSE for redistribution information.
   3  *
   4  * Copyright (c) 1996, 1997
   5  *      Sleepycat Software.  All rights reserved.
   6  */
   7 #include "config.h"
   8
   9 #ifndef lint
  10 static const char sccsid[] = "@(#)mp_bh.c       10.15 (Sleepycat) 8/29/97";
  11 #endif /* not lint */
  12
  13 #ifndef NO_SYSTEM_INCLUDES
  14 #include <sys/types.h>
  15
  16 #include <errno.h>
  17 #include <string.h>
  18 #include <unistd.h>
  19 #endif
  20
  21 #include "db_int.h"
  22 #include "shqueue.h"
  23 #include "db_shash.h"
  24 #include "mp.h"
  25 #include "common_ext.h"
  26
  27 static int __memp_upgrade __P((DB_MPOOL *, DB_MPOOLFILE *, MPOOLFILE *));
  28
  29 /*
  30  * __memp_bhwrite --
  31  *      Write the page associated with a given bucket header.
  32  *
  33  * PUBLIC: int __memp_bhwrite
  34  * PUBLIC:     __P((DB_MPOOL *, MPOOLFILE *, BH *, int *, int *));
  35  */
  36 int
  37 __memp_bhwrite(dbmp, mfp, bhp, restartp, wrotep)
  38         DB_MPOOL *dbmp;
  39         MPOOLFILE *mfp;
  40         BH *bhp;
  41         int *restartp, *wrotep;
  42 {
  43         DBT dbt;
  44         DB_MPOOLFILE *dbmfp;
  45         DB_MPREG *mpreg;
  46
  47         if (restartp != NULL)
  48                 *restartp = 0;
  49         if (wrotep != NULL)
  50                 *wrotep = 0;
  51
  52         /*
  53          * Walk the process' DB_MPOOLFILE list and find a file descriptor for
  54          * the file.  We also check that the descriptor is open for writing.
  55          * If we find a descriptor on the file that's not open for writing, we
  56          * try and upgrade it to make it writeable.
  57          */
  58         LOCKHANDLE(dbmp, &dbmp->mutex);
  59         for (dbmfp = TAILQ_FIRST(&dbmp->dbmfq);
  60             dbmfp != NULL; dbmfp = TAILQ_NEXT(dbmfp, q))
  61                 if (dbmfp->mfp == mfp) {
  62                         if (F_ISSET(dbmfp, MP_READONLY) &&
  63                             __memp_upgrade(dbmp, dbmfp, mfp))
  64                                 return (0);
  65                         break;
  66                 }
  67         UNLOCKHANDLE(dbmp, &dbmp->mutex);
  68         if (dbmfp != NULL)
  69                 goto found;
  70
  71         /*
  72          * It's not a page from a file we've opened.  If the file requires
  73          * input/output processing, see if this process has ever registered
  74          * information as to how to write this type of file.  If not, there's
  75          * nothing we can do.
  76          */
  77         if (mfp->ftype != 0) {
  78                 LOCKHANDLE(dbmp, &dbmp->mutex);
  79                 for (mpreg = LIST_FIRST(&dbmp->dbregq);
  80                     mpreg != NULL; mpreg = LIST_NEXT(mpreg, q))
  81                         if (mpreg->ftype == mfp->ftype)
  82                                 break;
  83                 UNLOCKHANDLE(dbmp, &dbmp->mutex);
  84                 if (mpreg == NULL)
  85                         return (0);
  86         }
  87
  88         /*
  89          * Try and open the file; ignore any error, assume it's a permissions
  90          * problem.
  91          *
  92          * XXX
  93          * There's no negative cache here, so we may repeatedly try and open
  94          * files that we have previously tried (and failed) to open.
  95          */
  96         dbt.size = mfp->pgcookie_len;
  97         dbt.data = ADDR(dbmp, mfp->pgcookie_off);
  98         if (__memp_fopen(dbmp, ADDR(dbmp, mfp->path_off),
  99             mfp->ftype, 0, 0, mfp->stat.st_pagesize,
 100             mfp->lsn_off, &dbt, ADDR(dbmp, mfp->fileid_off), 0, &dbmfp) != 0)
 101                 return (0);
 102
 103 found:  return (__memp_pgwrite(dbmfp, bhp, restartp, wrotep));
 104 }
 105
 106 /*
 107  * __memp_pgread --
 108  *      Read a page from a file.
 109  *
 110  * PUBLIC: int __memp_pgread __P((DB_MPOOLFILE *, BH *, int));
 111  */
 112 int
 113 __memp_pgread(dbmfp, bhp, can_create)
 114         DB_MPOOLFILE *dbmfp;
 115         BH *bhp;
 116         int can_create;
 117 {
 118         DB_MPOOL *dbmp;
 119         MPOOLFILE *mfp;
 120         size_t pagesize;
 121         ssize_t nr;
 122         int ret;
 123
 124         dbmp = dbmfp->dbmp;
 125         mfp = dbmfp->mfp;
 126         pagesize = mfp->stat.st_pagesize;
 127
 128         F_SET(bhp, BH_LOCKED | BH_TRASH);
 129         LOCKBUFFER(dbmp, bhp);
 130         UNLOCKREGION(dbmp);
 131
 132         /*
 133          * Temporary files may not yet have been created.
 134          *
 135          * Seek to the page location.
 136          */
 137         ret = 0;
 138         LOCKHANDLE(dbmp, &dbmfp->mutex);
 139         if (dbmfp->fd == -1 || (ret =
 140             __db_lseek(dbmfp->fd, pagesize, bhp->pgno, 0, SEEK_SET)) != 0) {
 141                 if (!can_create) {
 142                         if (dbmfp->fd == -1)
 143                                 ret = EINVAL;
 144                         UNLOCKHANDLE(dbmp, &dbmfp->mutex);
 145                         __db_err(dbmp->dbenv,
 146                             "%s: page %lu doesn't exist, create flag not set",
 147                             dbmfp->path, (u_long)bhp->pgno);
 148                         goto err;
 149                 }
 150                 UNLOCKHANDLE(dbmp, &dbmfp->mutex);
 151
 152                 /* Clear any uninitialized data. */
 153                 memset(bhp->buf, 0, pagesize);
 154                 goto pgin;
 155         }
 156
 157         /*
 158          * Read the page; short reads are treated like creates, although
 159          * any valid data is preserved.
 160          */
 161         ret = __db_read(dbmfp->fd, bhp->buf, pagesize, &nr);
 162         UNLOCKHANDLE(dbmp, &dbmfp->mutex);
 163         if (ret != 0)
 164                 goto err;
 165
 166         if (nr == (ssize_t)pagesize)
 167                 can_create = 0;
 168         else {
 169                 if (!can_create) {
 170                         ret = EINVAL;
 171                         goto err;
 172                 }
 173
 174                 /* Clear any uninitialized data. */
 175                 memset(bhp->buf + nr, 0, pagesize - nr);
 176         }
 177
 178         /* Call any pgin function. */
 179 pgin:   ret = mfp->ftype == 0 ? 0 : __memp_pg(dbmfp, bhp, 1);
 180
 181         /* Reacquire the region lock. */
 182         LOCKREGION(dbmp);
 183
 184         /* If the pgin function succeeded, the data is now valid. */
 185         if (ret == 0)
 186                 F_CLR(bhp, BH_TRASH);
 187
 188         /* Update the statistics. */
 189         if (can_create) {
 190                 ++dbmp->mp->stat.st_page_create;
 191                 ++mfp->stat.st_page_create;
 192         } else {
 193                 ++dbmp->mp->stat.st_page_in;
 194                 ++mfp->stat.st_page_in;
 195         }
 196
 197         if (0) {
 198 err:            LOCKREGION(dbmp);
 199         }
 200
 201         /* Release the buffer. */
 202         F_CLR(bhp, BH_LOCKED);
 203         UNLOCKBUFFER(dbmp, bhp);
 204
 205         return (ret);
 206 }
 207
 208 /*
 209  * __memp_pgwrite --
 210  *      Write a page to a file.
 211  *
 212  * PUBLIC: int __memp_pgwrite __P((DB_MPOOLFILE *, BH *, int *, int *));
 213  */
 214 int
 215 __memp_pgwrite(dbmfp, bhp, restartp, wrotep)
 216         DB_MPOOLFILE *dbmfp;
 217         BH *bhp;
 218         int *restartp, *wrotep;
 219 {
 220         DB_ENV *dbenv;
 221         DB_LOG *lg_info;
 222         DB_LSN lsn;
 223         DB_MPOOL *dbmp;
 224         MPOOL *mp;
 225         MPOOLFILE *mfp;
 226         size_t pagesize;
 227         ssize_t nw;
 228         int callpgin, ret;
 229         const char *fail;
 230
 231         dbmp = dbmfp->dbmp;
 232         dbenv = dbmp->dbenv;
 233         mfp = dbmfp->mfp;
 234
 235         if (restartp != NULL)
 236                 *restartp = 0;
 237         if (wrotep != NULL)
 238                 *wrotep = 0;
 239         callpgin = 0;
 240         pagesize = mfp->stat.st_pagesize;
 241
 242         F_SET(bhp, BH_LOCKED);
 243         LOCKBUFFER(dbmp, bhp);
 244         UNLOCKREGION(dbmp);
 245
 246         if (restartp != NULL)
 247                 *restartp = 1;
 248
 249         /* Copy the LSN off the page if we're going to need it. */
 250         lg_info = dbenv->lg_info;
 251         if (lg_info != NULL || F_ISSET(bhp, BH_WRITE))
 252                 memcpy(&lsn, bhp->buf + mfp->lsn_off, sizeof(DB_LSN));
 253
 254         /* Ensure the appropriate log records are on disk. */
 255         if (lg_info != NULL && (ret = log_flush(lg_info, &lsn)) != 0)
 256                 goto err;
 257
 258         /*
 259          * Call any pgout function.  We set the callpgin flag so that on
 260          * error we flag that the contents of the buffer may be trash.
 261          */
 262         if (mfp->ftype == 0)
 263                 ret = 0;
 264         else {
 265                 callpgin = 1;
 266                 if ((ret = __memp_pg(dbmfp, bhp, 0)) != 0)
 267                         goto err;
 268         }
 269
 270         /* Temporary files may not yet have been created. */
 271         LOCKHANDLE(dbmp, &dbmfp->mutex);
 272         if (dbmfp->fd == -1 && ((ret = __db_appname(dbenv, DB_APP_TMP,
 273             NULL, NULL, &dbmfp->fd, NULL)) != 0 || dbmfp->fd == -1)) {
 274                 UNLOCKHANDLE(dbmp, &dbmfp->mutex);
 275                 __db_err(dbenv, "unable to create temporary backing file");
 276                 goto err;
 277         }
 278
 279         /* Write the page out. */
 280         if ((ret =
 281             __db_lseek(dbmfp->fd, pagesize, bhp->pgno, 0, SEEK_SET)) != 0)
 282                 fail = "seek";
 283         else if ((ret = __db_write(dbmfp->fd, bhp->buf, pagesize, &nw)) != 0)
 284                 fail = "write";
 285         UNLOCKHANDLE(dbmp, &dbmfp->mutex);
 286         if (ret != 0) {
 287                 /*
 288                  * XXX
 289                  * Shut the compiler up; it doesn't understand the correlation
 290                  * between the failing clauses to __db_lseek and __db_write and
 291                  * this ret != 0.
 292                  */
 293                 fail = NULL;
 294                 goto syserr;
 295         }
 296
 297         if (nw != (ssize_t)pagesize) {
 298                 ret = EIO;
 299                 fail = "write";
 300                 goto syserr;
 301         }
 302
 303         if (wrotep != NULL)
 304                 *wrotep = 1;
 305
 306         /* Reacquire the region lock. */
 307         LOCKREGION(dbmp);
 308
 309         /* Clean up the flags based on a successful write. */
 310         F_SET(bhp, BH_CALLPGIN);
 311         F_CLR(bhp, BH_DIRTY | BH_LOCKED);
 312         UNLOCKBUFFER(dbmp, bhp);
 313
 314         /*
 315          * If we wrote a buffer which a checkpoint is waiting for, update
 316          * the count of pending buffers (both in the mpool as a whole and
 317          * for this file).  If the count for this file goes to zero, flush
 318          * the writes.
 319          *
 320          * XXX:
 321          * We ignore errors from the sync -- it makes no sense to return an
 322          * error to the calling process, so set a flag causing the sync to
 323          * be retried later.
 324          *
 325          * If the buffer we wrote has a LSN larger than the current largest
 326          * we've written for this checkpoint, update the saved value.
 327          */
 328         mp = dbmp->mp;
 329         if (F_ISSET(bhp, BH_WRITE)) {
 330                 if (log_compare(&lsn, &mp->lsn) > 0)
 331                         mp->lsn = lsn;
 332                 F_CLR(bhp, BH_WRITE);
 333
 334                 --mp->lsn_cnt;
 335                 if (--mfp->lsn_cnt == 0) {
 336                         /*
 337                          * Don't lock -- there are no atomicity issues for
 338                          * fsync(2).
 339                          */
 340                         if (__db_fsync(dbmfp->fd) != 0)
 341                                 F_SET(mp, MP_LSN_RETRY);
 342                 }
 343         }
 344
 345         /* Update I/O statistics. */
 346         ++mp->stat.st_page_out;
 347         ++mfp->stat.st_page_out;
 348
 349         return (0);
 350
 351 syserr: __db_err(dbenv,
 352             "%s: %s failed for page %lu", dbmfp->path, fail, (u_long)bhp->pgno);
 353
 354 err:    UNLOCKBUFFER(dbmp, bhp);
 355         LOCKREGION(dbmp);
 356         if (callpgin)
 357                 F_SET(bhp, BH_CALLPGIN);
 358         F_CLR(bhp, BH_LOCKED);
 359         return (ret);
 360 }
 361
 362 /*
 363  * __memp_pg --
 364  *      Call the pgin/pgout routine.
 365  *
 366  * PUBLIC: int __memp_pg __P((DB_MPOOLFILE *, BH *, int));
 367  */
 368 int
 369 __memp_pg(dbmfp, bhp, is_pgin)
 370         DB_MPOOLFILE *dbmfp;
 371         BH *bhp;
 372         int is_pgin;
 373 {
 374         DBT dbt, *dbtp;
 375         DB_MPOOL *dbmp;
 376         DB_MPREG *mpreg;
 377         MPOOLFILE *mfp;
 378         int ftype, ret;
 379
 380         dbmp = dbmfp->dbmp;
 381         mfp = dbmfp->mfp;
 382
 383         LOCKHANDLE(dbmp, &dbmp->mutex);
 384
 385         ftype = mfp->ftype;
 386         for (mpreg = LIST_FIRST(&dbmp->dbregq);
 387             mpreg != NULL; mpreg = LIST_NEXT(mpreg, q)) {
 388                 if (ftype != mpreg->ftype)
 389                         continue;
 390                 if (mfp->pgcookie_len == 0)
 391                         dbtp = NULL;
 392                 else {
 393                         dbt.size = mfp->pgcookie_len;
 394                         dbt.data = ADDR(dbmp, mfp->pgcookie_off);
 395                         dbtp = &dbt;
 396                 }
 397                 UNLOCKHANDLE(dbmp, &dbmp->mutex);
 398
 399                 if (is_pgin) {
 400                         if (mpreg->pgin != NULL && (ret =
 401                             mpreg->pgin(bhp->pgno, bhp->buf, dbtp)) != 0)
 402                                 goto err;
 403                 } else
 404                         if (mpreg->pgout != NULL && (ret =
 405                             mpreg->pgout(bhp->pgno, bhp->buf, dbtp)) != 0)
 406                                 goto err;
 407                 break;
 408         }
 409
 410         if (mpreg == NULL)
 411                 UNLOCKHANDLE(dbmp, &dbmp->mutex);
 412
 413         return (0);
 414
 415 err:    UNLOCKHANDLE(dbmp, &dbmp->mutex);
 416         __db_err(dbmp->dbenv, "%s: %s failed for page %lu",
 417             dbmfp->path, is_pgin ? "pgin" : "pgout", (u_long)bhp->pgno);
 418         return (ret);
 419 }
 420
 421 /*
 422  * __memp_bhfree --
 423  *      Free a bucket header and its referenced data.
 424  *
 425  * PUBLIC: void __memp_bhfree __P((DB_MPOOL *, MPOOLFILE *, BH *, int));
 426  */
 427 void
 428 __memp_bhfree(dbmp, mfp, bhp, free_mem)
 429         DB_MPOOL *dbmp;
 430         MPOOLFILE *mfp;
 431         BH *bhp;
 432         int free_mem;
 433 {
 434         size_t off;
 435
 436         /* Delete the buffer header from the MPOOL hash list. */
 437         off = BUCKET(dbmp->mp, OFFSET(dbmp, mfp), bhp->pgno);
 438         SH_TAILQ_REMOVE(&dbmp->htab[off], bhp, mq, __bh);
 439
 440         /* Delete the buffer header from the LRU chain. */
 441         SH_TAILQ_REMOVE(&dbmp->mp->bhq, bhp, q, __bh);
 442
 443         /*
 444          * If we're not reusing it immediately, free the buffer header
 445          * and data for real.
 446          */
 447         if (free_mem)
 448                 __db_shalloc_free(dbmp->addr, bhp);
 449 }
 450
 451 /*
 452  * __memp_upgrade --
 453  *      Upgrade a file descriptor from readonly to readwrite.
 454  */
 455 static int
 456 __memp_upgrade(dbmp, dbmfp, mfp)
 457         DB_MPOOL *dbmp;
 458         DB_MPOOLFILE *dbmfp;
 459         MPOOLFILE *mfp;
 460 {
 461         int fd;
 462
 463         /*
 464          * !!!
 465          * We expect the handle to already be locked.
 466          */
 467
 468         /* Check to see if we've already upgraded. */
 469         if (F_ISSET(dbmfp, MP_UPGRADE))
 470                 return (0);
 471
 472         /* Check to see if we've already failed. */
 473         if (F_ISSET(dbmfp, MP_UPGRADE_FAIL))
 474                 return (1);
 475
 476         /* Try the open. */
 477         if (__db_fdopen(ADDR(dbmp, mfp->path_off), 0, 0, 0, &fd) != 0) {
 478                 F_SET(dbmfp, MP_UPGRADE_FAIL);
 479                 return (1);
 480         }
 481
 482         /* Swap the descriptors and set the upgrade flag. */
 483         (void)close(dbmfp->fd);
 484         dbmfp->fd = fd;
 485         F_SET(dbmfp, MP_UPGRADE);
 486
 487         return (0);
 488 }