write — write to a file descriptor
|const void *buf,|
write() writes up to
count bytes from the
the file referred to by the file descriptor
The number of bytes written may be less than
count if, for example, there is
insufficient space on the underlying physical medium, or the
RLIMIT_FSIZE resource limit is
encountered (see setrlimit(2)), or the call
was interrupted by a signal handler after having written less
(See also pipe(7).)
For a seekable file (i.e., one to which lseek(2) may be applied,
for example, a regular file) writing takes place at the file
offset, and the file offset is incremented by the number of
bytes actually written. If the file was open(2)ed with
O_APPEND, the file offset is first set to
the end of the file before writing. The adjustment of the
file offset and the write operation are performed as an
POSIX requires that a read(2) which can be proved
to occur after a
returned returns the new data. Note that not all filesystems
are POSIX conforming.
On success, the number of bytes written is returned (zero indicates nothing was written). It is not an error if this number is smaller than the number of bytes requested; this may happen for example because the disk device was filled. See also NOTES.
On error, −1 is returned, and
errno is set appropriately.
count is zero
fd refers to a
regular file, then
return a failure status if one of the errors below is
detected. If no errors are detected, or error detection is
not performed, 0 will be returned without causing any other
fd refers to
a file other than a regular file, the results are not
The file descriptor
fd refers to a file other
than a socket and has been marked nonblocking
O_NONBLOCK), and the
write would block. See open(2) for further
details on the
The file descriptor
fd refers to a socket and
has been marked nonblocking (
O_NONBLOCK), and the write would
block. POSIX.1-2001 allows either error to be returned
for this case, and does not require these constants to
have the same value, so a portable application should
check for both possibilities.
fd is not a
valid file descriptor or is not open for writing.
fd refers to
a datagram socket for which a peer address has not been
set using connect(2).
The user's quota of disk blocks on the filesystem
containing the file referred to by
fd has been
outside your accessible address space.
An attempt was made to write a file that exceeds the implementation-defined maximum file size or the process's file size limit, or to write at a position past the maximum allowed offset.
The call was interrupted by a signal before any data was written; see signal(7).
attached to an object which is unsuitable for writing;
or the file was opened with the
O_DIRECT flag, and either the address
buf, the value specified
the file offset is not suitably aligned.
A low-level I/O error occurred while modifying the inode.
The device containing the file referred to by
fd has no room
for the data.
The operation was prevented by a file seal; see fcntl(2).
connected to a pipe or socket whose reading end is
closed. When this happens the writing process will also
(Thus, the write return value is seen only if the
program catches, blocks or ignores this signal.)
Other errors may occur, depending on the object connected
SVr4, 4.3BSD, POSIX.1-2001.
Under SVr4 a write may be interrupted and return EINTR at any point, not just before any data is written.
The types size_t and ssize_t are, respectively, unsigned and signed integer data types specified by POSIX.1.
A successful return from
write() does not make any guarantee that
data has been committed to disk. In fact, on some buggy
implementations, it does not even guarantee that space has
successfully been reserved for the data. The only way to be
sure is to call fsync(2) after you are done
writing all your data.
write() is interrupted
by a signal handler before any bytes are written, then the
call fails with the error EINTR; if it is interrupted after at least
one byte has been written, the call succeeds, and returns the
number of bytes written.
similar system calls) will transfer at most 0x7ffff000
(2,147,479,552) bytes, returning the number of bytes actually
transferred. (This is true on both 32-bit and 64-bit
According to POSIX.1-2008/SUSv4 Section XSI 2.9.7 ("Thread Interactions with Regular File Operations"):
All of the following functions shall be atomic with respect to each other in the effects specified in POSIX.1-2008 when they operate on regular files or symbolic links: ...
Among the APIs subsequently listed are
write() and writev(2). And among the
effects that should be atomic across threads (and processes)
are updates of the file offset. However, on Linux before
version 3.14, this was not the case: if two processes that
share an open file description (see open(2)) perform a
write() (or writev(2)) at the same
time, then the I/O operations were not atomic with respect
updating the file offset, with the result that the blocks of
data output by the two processes might (incorrectly) overlap.
This problem was fixed in Linux 3.14.
This page is part of release 4.07 of the Linux
man-pages project. A
description of the project, information about reporting bugs,
and the latest version of this page, can be found at
This manpage is Copyright (C) 1992 Drew Eckhardt;
and Copyright (C) 1993 Michael Haardt, Ian Jackson.
and Copyright (C) 2007 Michael Kerrisk <mtk.manpagesgmail.com>
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Since the Linux kernel and libraries are constantly changing, this
manual page may be incorrect or out-of-date. The author(s) assume no
responsibility for errors or omissions, or for damages resulting from
the use of the information contained herein. The author(s) may not
have taken the same level of care in the production of this manual,
which is licensed free of charge, as they might when working
Formatted or processed versions of this manual, if unaccompanied by
the source, must acknowledge the copyright and authors of this work.
Modified Sat Jul 24 13:35:59 1993 by Rik Faith <faithcs.unc.edu>
Modified Sun Nov 28 17:19:01 1993 by Rik Faith <faithcs.unc.edu>
Modified Sat Jan 13 12:58:08 1996 by Michael Haardt
Modified Sun Jul 21 18:59:33 1996 by Andries Brouwer <aebcwi.nl>
2001-12-13 added remark by Zack Weinberg
Added details about seekable files and file offset.
Noted that write() may write less than 'count' bytes, and
gave some examples of why this might occur.
Noted what happens if write() is interrupted by a signal.