rszshm: New module
[ccan] / 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 }