git.ozlabs.org Git - ccan/blob - ccan/rszshm/rszshm.c

   1 /* Licensed under Apache License v2.0 - see LICENSE file for details */
   2 #include "config.h"
   3 #include "rszshm.h"
   4
   5 #define _XOPEN_SOURCE 700
   6 #include <assert.h>
   7 #include <errno.h>
   8 #include <fcntl.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <unistd.h>
  12 #include <sys/mman.h>
  13 #include <sys/file.h>
  14
  15 #define pgup(x, pgsz) (((x) + (pgsz) - 1) & ~((pgsz) - 1))
  16
  17 void *rszshm_mk(struct rszshm *r, size_t flen, const char *fname, struct rszshm_scan scan)
  18 {
  19         long pgsz = sysconf(_SC_PAGE_SIZE);
  20         int i, errno_;
  21         char *m, *tgt, *p = NULL;
  22
  23         if (!r || flen == 0 || scan.len < flen + sizeof(*r->hdr) ||
  24             !scan.start || scan.len == 0 || scan.hop == 0 || scan.iter == 0 ||
  25             (fname && strnlen(fname, RSZSHM_PATH_MAX) == RSZSHM_PATH_MAX)) {
  26                 errno = EINVAL;
  27                 return NULL;
  28         }
  29
  30         *r = (typeof(*r)) { -1, 0, "", NULL, NULL };
  31         strcpy(r->fname, fname ? fname : RSZSHM_DFLT_FNAME);
  32
  33         flen = pgup(flen + sizeof(*r->hdr), pgsz);
  34         scan.len = pgup(scan.len, pgsz);
  35
  36         for (i = 1, tgt = scan.start; i <= scan.iter; i++) {
  37                 m = mmap(tgt, scan.len, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON|MAP_NORESERVE, -1, 0);
  38                 if (m == MAP_FAILED)
  39                         return NULL;
  40                 if (m == tgt)
  41                         break;
  42                 munmap(m, scan.len);
  43                 m = NULL;
  44                 tgt += (i % 2 == 0 ? 1 : -1) * i * scan.hop;
  45         }
  46         if (!m) {
  47                 errno = ENOSPC;
  48                 return NULL;
  49         }
  50
  51         if ((p = strstr(r->fname, "XXXXXX/")) != NULL) {
  52                 p += 6;
  53                 *p = '\0';
  54                 if (!mkdtemp(r->fname))
  55                         goto err;
  56                 *p = '/';
  57         }
  58
  59         if ((r->fd = open(r->fname, O_CREAT|O_EXCL|O_RDWR, p ? 0600 : 0666)) == -1)
  60                 goto err;
  61
  62         if (ftruncate(r->fd, flen) == -1)
  63                 goto err;
  64
  65         if (mmap(m, flen, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, r->fd, 0) == MAP_FAILED)
  66                 goto err;
  67
  68         *(r->hdr = (typeof(r->hdr)) m) = (typeof(*r->hdr)) { flen, scan.len, m };
  69
  70         if (msync(m, sizeof(*r->hdr), MS_SYNC) == -1)
  71                 goto err;
  72
  73         r->flen = flen;
  74         r->cap = flen - sizeof(*r->hdr);
  75         r->dat = m + sizeof(*r->hdr);
  76
  77         return r->dat;
  78
  79 err:
  80         errno_ = errno;
  81         if (m && m != MAP_FAILED)
  82                 munmap(m, scan.len);
  83         if (r->fd != -1) {
  84                 close(r->fd);
  85                 unlink(r->fname);
  86         }
  87         if (p) {
  88                 *p = '\0';
  89                 rmdir(r->fname);
  90                 *p = '/';
  91         }
  92         errno = errno_;
  93         return NULL;
  94 }
  95
  96 void *rszshm_at(struct rszshm *r, const char *fname)
  97 {
  98         struct rszshm_hdr h;
  99         int fd = -1, ret, errno_;
 100         char *m = NULL;
 101
 102         if (!r || !fname || !fname[0] ||
 103             strnlen(fname, RSZSHM_PATH_MAX) == RSZSHM_PATH_MAX) {
 104                 errno = EINVAL;
 105                 return NULL;
 106         }
 107
 108         if ((fd = open(fname, O_RDWR)) == -1)
 109                 return NULL;
 110
 111         if ((ret = read(fd, &h, sizeof(h))) == -1)
 112                 goto err;
 113
 114         if (ret != sizeof(h) || !h.addr || h.flen == 0 || h.max == 0) {
 115                 errno = ENODATA;
 116                 goto err;
 117         }
 118
 119         m = mmap(h.addr, h.max, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON|MAP_NORESERVE, -1, 0);
 120         if (m == MAP_FAILED)
 121                 goto err;
 122         if (m != h.addr) {
 123                 errno = ENOSPC;
 124                 goto err;
 125         }
 126
 127         if (mmap(m, h.flen, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, 0) == MAP_FAILED)
 128                 goto err;
 129
 130         *r = (typeof(*r)) { .fd = fd, .flen = h.flen, .hdr = (typeof(r->hdr)) m,
 131                             .dat = m + sizeof(h), .cap = h.flen - sizeof(h) };
 132         strcpy(r->fname, fname);
 133
 134         return r->dat;
 135
 136 err:
 137         errno_ = errno;
 138         if (m && m != MAP_FAILED)
 139                 munmap(m, h.max);
 140         close(fd);
 141         errno = errno_;
 142         return NULL;
 143 }
 144
 145 #undef rszshm_up
 146 int rszshm_up(struct rszshm *r)
 147 {
 148         size_t flen;
 149
 150         assert(r);
 151
 152         flen = r->hdr->flen;
 153         if (r->flen == flen)
 154                 return 0;
 155         if (mmap(r->hdr, flen, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, r->fd, 0) == MAP_FAILED)
 156                 return -1;
 157
 158         r->flen = flen;
 159         r->cap = flen - sizeof(*r->hdr);
 160         return 1;
 161 }
 162
 163 int rszshm_grow(struct rszshm *r)
 164 {
 165         int ret;
 166         assert(r);
 167
 168         if ((ret = rszshm_up(r)) != 0)
 169                 return ret;
 170
 171         if (r->flen == r->hdr->max) {
 172                 errno = ENOMEM;
 173                 return -1;
 174         }
 175
 176         if (flock(r->fd, LOCK_EX) == -1)
 177                 return -1;
 178
 179         if ((ret = rszshm_up(r)) == 0) {
 180                 int flen = r->hdr->flen * 2 < r->hdr->max ? r->hdr->flen * 2 : r->hdr->max;
 181
 182                 if (ftruncate(r->fd, flen) != -1 &&
 183                     mmap(r->hdr, flen, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, r->fd, 0) != MAP_FAILED) {
 184                         r->flen = r->hdr->flen = flen;
 185                         r->cap = flen - sizeof(*r->hdr);
 186                         ret = 1;
 187                 }
 188                 else
 189                         ret = -1;
 190         }
 191
 192         flock(r->fd, LOCK_UN);
 193         return ret;
 194 }
 195
 196 int rszshm_dt(struct rszshm *r)
 197 {
 198         int ret[3];
 199         assert(r);
 200
 201         /* ok to call twice, since free macro calls this */
 202         if (r->fd == -1)
 203                 return 0;
 204
 205         ret[0] = msync(r->hdr, r->flen, MS_SYNC);
 206         ret[1] = munmap(r->hdr, r->hdr->max);
 207         ret[2] = close(r->fd);
 208
 209         r->fd = -1;
 210         r->flen = 0;
 211         r->hdr = NULL;
 212         r->dat = NULL;
 213         r->cap = 0;
 214
 215         return ret[0] == 0 && ret[1] == 0 && ret[2] == 0 ? 0 : -1;
 216 }
 217
 218 int rszshm_unlink(struct rszshm *r)
 219 {
 220         assert(r);
 221         return unlink(r->fname);
 222 }
 223
 224 int rszshm_rmdir(struct rszshm *r)
 225 {
 226         int ret;
 227         char *p;
 228
 229         assert(r);
 230
 231         if ((p = strrchr(r->fname, '/')) == NULL) {
 232                 errno = ENOTDIR;
 233                 return -1;
 234         }
 235
 236         *p = '\0';
 237         ret = rmdir(r->fname);
 238         *p = '/';
 239         return ret;
 240 }