Code Coverage: vinyl-cache/lib/libvinyl/vfil.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2011 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Dag-Erling Smørgrav <des@des.no>
6
 *
7
 * SPDX-License-Identifier: BSD-2-Clause
8
 *
9
 * Redistribution and use in source and binary forms, with or without
10
 * modification, are permitted provided that the following conditions
11
 * are met:
12
 * 1. Redistributions of source code must retain the above copyright
13
 *    notice, this list of conditions and the following disclaimer.
14
 * 2. Redistributions in binary form must reproduce the above copyright
15
 *    notice, this list of conditions and the following disclaimer in the
16
 *    documentation and/or other materials provided with the distribution.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28
 * SUCH DAMAGE.
29
 */
30
31
#include "config.h"
32
33
#include <time.h>
34
#include <sys/types.h>
35
#include <sys/stat.h>
36
#include <fcntl.h>
37
#include <limits.h>
38
#include <stdio.h>
39
#include <stdlib.h>
40
#include <unistd.h>
41
#include <stdint.h>
42
#include <string.h>
43
#include <sys/statvfs.h>
44
#if defined(__linux__) && defined(HAVE_FALLOCATE)
45
#  include <linux/magic.h>
46
#  include <sys/vfs.h>
47
#endif
48
49
#include "vdef.h"
50
51
#include "miniobj.h"
52
#include "vas.h"
53
#include "vsb.h"
54
#include "vfil.h"
55
#include "vqueue.h"
56
57
void
58
VFIL_null_fd(int target)
59 15771
{
60 15771
        int fd;
61
62 15771
        assert(target >= 0);
63 15771
        fd = open("/dev/null", O_RDWR);
64 15771
        assert(fd >= 0);
65 15771
        assert(dup2(fd, target) == target);
66 15771
        closefd(&fd);
67 15771
}
68
69
static char *
70
vfil_readfd(int fd, ssize_t *sz)
71 3604
{
72 3604
        struct stat st;
73 3604
        char *f;
74 3604
        int i;
75
76 3604
        AZ(fstat(fd, &st));
77 3604
        if (!S_ISREG(st.st_mode))
78 0
                return (NULL);
79 3604
        f = malloc(st.st_size + 1);
80 3604
        assert(f != NULL);
81 3604
        i = read(fd, f, st.st_size + 1);
82 3604
        if (i != st.st_size) {
83 0
                free(f);
84 0
                return (NULL);
85 0
        }
86 3604
        f[i] = '\0';
87 3604
        if (sz != NULL)
88 18
                *sz = st.st_size;
89 3604
        return (f);
90 3604
}
91
92
static int
93
vfil_writefd(int fd, const char *buf, size_t sz)
94 17
{
95 17
        ssize_t len;
96
97 34
        while (sz > 0) {
98 17
                len = write(fd, buf, sz);
99 17
                if (len < 0)
100 0
                        return (len);
101 17
                if (len == 0)
102 0
                        break;
103 17
                buf += len;
104 17
                sz -= len;
105 17
        }
106
107 17
        return (sz == 0 ? 0 : -1);
108 17
}
109
110
static int
111
vfil_openfile(const char *pfx, const char *fn, int flags, int mode)
112 3629
{
113 3629
        char fnb[PATH_MAX + 1];
114
115 3629
        if (fn[0] != '/' && pfx != NULL) {
116
                /* XXX: graceful length check */
117 0
                bprintf(fnb, "/%s/%s", pfx, fn);
118 0
                fn = fnb;
119 0
        }
120
121 3629
        if (flags & O_CREAT)
122 17
                return (open(fn, flags, mode));
123 3612
        else
124 3612
                return (open(fn, flags));
125 3629
}
126
127
char *
128
VFIL_readfile(const char *pfx, const char *fn, ssize_t *sz)
129 3612
{
130 3612
        int fd, err;
131 3612
        char *r;
132
133 3612
        fd = vfil_openfile(pfx, fn, O_RDONLY, 0);
134 3612
        if (fd < 0)
135 8
                return (NULL);
136 3604
        r = vfil_readfd(fd, sz);
137 3604
        err = errno;
138 3604
        closefd(&fd);
139 3604
        errno = err;
140 3604
        return (r);
141 3604
}
142
143
int
144
VFIL_writefile(const char *pfx, const char *fn, const char *buf, size_t sz)
145 17
{
146 17
        int fd, err;
147 17
        int r;
148
149 17
        fd = vfil_openfile(pfx, fn, O_WRONLY|O_CREAT|O_TRUNC, 0660);
150 17
        if (fd < 0)
151 0
                return (fd);
152 17
        r = vfil_writefd(fd, buf, sz);
153 17
        err = errno;
154 17
        closefd(&fd);
155 17
        errno = err;
156 17
        return (r);
157 17
}
158
159
int
160
VFIL_nonblocking(int fd)
161 1032
{
162 1032
        int i;
163
164 1032
        i = fcntl(fd, F_GETFL);
165 1032
        assert(i != -1);
166 1032
        i |= O_NONBLOCK;
167 1032
        i = fcntl(fd, F_SETFL, i);
168 1032
        assert(i != -1);
169 1032
        return (i);
170 1032
}
171
172
/*
173
 * Get file system information from an fd
174
 * Returns block size, total size and space available in the passed pointers
175
 * Returns 0 on success, or -1 on failure with errno set
176
 */
177
int
178
VFIL_fsinfo(int fd, unsigned *pbs, uintmax_t *psize, uintmax_t *pspace)
179 54681
{
180 54681
        unsigned bs;
181 54681
        uintmax_t size, space;
182 54681
        struct statvfs fsst;
183
184 54681
        if (fstatvfs(fd, &fsst))
185 0
                return (-1);
186 54681
        bs = fsst.f_frsize;
187 54681
        size = fsst.f_blocks * fsst.f_frsize;
188 54681
        space = fsst.f_bavail * fsst.f_frsize;
189
190 54681
        if (pbs)
191 43
                *pbs = bs;
192 54681
        if (psize)
193 43
                *psize = size;
194 54681
        if (pspace)
195 54638
                *pspace = space;
196 54681
        return (0);
197 54681
}
198
199
/*
200
 * Make sure that the file system can accommodate the file of the given
201
 * size. Will use fallocate if available. If fallocate is not available
202
 * and insist is true, it will write size zero bytes.
203
 *
204
 * Returns 0 on success, -1 on failure with errno set.
205
 */
206
207
int
208
VFIL_allocate(int fd, uintmax_t size, int insist)
209 54638
{
210 54638
        struct stat st;
211 54638
        uintmax_t fsspace;
212 54638
        size_t l;
213 54638
        ssize_t l2, l3;
214 54638
        char *buf;
215 54638
        ssize_t bufsiz;
216 54638
        int retval = 0;
217
218 54638
        if (ftruncate(fd, size))
219 0
                return (-1);
220 54638
        if (fstat(fd, &st))
221 0
                return (-1);
222 54638
        if (VFIL_fsinfo(fd, NULL, NULL, &fsspace))
223 0
                return (-1);
224 54638
        if ((st.st_blocks * 512) + fsspace < size) {
225
                /* Sum of currently allocated blocks and available space
226
                   is less than requested size */
227 0
                errno = ENOSPC;
228 0
                return (-1);
229 0
        }
230
#if defined(__linux__) && defined(HAVE_FALLOCATE)
231
        {
232
                /* fallocate will for some filesystems (e.g. xfs) not take
233
                   the already allocated blocks of the file into
234
                   account. This will cause fallocate to report ENOSPC
235
                   when called on an existing fully allocated file unless
236
                   the filesystem has enough free space to accommodate the
237
                   complete new file size. Because of this we enable
238
                   fallocate only on filesystems that are known to work as
239
                   we expect. */
240
                struct statfs stfs;
241
                if (!fstatfs(fd, &stfs) && stfs.f_type == EXT4_SUPER_MAGIC) {
242
                        if (!fallocate(fd, 0, 0, size))
243
                                return (0);
244
                        if (errno == ENOSPC)
245
                                return (-1);
246
                }
247
        }
248
#endif
249 54638
        if (!insist)
250 6
                return (0);
251
252
        /* Write size zero bytes to make sure the entire file is allocated
253
           in the file system */
254 54632
        if (size > 65536)
255 1026
                bufsiz = 64 * 1024;
256 53606
        else
257 53606
                bufsiz = size;
258 54632
        buf = calloc(1, bufsiz);
259 54632
        AN(buf);
260 54632
        assert(lseek(fd, 0, SEEK_SET) == 0);
261 142318
        for (l = 0; l < size; l += l2) {
262 87686
                l2 = bufsiz;
263 87686
                if (l + l2 > size)
264 0
                        l2 = size - l;
265 87686
                l3 = write(fd, buf, l2);
266 87686
                if (l3 != l2) {
267 0
                        retval = -1;
268 0
                        break;
269 0
                }
270 87686
        }
271 54632
        assert(lseek(fd, 0, SEEK_SET) == 0);
272 54632
        free(buf);
273 54632
        return (retval);
274 54632
}
275
276
struct vfil_dir {
277
        unsigned                magic;
278
#define VFIL_DIR_MAGIC          0x3e214967
279
        char                    *dir;
280
        VTAILQ_ENTRY(vfil_dir)  list;
281
};
282
283
struct vfil_path {
284
        unsigned                magic;
285
#define VFIL_PATH_MAGIC         0x92dbcc31
286
        char                    *str;
287
        VTAILQ_HEAD(,vfil_dir)  paths;
288
};
289
290
/*
291
 * Path searching functions
292
 */
293
294
void
295
VFIL_setpath(struct vfil_path **pp, const char *path)
296 3302
{
297 3302
        struct vfil_path *vp;
298 3302
        struct vfil_dir *vd;
299 3302
        char *p, *q;
300
301 3302
        AN(pp);
302 3302
        AN(path);
303
304 3302
        vp = *pp;
305 3302
        if (vp == NULL) {
306 3298
                ALLOC_OBJ(vp, VFIL_PATH_MAGIC);
307 3298
                AN(vp);
308 3298
                VTAILQ_INIT(&vp->paths);
309 3298
                *pp = vp;
310 3298
        }
311 3302
        REPLACE(vp->str, path);
312 3310
        while (!VTAILQ_EMPTY(&vp->paths)) {
313 8
                vd = VTAILQ_FIRST(&vp->paths);
314 8
                CHECK_OBJ_NOTNULL(vd, VFIL_DIR_MAGIC);
315 8
                VTAILQ_REMOVE(&vp->paths, vd, list);
316 8
                FREE_OBJ(vd);
317 8
        }
318 9846
        for (p = vp->str; p != NULL; p = q) {
319 6544
                q = strchr(p, ':');
320 6544
                if (q != NULL)
321 3242
                        *q++ = '\0';
322 6544
                ALLOC_OBJ(vd, VFIL_DIR_MAGIC);
323 6544
                AN(vd);
324 6544
                vd->dir = p;
325 6544
                VTAILQ_INSERT_TAIL(&vp->paths, vd, list);
326 6544
        }
327 3302
}
328
329
static int
330
vfil_path_openfile(void *priv, const char *fn)
331 71
{
332 71
        char *p, **pp;
333
334 71
        AN(priv);
335 71
        AN(fn);
336 71
        p = VFIL_readfile(NULL, fn, NULL);
337 71
        if (p == NULL)
338 2
                return (1);
339
340 69
        pp = priv;
341 69
        *pp = p;
342 69
        return (0);
343 71
}
344
345
int
346
VFIL_searchpath(const struct vfil_path *vp, vfil_path_func_f *func, void *priv,
347
    const char *fni, char **fno)
348 715
{
349 715
        struct vsb *vsb;
350 715
        struct vfil_dir *vd;
351 715
        int i, e;
352
353 715
        CHECK_OBJ_NOTNULL(vp, VFIL_PATH_MAGIC);
354 715
        AN(fno);
355 715
        *fno = NULL;
356
357 715
        if (func == NULL) {
358 73
                func = vfil_path_openfile;
359 73
                AN(priv);
360 73
        }
361
362 715
        if (*fni == '/') {
363 61
                i = func(priv, fni);
364 61
                if (i <= 0)
365 59
                        REPLACE(*fno, fni);
366 61
                return (i);
367 61
        }
368 654
        vsb = VSB_new_auto();
369 654
        AN(vsb);
370 657
        VTAILQ_FOREACH(vd, &vp->paths, list) {
371 657
                VSB_clear(vsb);
372 657
                VSB_printf(vsb, "%s/%s", vd->dir, fni);
373 657
                AZ(VSB_finish(vsb));
374 657
                if (access(VSB_data(vsb), F_OK))
375 7
                        continue;
376 650
                i = func(priv, VSB_data(vsb));
377 650
                if (i <= 0) {
378 650
                        e = errno;
379 650
                        *fno = strdup(VSB_data(vsb));
380 650
                        AN(*fno);
381 650
                        VSB_destroy(&vsb);
382 650
                        errno = e;
383 650
                        return (i);
384 650
                }
385 650
        }
386 4
        VSB_destroy(&vsb);
387 4
        return (-1);
388 654
}