86d79a8148e6310ff1a4d7fbd82adeca3a43dff0
[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.13 (Sleepycat) 8/27/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_fdopen(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         /*
135          * Initialize the common information.
136          *
137          * !!!
138          * We have to order the region creates so that two processes don't try
139          * to simultaneously create the region and so that processes that are
140          * joining the region never see inconsistent data.  We'd like to play
141          * file permissions games, but we can't because WNT filesystems won't
142          * open a file mode 0.
143          *
144          * So, the process that's creating the region always acquires the lock
145          * before the setting the version number.  Any process joining always
146          * checks the version number before attempting to acquire the lock.
147          *
148          * We have to check the version number first, because if the version
149          * number has not been written, it's possible that the mutex has not
150          * been initialized in which case an attempt to get it could lead to
151          * random behavior.  If the version number isn't there (the file size
152          * is too small) or it's 0, we know that the region is being created.
153          */
154         (void)__db_mutex_init(&rp->lock, MUTEX_LOCK_OFFSET(rp, &rp->lock));
155         (void)__db_mutex_lock(&rp->lock,
156             fd, dbenv == NULL ? NULL : dbenv->db_yield);
157
158         rp->refcnt = 1;
159         rp->size = size;
160         rp->flags = 0;
161         db_version(&rp->majver, &rp->minver, &rp->patch);
162
163         if (name != NULL)
164                 FREES(name);
165
166         *(void **)retp = rp;
167         return (0);
168
169 err:    if (fd != -1) {
170                 if (rp != NULL)
171                         (void)__db_munmap(rp, rp->size);
172                 (void)__db_unlink(name);
173                 (void)__db_close(fd);
174         }
175         if (name != NULL)
176                 FREES(name);
177         return (ret);
178 }
179
180 /*
181  * __db_ropen --
182  *      Construct the name of a file, open it and map it in.
183  *
184  * PUBLIC: int __db_ropen __P((DB_ENV *,
185  * PUBLIC:    APPNAME, const char *, const char *, int, int *, void *));
186  */
187 int
188 __db_ropen(dbenv, appname, path, file, flags, fdp, retp)
189         DB_ENV *dbenv;
190         APPNAME appname;
191         const char *path, *file;
192         int flags, *fdp;
193         void *retp;
194 {
195         RLAYOUT *rp;
196         off_t size1, size2;
197         int fd, ret;
198         char *name;
199
200         fd = -1;
201         rp = NULL;
202
203         /* Get the filename. */
204         if ((ret = __db_appname(dbenv, appname, path, file, NULL, &name)) != 0)
205                 return (ret);
206
207         /* Open the file. */
208         if ((ret = __db_fdopen(name, flags, DB_MUTEXDEBUG, 0, &fd)) != 0) {
209                 __db_err(dbenv, "region open: %s: %s", name, strerror(ret));
210                 goto err2;
211         }
212
213         *fdp = fd;
214
215         /*
216          * Map the file in.  We have to do things in a strange order so that
217          * we don't get into a situation where the file was just created and
218          * isn't yet initialized.  See the comment in __db_rcreate() above.
219          *
220          * XXX
221          * We'd like to test to see if the file is too big to mmap.  Since we
222          * don't know what size or type off_t's or size_t's are, or the largest
223          * unsigned integral type is, or what random insanity the local C
224          * compiler will perpetrate, doing the comparison in a portable way is
225          * flatly impossible.  Hope that mmap fails if the file is too large.
226          *
227          */
228         if ((ret = __db_stat(dbenv, name, fd, &size1, NULL)) != 0)
229                 goto err2;
230
231         /* Check to make sure the first block has been written. */
232         if ((size_t)size1 < sizeof(RLAYOUT)) {
233                 ret = EAGAIN;
234                 goto err2;
235         }
236
237         /* Map in whatever is there. */
238         if ((ret = __db_rmap(dbenv, fd, size1, &rp)) != 0)
239                 goto err2;
240
241         /*
242          * Check to make sure the region has been initialized.  We can't just
243          * grab the lock because the lock may not have been initialized yet.
244          */
245         if (rp->majver == 0) {
246                 ret = EAGAIN;
247                 goto err2;
248         }
249
250         /* Get the region lock. */
251         if (!LF_ISSET(DB_MUTEXDEBUG))
252                 (void)__db_mutex_lock(&rp->lock,
253                     fd, dbenv == NULL ? NULL : dbenv->db_yield);
254
255         /*
256          * The file may have been half-written if we were descheduled between
257          * getting the size of the file and checking the major version.  Check
258          * to make sure we got the entire file.
259          */
260         if ((ret = __db_stat(dbenv, name, fd, &size2, NULL)) != 0)
261                 goto err1;
262         if (size1 != size2) {
263                 ret = EAGAIN;
264                 goto err1;
265         }
266
267         /* The file may have just been deleted. */
268         if (F_ISSET(rp, DB_R_DELETED)) {
269                 ret = EAGAIN;
270                 goto err1;
271         }
272
273         /* Increment the reference count. */
274         ++rp->refcnt;
275
276         /* Release the lock. */
277         if (!LF_ISSET(DB_MUTEXDEBUG))
278                 (void)__db_mutex_unlock(&rp->lock, fd);
279
280         FREES(name);
281
282         *(void **)retp = rp;
283         return (0);
284
285 err1:   if (!LF_ISSET(DB_MUTEXDEBUG))
286                 (void)__db_mutex_unlock(&rp->lock, fd);
287 err2:   if (rp != NULL)
288                 (void)__db_munmap(rp, rp->size);
289         if (fd != -1)
290                 (void)__db_close(fd);
291         FREES(name);
292         return (ret);
293 }
294
295 /*
296  * __db_rclose --
297  *      Close a shared memory region.
298  *
299  * PUBLIC: int __db_rclose __P((DB_ENV *, int, void *));
300  */
301 int
302 __db_rclose(dbenv, fd, ptr)
303         DB_ENV *dbenv;
304         int fd;
305         void *ptr;
306 {
307         RLAYOUT *rp;
308         int ret, t_ret;
309         const char *fail;
310
311         rp = ptr;
312         fail = NULL;
313
314         /* Get the lock. */
315         if ((ret = __db_mutex_lock(&rp->lock,
316             fd, dbenv == NULL ? NULL : dbenv->db_yield)) != 0) {
317                 fail = "lock get";
318                 goto err;
319         }
320
321         /* Decrement the reference count. */
322         --rp->refcnt;
323
324         /* Release the lock. */
325         if ((t_ret = __db_mutex_unlock(&rp->lock, fd)) != 0 && fail == NULL) {
326                 ret = t_ret;
327                 fail = "lock release";
328         }
329
330         /* Discard the region. */
331         if ((t_ret = __db_munmap(ptr, rp->size)) != 0 && fail == NULL) {
332                 ret = t_ret;
333                 fail = "munmap";
334         }
335
336         if ((t_ret = __db_close(fd)) != 0 && fail == NULL) {
337                 ret = t_ret;
338                 fail = "close";
339         }
340
341         if (fail == NULL)
342                 return (0);
343
344 err:    __db_err(dbenv, "region detach: %s: %s", fail, strerror(ret));
345         return (ret);
346 }
347
348 /*
349  * __db_runlink --
350  *      Remove a shared memory region.
351  *
352  * PUBLIC: int __db_runlink __P((DB_ENV *,
353  * PUBLIC:    APPNAME, const char *, const char *, int));
354  */
355 int
356 __db_runlink(dbenv, appname, path, file, force)
357         DB_ENV *dbenv;
358         APPNAME appname;
359         const char *path, *file;
360         int force;
361 {
362         RLAYOUT *rp;
363         int cnt, fd, ret, t_ret;
364         char *name;
365
366         rp = NULL;
367
368         /* Get the filename. */
369         if ((ret = __db_appname(dbenv, appname, path, file, NULL, &name)) != 0)
370                 return (ret);
371
372         /* If the file doesn't exist, we're done. */
373         if (__db_exists(name, NULL))
374                 return (0);             /* XXX: ENOENT? */
375
376         /*
377          * If we're called with a force flag, try and unlink the file.  This
378          * may not succeed if the file is currently open, but there's nothing
379          * we can do about that.  There is a race condition between the check
380          * for existence above and the actual unlink.  If someone else snuck
381          * in and removed it before we do the remove, then we might get an
382          * ENOENT error.  If we get the ENOENT, we treat it as success, just
383          * as we do above.
384          */
385         if (force) {
386                 if ((ret = __db_unlink(name)) != 0 && ret != ENOENT)
387                         goto err1;
388                 FREES(name);
389                 return (0);
390         }
391
392         /* Open and lock the region. */
393         if ((ret = __db_ropen(dbenv, appname, path, file, 0, &fd, &rp)) != 0)
394                 goto err1;
395         (void)__db_mutex_lock(&rp->lock,
396             fd, dbenv == NULL ? NULL : dbenv->db_yield);
397
398         /* If the region is currently being deleted, fail. */
399         if (F_ISSET(rp, DB_R_DELETED)) {
400                 ret = ENOENT;           /* XXX: ENOENT? */
401                 goto err2;
402         }
403
404         /* If the region is currently in use by someone else, fail. */
405         if (rp->refcnt > 1) {
406                 ret = EBUSY;
407                 goto err2;
408         }
409
410         /* Set the delete flag. */
411         F_SET(rp, DB_R_DELETED);
412
413         /* Release the lock and close the region. */
414         (void)__db_mutex_unlock(&rp->lock, fd);
415         if ((t_ret = __db_rclose(dbenv, fd, rp)) != 0 && ret == 0)
416                 goto err1;
417
418         /*
419          * Unlink the region.  There's a race here -- other threads or
420          * processes might be opening the region while we're trying to
421          * remove it.  They'll fail, because we've set the DELETED flag,
422          * but they could still stop us from succeeding in the unlink.
423          */
424         for (cnt = 5; cnt > 0; --cnt) {
425                 if ((ret = __db_unlink(name)) == 0)
426                         break;
427                 (void)__db_sleep(0, 250000);
428         }
429         if (ret == 0) {
430                 FREES(name);
431                 return (0);
432         }
433
434         /* Not a clue.  Try to clear the DB_R_DELETED flag. */
435         if ((ret = __db_ropen(dbenv, appname, path, file, 0, &fd, &rp)) != 0)
436                 goto err1;
437         (void)__db_mutex_lock(&rp->lock,
438             fd, dbenv == NULL ? NULL : dbenv->db_yield);
439         F_CLR(rp, DB_R_DELETED);
440         /* FALLTHROUGH */
441
442 err2:   (void)__db_mutex_unlock(&rp->lock, fd);
443         (void)__db_rclose(dbenv, fd, rp);
444 err1:   __db_err(dbenv, "region unlink: %s: %s", name, strerror(ret));
445         FREES(name);
446         return (ret);
447 }
448
449 /*
450  * DB creates all regions on 4K boundaries so that we don't make the
451  * underlying VM unhappy.
452  */
453 #define __DB_VMPAGESIZE (4 * 1024)
454
455 /*
456  * __db_rgrow --
457  *      Extend a region by a specified amount.
458  *
459  * PUBLIC: int __db_rgrow __P((DB_ENV *, int, size_t));
460  */
461 int
462 __db_rgrow(dbenv, fd, incr)
463         DB_ENV *dbenv;
464         int fd;
465         size_t incr;
466 {
467 #ifdef MMAP_INIT_NEEDED
468         size_t i;
469 #endif
470         ssize_t nw;
471         int ret;
472         char buf[__DB_VMPAGESIZE];
473
474         /* Seek to the end of the region. */
475         if ((ret = __db_lseek(fd, 0, 0, 0, SEEK_END)) != 0)
476                 goto err;
477
478         /* Write nuls to the new bytes. */
479         memset(buf, 0, sizeof(buf));
480
481         /*
482          * Historically, some systems required that all of the bytes of the
483          * region be written before you could mmap it and access it randomly.
484          */
485 #ifdef MMAP_INIT_NEEDED
486         /* Extend the region by writing each new page. */
487         for (i = 0; i < incr; i += __DB_VMPAGESIZE) {
488                 if ((ret = __db_write(fd, buf, sizeof(buf), &nw)) != 0)
489                         goto err;
490                 if (nw != sizeof(buf))
491                         goto eio;
492         }
493 #else
494         /*
495          * Extend the region by writing the last page.
496          *
497          * Round off the increment to the next page boundary.
498          */
499         incr += __DB_VMPAGESIZE - 1;
500         incr -= incr % __DB_VMPAGESIZE;
501
502         /* Write the last page, not the page after the last. */
503         if ((ret = __db_lseek(fd, 0, 0, incr - __DB_VMPAGESIZE, SEEK_CUR)) != 0)
504                 goto err;
505         if ((ret = __db_write(fd, buf, sizeof(buf), &nw)) != 0)
506                 goto err;
507         if (nw != sizeof(buf))
508                 goto eio;
509 #endif
510         return (0);
511
512 eio:    ret = EIO;
513 err:    __db_err(dbenv, "region grow: %s", strerror(ret));
514         return (ret);
515 }
516
517 /*
518  * __db_rremap --
519  *      Unmap the old region and map in a new region of a new size.  If
520  *      either call fails, returns NULL, else returns the address of the
521  *      new region.
522  *
523  * PUBLIC: int __db_rremap __P((DB_ENV *, void *, size_t, size_t, int, void *));
524  */
525 int
526 __db_rremap(dbenv, ptr, oldsize, newsize, fd, retp)
527         DB_ENV *dbenv;
528         void *ptr, *retp;
529         size_t oldsize, newsize;
530         int fd;
531 {
532         int ret;
533
534         if ((ret = __db_munmap(ptr, oldsize)) != 0) {
535                 __db_err(dbenv, "region remap: munmap: %s", strerror(ret));
536                 return (ret);
537         }
538
539         return (__db_rmap(dbenv, fd, newsize, retp));
540 }
541
542 /*
543  * __db_rmap --
544  *      Attach to a shared memory region.
545  */
546 static int
547 __db_rmap(dbenv, fd, size, retp)
548         DB_ENV *dbenv;
549         int fd;
550         size_t size;
551         void *retp;
552 {
553         RLAYOUT *rp;
554         int ret;
555
556         if ((ret = __db_mmap(fd, size, 0, 0, &rp)) != 0) {
557                 __db_err(dbenv, "region map: mmap %s", strerror(ret));
558                 return (ret);
559         }
560         if (rp->size < size)
561                 rp->size = size;
562
563         *(void **)retp = rp;
564         return (0);
565 }