Node:File Position Primitive, Next:Descriptors and Streams, Previous:I/O Primitives, Up:Low-Level I/O
Just as you can set the file position of a stream with fseek
, you
can set the file position of a descriptor with lseek
. This
specifies the position in the file for the next read
or
write
operation. See File Positioning, for more information
on the file position and what it means.
To read the current file position value from a descriptor, use
lseek (desc, 0, SEEK_CUR)
.
off_t lseek (int filedes, off_t offset, int whence) | Function |
The lseek function is used to change the file position of the
file with descriptor filedes.
The whence argument specifies how the offset should be
interpreted, in the same way as for the
The return value from If you want to append to the file, setting the file position to the
current end of file with You can set the file position past the current end of the file. This
does not by itself make the file longer; If the file position cannot be changed, or the operation is in some way
invalid,
When the source file is compiled with This function is a cancellation point in multi-threaded programs. This
is a problem if the thread allocates some resources (like memory, file
descriptors, semaphores or whatever) at the time The |
off64_t lseek64 (int filedes, off64_t offset, int whence) | Function |
This function is similar to the lseek function. The difference
is that the offset parameter is of type off64_t instead of
off_t which makes it possible on 32 bit machines to address
files larger than 2^31 bytes and up to 2^63 bytes. The
file descriptor filedes must be opened using open64 since
otherwise the large offsets possible with off64_t will lead to
errors with a descriptor in small file mode.
When the source file is compiled with |
You can have multiple descriptors for the same file if you open the file
more than once, or if you duplicate a descriptor with dup
.
Descriptors that come from separate calls to open
have independent
file positions; using lseek
on one descriptor has no effect on the
other. For example,
{ int d1, d2; char buf[4]; d1 = open ("foo", O_RDONLY); d2 = open ("foo", O_RDONLY); lseek (d1, 1024, SEEK_SET); read (d2, buf, 4); }
will read the first four characters of the file foo
. (The
error-checking code necessary for a real program has been omitted here
for brevity.)
By contrast, descriptors made by duplication share a common file
position with the original descriptor that was duplicated. Anything
which alters the file position of one of the duplicates, including
reading or writing data, affects all of them alike. Thus, for example,
{ int d1, d2, d3; char buf1[4], buf2[4]; d1 = open ("foo", O_RDONLY); d2 = dup (d1); d3 = dup (d2); lseek (d3, 1024, SEEK_SET); read (d1, buf1, 4); read (d2, buf2, 4); }
will read four characters starting with the 1024'th character of
foo
, and then four more characters starting with the 1028'th
character.
off_t | Data Type |
This is an arithmetic data type used to represent file sizes.
In the GNU system, this is equivalent to fpos_t or long int .
If the source is compiled with |
off64_t | Data Type |
This type is used similar to off_t . The difference is that even
on 32 bit machines, where the off_t type would have 32 bits,
off64_t has 64 bits and so is able to address files up to
2^63 bytes in length.
When compiling with |
These aliases for the SEEK_...
constants exist for the sake
of compatibility with older BSD systems. They are defined in two
different header files: fcntl.h
and sys/file.h
.
L_SET
SEEK_SET
.
L_INCR
SEEK_CUR
.
L_XTND
SEEK_END
.