db2/common/db_region.c

   1 /*-
   2  * See the file LICENSE for redistribution information.
   3  *
   4  * Copyright (c) 1996, 1997
   5  *      Sleepycat Software.  All rights reserved.
   6  */
   7 /*
   8  * Copyright (c) 1995, 1996
   9  *      The President and Fellows of Harvard University.  All rights reserved.
  10  *
  11  * This code is derived from software contributed to Harvard by
  12  * Margo Seltzer.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions
  16  * are met:
  17  * 1. Redistributions of source code must retain the above copyright
  18  *    notice, this list of conditions and the following disclaimer.
  19  * 2. Redistributions in binary form must reproduce the above copyright
  20  *    notice, this list of conditions and the following disclaimer in the
  21  *    documentation and/or other materials provided with the distribution.
  22  * 3. All advertising materials mentioning features or use of this software
  23  *    must display the following acknowledgement:
  24  *      This product includes software developed by the University of
  25  *      California, Berkeley and its contributors.
  26  * 4. 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  */
  42
  43 #include "config.h"
  44
  45 #ifndef lint
  46 static const char sccsid[] = "@(#)db_region.c   10.15 (Sleepycat) 10/25/97";
  47 #endif /* not lint */
  48
  49 #ifndef NO_SYSTEM_INCLUDES
  50 #include <sys/types.h>
  51 #include <sys/stat.h>
  52
  53 #include <errno.h>
  54 #include <fcntl.h>
  55 #include <stdio.h>
  56 #include <stdlib.h>
  57 #include <string.h>
  58 #include <unistd.h>
  59 #endif
  60
  61 #include "db_int.h"
  62 #include "common_ext.h"
  63
  64 static int __db_rmap __P((DB_ENV *, int, size_t, void *));
  65
  66 /*
  67  * __db_rcreate --
  68  *
  69  * Common interface for creating a shared region.  Handles synchronization
  70  * across multiple processes.
  71  *
  72  * The dbenv contains the environment for this process, including naming
  73  * information.  The path argument represents the parameters passed to
  74  * the open routines and may be either a file or a directory.  If it is
  75  * a directory, it must exist.  If it is a file, then the file parameter
  76  * must be NULL, otherwise, file is the name to be created inside the
  77  * directory path.
  78  *
  79  * The function returns a pointer to the shared region that has been mapped
  80  * into memory, NULL on error.
  81  *
  82  * PUBLIC: int __db_rcreate __P((DB_ENV *, APPNAME,
  83  * PUBLIC:    const char *, const char *, int, size_t, int *, void *));
  84  */
  85 int
  86 __db_rcreate(dbenv, appname, path, file, mode, size, fdp, retp)
  87         DB_ENV *dbenv;
  88         APPNAME appname;
  89         const char *path, *file;
  90         int mode, *fdp;
  91         size_t size;
  92         void *retp;
  93 {
  94         RLAYOUT *rp;
  95         int fd, ret;
  96         char *name;
  97
  98         fd = -1;
  99         rp = NULL;
 100
 101         /*
 102          * Get the filename -- note, if it's a temporary file, it will
 103          * be created by the underlying temporary file creation code,
 104          * so we have to check the file descriptor to be sure it's an
 105          * error.
 106          */
 107         if ((ret = __db_appname(dbenv, appname, path, file, &fd, &name)) != 0)
 108                 return (ret);
 109
 110         /*
 111          * Now open the file. We need to make sure that multiple processes
 112          * that attempt to create the region at the same time are properly
 113          * ordered, so we open it O_EXCL and O_CREAT so two simultaneous
 114          * attempts to create the region will return failure in one of the
 115          * attempts.
 116          */
 117         if (fd == -1 && (ret = __db_open(name,
 118             DB_CREATE | DB_EXCL, DB_CREATE | DB_EXCL, mode, &fd)) != 0) {
 119                 if (ret != EEXIST)
 120                         __db_err(dbenv,
 121                             "region create: %s: %s", name, strerror(ret));
 122                 goto err;
 123         }
 124         *fdp = fd;
 125
 126         /* Grow the region to the correct size. */
 127         if ((ret = __db_rgrow(dbenv, fd, size)) != 0)
 128                 goto err;
 129
 130         /* Map the region in. */
 131         if ((ret = __db_rmap(dbenv, fd, size, &rp)) != 0)
 132                 goto err;
 133
 134         /* Initialize the region. */
 135         if ((ret = __db_rinit(dbenv, rp, fd, size, 1)) != 0)
 136                 goto err;
 137
 138         if (name != NULL)
 139                 FREES(name);
 140
 141         *(void **)retp = rp;
 142         return (0);
 143
 144 err:    if (fd != -1) {
 145                 if (rp != NULL)
 146                         (void)__db_unmap(rp, rp->size);
 147                 (void)__db_unlink(name);
 148                 (void)__db_close(fd);
 149         }
 150         if (name != NULL)
 151                 FREES(name);
 152         return (ret);
 153 }
 154
 155 /*
 156  * __db_rinit --
 157  *      Initialize the region.
 158  *
 159  * PUBLIC: int __db_rinit __P((DB_ENV *, RLAYOUT *, int, size_t, int));
 160  */
 161 int
 162 __db_rinit(dbenv, rp, fd, size, lock_region)
 163         DB_ENV *dbenv;
 164         RLAYOUT *rp;
 165         size_t size;
 166         int fd, lock_region;
 167 {
 168         int ret;
 169
 170         /*
 171          * Initialize the common information.
 172          *
 173          * !!!
 174          * We have to order the region creates so that two processes don't try
 175          * to simultaneously create the region and so that processes that are
 176          * joining the region never see inconsistent data.  We'd like to play
 177          * file permissions games, but we can't because WNT filesystems won't
 178          * open a file mode 0.
 179          *
 180          * If the lock_region flag is set, the process creating the region
 181          * acquires the lock before the setting the version number.  Any
 182          * process joining the region checks the version number before
 183          * attempting to acquire the lock.  (The lock_region flag may not be
 184          * set -- the mpool code sometimes malloc's private regions but still
 185          * needs to initialize them, specifically, the mutex for threads.)
 186          *
 187          * We have to check the version number first, because if the version
 188          * number has not been written, it's possible that the mutex has not
 189          * been initialized in which case an attempt to get it could lead to
 190          * random behavior.  If the version number isn't there (the file size
 191          * is too small) or it's 0, we know that the region is being created.
 192          */
 193         __db_mutex_init(&rp->lock, MUTEX_LOCK_OFFSET(rp, &rp->lock));
 194         if (lock_region && (ret = __db_mutex_lock(&rp->lock, fd)) != 0)
 195                 return (ret);
 196
 197         rp->refcnt = 1;
 198         rp->size = size;
 199         rp->flags = 0;
 200         db_version(&rp->majver, &rp->minver, &rp->patch);
 201
 202         return (0);
 203 }
 204
 205 /*
 206  * __db_ropen --
 207  *      Construct the name of a file, open it and map it in.
 208  *
 209  * PUBLIC: int __db_ropen __P((DB_ENV *,
 210  * PUBLIC:    APPNAME, const char *, const char *, int, int *, void *));
 211  */
 212 int
 213 __db_ropen(dbenv, appname, path, file, flags, fdp, retp)
 214         DB_ENV *dbenv;
 215         APPNAME appname;
 216         const char *path, *file;
 217         int flags, *fdp;
 218         void *retp;
 219 {
 220         RLAYOUT *rp;
 221         off_t size1, size2;
 222         int fd, ret;
 223         char *name;
 224
 225         fd = -1;
 226         rp = NULL;
 227
 228         /* Get the filename. */
 229         if ((ret = __db_appname(dbenv, appname, path, file, NULL, &name)) != 0)
 230                 return (ret);
 231
 232         /* Open the file. */
 233         if ((ret = __db_open(name, flags, DB_MUTEXDEBUG, 0, &fd)) != 0) {
 234                 __db_err(dbenv, "region open: %s: %s", name, strerror(ret));
 235                 goto err2;
 236         }
 237
 238         *fdp = fd;
 239
 240         /*
 241          * Map the file in.  We have to do things in a strange order so that
 242          * we don't get into a situation where the file was just created and
 243          * isn't yet initialized.  See the comment in __db_rcreate() above.
 244          *
 245          * XXX
 246          * We'd like to test to see if the file is too big to mmap.  Since we
 247          * don't know what size or type off_t's or size_t's are, or the largest
 248          * unsigned integral type is, or what random insanity the local C
 249          * compiler will perpetrate, doing the comparison in a portable way is
 250          * flatly impossible.  Hope that mmap fails if the file is too large.
 251          *
 252          */
 253         if ((ret = __db_ioinfo(name, fd, &size1, NULL)) != 0) {
 254                 __db_err(dbenv, "%s: %s", name, strerror(ret));
 255                 goto err2;
 256         }
 257
 258         /* Check to make sure the first block has been written. */
 259         if ((size_t)size1 < sizeof(RLAYOUT)) {
 260                 ret = EAGAIN;
 261                 goto err2;
 262         }
 263
 264         /* Map in whatever is there. */
 265         if ((ret = __db_rmap(dbenv, fd, size1, &rp)) != 0)
 266                 goto err2;
 267
 268         /*
 269          * Check to make sure the region has been initialized.  We can't just
 270          * grab the lock because the lock may not have been initialized yet.
 271          */
 272         if (rp->majver == 0) {
 273                 ret = EAGAIN;
 274                 goto err2;
 275         }
 276
 277         /* Get the region lock. */
 278         if (!LF_ISSET(DB_MUTEXDEBUG))
 279                 (void)__db_mutex_lock(&rp->lock, fd);
 280
 281         /*
 282          * The file may have been half-written if we were descheduled between
 283          * getting the size of the file and checking the major version.  Check
 284          * to make sure we got the entire file.
 285          */
 286         if ((ret = __db_ioinfo(name, fd, &size2, NULL)) != 0) {
 287                 __db_err(dbenv, "%s: %s", name, strerror(ret));
 288                 goto err1;
 289         }
 290         if (size1 != size2) {
 291                 ret = EAGAIN;
 292                 goto err1;
 293         }
 294
 295         /* The file may have just been deleted. */
 296         if (F_ISSET(rp, DB_R_DELETED)) {
 297                 ret = EAGAIN;
 298                 goto err1;
 299         }
 300
 301         /* Increment the reference count. */
 302         ++rp->refcnt;
 303
 304         /* Release the lock. */
 305         if (!LF_ISSET(DB_MUTEXDEBUG))
 306                 (void)__db_mutex_unlock(&rp->lock, fd);
 307
 308         FREES(name);
 309
 310         *(void **)retp = rp;
 311         return (0);
 312
 313 err1:   if (!LF_ISSET(DB_MUTEXDEBUG))
 314                 (void)__db_mutex_unlock(&rp->lock, fd);
 315 err2:   if (rp != NULL)
 316                 (void)__db_unmap(rp, rp->size);
 317         if (fd != -1)
 318                 (void)__db_close(fd);
 319         FREES(name);
 320         return (ret);
 321 }
 322
 323 /*
 324  * __db_rclose --
 325  *      Close a shared memory region.
 326  *
 327  * PUBLIC: int __db_rclose __P((DB_ENV *, int, void *));
 328  */
 329 int
 330 __db_rclose(dbenv, fd, ptr)
 331         DB_ENV *dbenv;
 332         int fd;
 333         void *ptr;
 334 {
 335         RLAYOUT *rp;
 336         int ret, t_ret;
 337         const char *fail;
 338
 339         rp = ptr;
 340         fail = NULL;
 341
 342         /* Get the lock. */
 343         if ((ret = __db_mutex_lock(&rp->lock, fd)) != 0) {
 344                 fail = "lock get";
 345                 goto err;
 346         }
 347
 348         /* Decrement the reference count. */
 349         --rp->refcnt;
 350
 351         /* Release the lock. */
 352         if ((t_ret = __db_mutex_unlock(&rp->lock, fd)) != 0 && fail == NULL) {
 353                 ret = t_ret;
 354                 fail = "lock release";
 355         }
 356
 357         /* Discard the region. */
 358         if ((t_ret = __db_unmap(ptr, rp->size)) != 0 && fail == NULL) {
 359                 ret = t_ret;
 360                 fail = "munmap";
 361         }
 362
 363         if ((t_ret = __db_close(fd)) != 0 && fail == NULL) {
 364                 ret = t_ret;
 365                 fail = "close";
 366         }
 367
 368         if (fail == NULL)
 369                 return (0);
 370
 371 err:    __db_err(dbenv, "region detach: %s: %s", fail, strerror(ret));
 372         return (ret);
 373 }
 374
 375 /*
 376  * __db_runlink --
 377  *      Remove a shared memory region.
 378  *
 379  * PUBLIC: int __db_runlink __P((DB_ENV *,
 380  * PUBLIC:    APPNAME, const char *, const char *, int));
 381  */
 382 int
 383 __db_runlink(dbenv, appname, path, file, force)
 384         DB_ENV *dbenv;
 385         APPNAME appname;
 386         const char *path, *file;
 387         int force;
 388 {
 389         RLAYOUT *rp;
 390         int cnt, fd, ret, t_ret;
 391         char *name;
 392
 393         rp = NULL;
 394
 395         /* Get the filename. */
 396         if ((ret = __db_appname(dbenv, appname, path, file, NULL, &name)) != 0)
 397                 return (ret);
 398
 399         /* If the file doesn't exist, we're done. */
 400         if (__db_exists(name, NULL))
 401                 return (0);             /* XXX: ENOENT? */
 402
 403         /*
 404          * If we're called with a force flag, try and unlink the file.  This
 405          * may not succeed if the file is currently open, but there's nothing
 406          * we can do about that.  There is a race condition between the check
 407          * for existence above and the actual unlink.  If someone else snuck
 408          * in and removed it before we do the remove, then we might get an
 409          * ENOENT error.  If we get the ENOENT, we treat it as success, just
 410          * as we do above.
 411          */
 412         if (force) {
 413                 if ((ret = __db_unlink(name)) != 0 && ret != ENOENT)
 414                         goto err1;
 415                 FREES(name);
 416                 return (0);
 417         }
 418
 419         /* Open and lock the region. */
 420         if ((ret = __db_ropen(dbenv, appname, path, file, 0, &fd, &rp)) != 0)
 421                 goto err1;
 422         (void)__db_mutex_lock(&rp->lock, fd);
 423
 424         /* If the region is currently being deleted, fail. */
 425         if (F_ISSET(rp, DB_R_DELETED)) {
 426                 ret = ENOENT;           /* XXX: ENOENT? */
 427                 goto err2;
 428         }
 429
 430         /* If the region is currently in use by someone else, fail. */
 431         if (rp->refcnt > 1) {
 432                 ret = EBUSY;
 433                 goto err2;
 434         }
 435
 436         /* Set the delete flag. */
 437         F_SET(rp, DB_R_DELETED);
 438
 439         /* Release the lock and close the region. */
 440         (void)__db_mutex_unlock(&rp->lock, fd);
 441         if ((t_ret = __db_rclose(dbenv, fd, rp)) != 0 && ret == 0)
 442                 goto err1;
 443
 444         /*
 445          * Unlink the region.  There's a race here -- other threads or
 446          * processes might be opening the region while we're trying to
 447          * remove it.  They'll fail, because we've set the DELETED flag,
 448          * but they could still stop us from succeeding in the unlink.
 449          */
 450         for (cnt = 5; cnt > 0; --cnt) {
 451                 if ((ret = __db_unlink(name)) == 0)
 452                         break;
 453                 (void)__db_sleep(0, 250000);
 454         }
 455         if (ret == 0) {
 456                 FREES(name);
 457                 return (0);
 458         }
 459
 460         /* Not a clue.  Try to clear the DB_R_DELETED flag. */
 461         if ((ret = __db_ropen(dbenv, appname, path, file, 0, &fd, &rp)) != 0)
 462                 goto err1;
 463         (void)__db_mutex_lock(&rp->lock, fd);
 464         F_CLR(rp, DB_R_DELETED);
 465         /* FALLTHROUGH */
 466
 467 err2:   (void)__db_mutex_unlock(&rp->lock, fd);
 468         (void)__db_rclose(dbenv, fd, rp);
 469 err1:   __db_err(dbenv, "region unlink: %s: %s", name, strerror(ret));
 470         FREES(name);
 471         return (ret);
 472 }
 473
 474 /*
 475  * DB creates all regions on 4K boundaries so that we don't make the
 476  * underlying VM unhappy.
 477  */
 478 #define __DB_VMPAGESIZE (4 * 1024)
 479
 480 /*
 481  * __db_rgrow --
 482  *      Extend a region by a specified amount.
 483  *
 484  * PUBLIC: int __db_rgrow __P((DB_ENV *, int, size_t));
 485  */
 486 int
 487 __db_rgrow(dbenv, fd, incr)
 488         DB_ENV *dbenv;
 489         int fd;
 490         size_t incr;
 491 {
 492 #ifdef MMAP_INIT_NEEDED
 493         size_t i;
 494 #endif
 495         ssize_t nw;
 496         int ret;
 497         char buf[__DB_VMPAGESIZE];
 498
 499         /* Seek to the end of the region. */
 500         if ((ret = __db_seek(fd, 0, 0, 0, SEEK_END)) != 0)
 501                 goto err;
 502
 503         /* Write nuls to the new bytes. */
 504         memset(buf, 0, sizeof(buf));
 505
 506         /*
 507          * Historically, some systems required that all of the bytes of the
 508          * region be written before you could mmap it and access it randomly.
 509          */
 510 #ifdef MMAP_INIT_NEEDED
 511         /* Extend the region by writing each new page. */
 512         for (i = 0; i < incr; i += __DB_VMPAGESIZE) {
 513                 if ((ret = __db_write(fd, buf, sizeof(buf), &nw)) != 0)
 514                         goto err;
 515                 if (nw != sizeof(buf))
 516                         goto eio;
 517         }
 518 #else
 519         /*
 520          * Extend the region by writing the last page.
 521          *
 522          * Round off the increment to the next page boundary.
 523          */
 524         incr += __DB_VMPAGESIZE - 1;
 525         incr -= incr % __DB_VMPAGESIZE;
 526
 527         /* Write the last page, not the page after the last. */
 528         if ((ret = __db_seek(fd, 0, 0, incr - __DB_VMPAGESIZE, SEEK_CUR)) != 0)
 529                 goto err;
 530         if ((ret = __db_write(fd, buf, sizeof(buf), &nw)) != 0)
 531                 goto err;
 532         if (nw != sizeof(buf))
 533                 goto eio;
 534 #endif
 535         return (0);
 536
 537 eio:    ret = EIO;
 538 err:    __db_err(dbenv, "region grow: %s", strerror(ret));
 539         return (ret);
 540 }
 541
 542 /*
 543  * __db_rremap --
 544  *      Unmap the old region and map in a new region of a new size.  If
 545  *      either call fails, returns NULL, else returns the address of the
 546  *      new region.
 547  *
 548  * PUBLIC: int __db_rremap __P((DB_ENV *, void *, size_t, size_t, int, void *));
 549  */
 550 int
 551 __db_rremap(dbenv, ptr, oldsize, newsize, fd, retp)
 552         DB_ENV *dbenv;
 553         void *ptr, *retp;
 554         size_t oldsize, newsize;
 555         int fd;
 556 {
 557         int ret;
 558
 559         if ((ret = __db_unmap(ptr, oldsize)) != 0) {
 560                 __db_err(dbenv, "region remap: munmap: %s", strerror(ret));
 561                 return (ret);
 562         }
 563
 564         return (__db_rmap(dbenv, fd, newsize, retp));
 565 }
 566
 567 /*
 568  * __db_rmap --
 569  *      Attach to a shared memory region.
 570  */
 571 static int
 572 __db_rmap(dbenv, fd, size, retp)
 573         DB_ENV *dbenv;
 574         int fd;
 575         size_t size;
 576         void *retp;
 577 {
 578         RLAYOUT *rp;
 579         int ret;
 580
 581         if ((ret = __db_map(fd, size, 0, 0, (void **)&rp)) != 0) {
 582                 __db_err(dbenv, "region map: mmap %s", strerror(ret));
 583                 return (ret);
 584         }
 585         if (rp->size < size)
 586                 rp->size = size;
 587
 588         *(void **)retp = rp;
 589         return (0);
 590 }