0ec03b3cc6bfb4bb036c36c88ceecd385b860709
[folly.git] / folly / FileUtil.cpp
1 /*
2  * Copyright 2016 Facebook, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *   http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <folly/FileUtil.h>
18
19 #include <cerrno>
20
21 #include <folly/Exception.h>
22 #include <folly/detail/FileUtilDetail.h>
23 #include <folly/portability/Fcntl.h>
24 #include <folly/portability/Sockets.h>
25 #include <folly/portability/SysFile.h>
26
27 namespace folly {
28
29 using namespace fileutil_detail;
30
31 int openNoInt(const char* name, int flags, mode_t mode) {
32   return int(wrapNoInt(open, name, flags, mode));
33 }
34
35 int closeNoInt(int fd) {
36   int r = close(fd);
37   // Ignore EINTR.  On Linux, close() may only return EINTR after the file
38   // descriptor has been closed, so you must not retry close() on EINTR --
39   // in the best case, you'll get EBADF, and in the worst case, you'll end up
40   // closing a different file (one opened from another thread).
41   //
42   // Interestingly enough, the Single Unix Specification says that the state
43   // of the file descriptor is unspecified if close returns EINTR.  In that
44   // case, the safe thing to do is also not to retry close() -- leaking a file
45   // descriptor is definitely better than closing the wrong file.
46   if (r == -1 && errno == EINTR) {
47     r = 0;
48   }
49   return r;
50 }
51
52 int fsyncNoInt(int fd) {
53   return int(wrapNoInt(fsync, fd));
54 }
55
56 int dupNoInt(int fd) {
57   return int(wrapNoInt(dup, fd));
58 }
59
60 int dup2NoInt(int oldfd, int newfd) {
61   return int(wrapNoInt(dup2, oldfd, newfd));
62 }
63
64 int fdatasyncNoInt(int fd) {
65 #if defined(__APPLE__)
66   return int(wrapNoInt(fcntl, fd, F_FULLFSYNC));
67 #elif defined(__FreeBSD__) || defined(_MSC_VER)
68   return int(wrapNoInt(fsync, fd));
69 #else
70   return int(wrapNoInt(fdatasync, fd));
71 #endif
72 }
73
74 int ftruncateNoInt(int fd, off_t len) {
75   return int(wrapNoInt(ftruncate, fd, len));
76 }
77
78 int truncateNoInt(const char* path, off_t len) {
79   return int(wrapNoInt(truncate, path, len));
80 }
81
82 int flockNoInt(int fd, int operation) {
83   return int(wrapNoInt(flock, fd, operation));
84 }
85
86 int shutdownNoInt(int fd, int how) {
87   return int(wrapNoInt(portability::sockets::shutdown, fd, how));
88 }
89
90 ssize_t readNoInt(int fd, void* buf, size_t count) {
91   return wrapNoInt(read, fd, buf, count);
92 }
93
94 ssize_t preadNoInt(int fd, void* buf, size_t count, off_t offset) {
95   return wrapNoInt(pread, fd, buf, count, offset);
96 }
97
98 ssize_t readvNoInt(int fd, const iovec* iov, int count) {
99   return wrapNoInt(readv, fd, iov, count);
100 }
101
102 ssize_t writeNoInt(int fd, const void* buf, size_t count) {
103   return wrapNoInt(write, fd, buf, count);
104 }
105
106 ssize_t pwriteNoInt(int fd, const void* buf, size_t count, off_t offset) {
107   return wrapNoInt(pwrite, fd, buf, count, offset);
108 }
109
110 ssize_t writevNoInt(int fd, const iovec* iov, int count) {
111   return wrapNoInt(writev, fd, iov, count);
112 }
113
114 ssize_t readFull(int fd, void* buf, size_t count) {
115   return wrapFull(read, fd, buf, count);
116 }
117
118 ssize_t preadFull(int fd, void* buf, size_t count, off_t offset) {
119   return wrapFull(pread, fd, buf, count, offset);
120 }
121
122 ssize_t writeFull(int fd, const void* buf, size_t count) {
123   return wrapFull(write, fd, const_cast<void*>(buf), count);
124 }
125
126 ssize_t pwriteFull(int fd, const void* buf, size_t count, off_t offset) {
127   return wrapFull(pwrite, fd, const_cast<void*>(buf), count, offset);
128 }
129
130 ssize_t readvFull(int fd, iovec* iov, int count) {
131   return wrapvFull(readv, fd, iov, count);
132 }
133
134 ssize_t preadvFull(int fd, iovec* iov, int count, off_t offset) {
135   return wrapvFull(preadv, fd, iov, count, offset);
136 }
137
138 ssize_t writevFull(int fd, iovec* iov, int count) {
139   return wrapvFull(writev, fd, iov, count);
140 }
141
142 ssize_t pwritevFull(int fd, iovec* iov, int count, off_t offset) {
143   return wrapvFull(pwritev, fd, iov, count, offset);
144 }
145
146 int writeFileAtomicNoThrow(
147     StringPiece filename,
148     iovec* iov,
149     int count,
150     mode_t permissions) {
151   // We write the data to a temporary file name first, then atomically rename
152   // it into place.  This ensures that the file contents will always be valid,
153   // even if we crash or are killed partway through writing out data.
154   //
155   // Create a buffer that will contain two things:
156   // - A nul-terminated version of the filename
157   // - The temporary file name
158   std::vector<char> pathBuffer;
159   // Note that we have to explicitly pass in the size here to make
160   // sure the nul byte gets included in the data.
161   constexpr folly::StringPiece suffix(".XXXXXX\0", 8);
162   pathBuffer.resize((2 * filename.size()) + 1 + suffix.size());
163   // Copy in the filename and then a nul terminator
164   memcpy(pathBuffer.data(), filename.data(), filename.size());
165   pathBuffer[filename.size()] = '\0';
166   const char* const filenameCStr = pathBuffer.data();
167   // Now prepare the temporary path template
168   char* const tempPath = pathBuffer.data() + filename.size() + 1;
169   memcpy(tempPath, filename.data(), filename.size());
170   memcpy(tempPath + filename.size(), suffix.data(), suffix.size());
171
172   auto tmpFD = mkstemp(tempPath);
173   if (tmpFD == -1) {
174     return errno;
175   }
176   bool success = false;
177   SCOPE_EXIT {
178     if (tmpFD != -1) {
179       close(tmpFD);
180     }
181     if (!success) {
182       unlink(tempPath);
183     }
184   };
185
186   auto rc = writevFull(tmpFD, iov, count);
187   if (rc == -1) {
188     return errno;
189   }
190
191   rc = fchmod(tmpFD, permissions);
192   if (rc == -1) {
193     return errno;
194   }
195
196   // Close the file before renaming to make sure all data has
197   // been successfully written.
198   rc = close(tmpFD);
199   tmpFD = -1;
200   if (rc == -1) {
201     return errno;
202   }
203
204   rc = rename(tempPath, filenameCStr);
205   if (rc == -1) {
206     return errno;
207   }
208   success = true;
209   return 0;
210 }
211
212 void writeFileAtomic(
213     StringPiece filename,
214     iovec* iov,
215     int count,
216     mode_t permissions) {
217   auto rc = writeFileAtomicNoThrow(filename, iov, count, permissions);
218   checkPosixError(rc, "writeFileAtomic() failed to update ", filename);
219 }
220
221 void writeFileAtomic(StringPiece filename, ByteRange data, mode_t permissions) {
222   iovec iov;
223   iov.iov_base = const_cast<unsigned char*>(data.data());
224   iov.iov_len = data.size();
225   auto rc = writeFileAtomicNoThrow(filename, &iov, 1, permissions);
226   checkPosixError(rc, "writeFileAtomic() failed to update ", filename);
227 }
228
229 void writeFileAtomic(
230     StringPiece filename,
231     StringPiece data,
232     mode_t permissions) {
233   writeFileAtomic(filename, ByteRange(data), permissions);
234 }
235
236 }  // namespaces