1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
/*-
* Copyright (c) 2014-2016 MongoDB, Inc.
* Copyright (c) 2008-2014 WiredTiger, Inc.
* All rights reserved.
*
* See the file LICENSE for redistribution information.
*/
#include "wt_internal.h"
#if defined(__linux__)
#include <linux/falloc.h>
#include <sys/syscall.h>
#endif
/*
* __wt_posix_file_allocate_configure --
* Configure POSIX file-extension behavior for a file handle.
*/
void
__wt_posix_file_allocate_configure(WT_SESSION_IMPL *session, WT_FH *fh)
{
WT_UNUSED(session);
fh->fallocate_available = WT_FALLOCATE_NOT_AVAILABLE;
fh->fallocate_requires_locking = false;
/*
* Check for the availability of some form of fallocate; in all cases,
* start off requiring locking, we'll relax that requirement once we
* know which system calls work with the handle's underlying filesystem.
*/
#if defined(HAVE_FALLOCATE) || defined(HAVE_POSIX_FALLOCATE)
fh->fallocate_available = WT_FALLOCATE_AVAILABLE;
fh->fallocate_requires_locking = true;
#endif
#if defined(__linux__) && defined(SYS_fallocate)
fh->fallocate_available = WT_FALLOCATE_AVAILABLE;
fh->fallocate_requires_locking = true;
#endif
}
/*
* __posix_std_fallocate --
* Linux fallocate call.
*/
static int
__posix_std_fallocate(WT_FH *fh, wt_off_t offset, wt_off_t len)
{
#if defined(HAVE_FALLOCATE)
WT_DECL_RET;
WT_SYSCALL_RETRY(fallocate(fh->fd, 0, offset, len), ret);
return (ret);
#else
WT_UNUSED(fh);
WT_UNUSED(offset);
WT_UNUSED(len);
return (ENOTSUP);
#endif
}
/*
* __posix_sys_fallocate --
* Linux fallocate call (system call version).
*/
static int
__posix_sys_fallocate(WT_FH *fh, wt_off_t offset, wt_off_t len)
{
#if defined(__linux__) && defined(SYS_fallocate)
WT_DECL_RET;
/*
* Try the system call for fallocate even if the C library wrapper was
* not found. The system call actually exists in the kernel for some
* Linux versions (RHEL 5.5), but not in the version of the C library.
* This allows it to work everywhere the kernel supports it.
*/
WT_SYSCALL_RETRY(syscall(SYS_fallocate, fh->fd, 0, offset, len), ret);
return (ret);
#else
WT_UNUSED(fh);
WT_UNUSED(offset);
WT_UNUSED(len);
return (ENOTSUP);
#endif
}
/*
* __posix_posix_fallocate --
* POSIX fallocate call.
*/
static int
__posix_posix_fallocate(WT_FH *fh, wt_off_t offset, wt_off_t len)
{
#if defined(HAVE_POSIX_FALLOCATE)
WT_DECL_RET;
WT_SYSCALL_RETRY(posix_fallocate(fh->fd, offset, len), ret);
return (ret);
#else
WT_UNUSED(fh);
WT_UNUSED(offset);
WT_UNUSED(len);
return (ENOTSUP);
#endif
}
/*
* __wt_posix_file_allocate --
* POSIX fallocate.
*/
int
__wt_posix_file_allocate(
WT_SESSION_IMPL *session, WT_FH *fh, wt_off_t offset, wt_off_t len)
{
WT_DECL_RET;
switch (fh->fallocate_available) {
/*
* Check for already configured handles and make the configured call.
*/
case WT_FALLOCATE_POSIX:
if ((ret = __posix_posix_fallocate(fh, offset, len)) == 0)
return (0);
WT_RET_MSG(session, ret, "%s: posix_fallocate", fh->name);
case WT_FALLOCATE_STD:
if ((ret = __posix_std_fallocate(fh, offset, len)) == 0)
return (0);
WT_RET_MSG(session, ret, "%s: fallocate", fh->name);
case WT_FALLOCATE_SYS:
if ((ret = __posix_sys_fallocate(fh, offset, len)) == 0)
return (0);
WT_RET_MSG(session, ret, "%s: sys_fallocate", fh->name);
/*
* Figure out what allocation call this system/filesystem supports, if
* any.
*/
case WT_FALLOCATE_AVAILABLE:
/*
* We've seen Linux systems where posix_fallocate has corrupted
* existing file data (even though that is explicitly disallowed
* by POSIX). FreeBSD and Solaris support posix_fallocate, and
* so far we've seen no problems leaving it unlocked. Check for
* fallocate (and the system call version of fallocate) first to
* avoid locking on Linux if at all possible.
*/
if ((ret = __posix_std_fallocate(fh, offset, len)) == 0) {
fh->fallocate_available = WT_FALLOCATE_STD;
fh->fallocate_requires_locking = false;
return (0);
}
if ((ret = __posix_sys_fallocate(fh, offset, len)) == 0) {
fh->fallocate_available = WT_FALLOCATE_SYS;
fh->fallocate_requires_locking = false;
return (0);
}
if ((ret = __posix_posix_fallocate(fh, offset, len)) == 0) {
fh->fallocate_available = WT_FALLOCATE_POSIX;
#if !defined(__linux__)
fh->fallocate_requires_locking = false;
#endif
return (0);
}
/* FALLTHROUGH */
case WT_FALLOCATE_NOT_AVAILABLE:
default:
fh->fallocate_available = WT_FALLOCATE_NOT_AVAILABLE;
return (ENOTSUP);
}
/* NOTREACHED */
}
|
