2 * Copyright 2013 Facebook, Inc.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #ifndef FOLLY_FILEUTIL_H_
18 #define FOLLY_FILEUTIL_H_
20 #include "folly/Portability.h"
23 #include <sys/types.h>
31 * Convenience wrappers around some commonly used system calls. The *NoInt
32 * wrappers retry on EINTR. The *Full wrappers retry on EINTR and also loop
33 * until all data is written. Note that *Full wrappers weaken the thread
34 * semantics of underlying system calls.
36 int openNoInt(const char* name, int flags, mode_t mode=0644);
37 int closeNoInt(int fd);
38 int fsyncNoInt(int fd);
39 int fdatasyncNoInt(int fd);
40 int ftruncateNoInt(int fd, off_t len);
41 int truncateNoInt(const char* path, off_t len);
42 int flockNoInt(int fd, int operation);
44 ssize_t readNoInt(int fd, void* buf, size_t n);
45 ssize_t preadNoInt(int fd, void* buf, size_t n, off_t offset);
46 ssize_t readvNoInt(int fd, const iovec* iov, int count);
48 ssize_t writeNoInt(int fd, const void* buf, size_t n);
49 ssize_t pwriteNoInt(int fd, const void* buf, size_t n, off_t offset);
50 ssize_t writevNoInt(int fd, const iovec* iov, int count);
53 * Wrapper around read() (and pread()) that, in addition to retrying on
54 * EINTR, will loop until all data is read.
56 * This wrapper is only useful for blocking file descriptors (for non-blocking
57 * file descriptors, you have to be prepared to deal with incomplete reads
58 * anyway), and only exists because POSIX allows read() to return an incomplete
59 * read if interrupted by a signal (instead of returning -1 and setting errno
62 * Note that this wrapper weakens the thread safety of read(): the file pointer
63 * is shared between threads, but the system call is atomic. If multiple
64 * threads are reading from a file at the same time, you don't know where your
65 * data came from in the file, but you do know that the returned bytes were
66 * contiguous. You can no longer make this assumption if using readFull().
67 * You should probably use pread() when reading from the same file descriptor
68 * from multiple threads simultaneously, anyway.
70 * Note that readvFull and preadvFull require iov to be non-const, unlike
71 * readv and preadv. The contents of iov after these functions return
74 ssize_t readFull(int fd, void* buf, size_t n);
75 ssize_t preadFull(int fd, void* buf, size_t n, off_t offset);
76 ssize_t readvFull(int fd, iovec* iov, int count);
77 #ifdef FOLLY_HAVE_PREADV
78 ssize_t preadvFull(int fd, iovec* iov, int count, off_t offset);
82 * Similar to readFull and preadFull above, wrappers around write() and
83 * pwrite() that loop until all data is written.
85 * Generally, the write() / pwrite() system call may always write fewer bytes
86 * than requested, just like read(). In certain cases (such as when writing to
87 * a pipe), POSIX provides stronger guarantees, but not in the general case.
88 * For example, Linux (even on a 64-bit platform) won't write more than 2GB in
89 * one write() system call.
91 * Note that writevFull and pwritevFull require iov to be non-const, unlike
92 * writev and pwritev. The contents of iov after these functions return
95 ssize_t writeFull(int fd, const void* buf, size_t n);
96 ssize_t pwriteFull(int fd, const void* buf, size_t n, off_t offset);
97 ssize_t writevFull(int fd, iovec* iov, int count);
98 #ifdef FOLLY_HAVE_PWRITEV
99 ssize_t pwritevFull(int fd, iovec* iov, int count, off_t offset);
104 #endif /* FOLLY_FILEUTIL_H_ */