Update from db-2.3.12.
[kopensolaris-gnu/glibc.git] / 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 }