C - Using F_GETFL and F_SETFL

You asked:

Why does the flag returned by fcntl (fd, F_GETFL) only include a subset of the bits I set when I opened the file? Does it display only those that can be changed?

Not; it only displays those that are "remembered" by the system, for example O_RDWR

. They can really be called "flags". Some of the other ORed bits in the parameter are oflag

more like "imperative instructions" to the system call open

: for example, it O_CREAT

says "create this file if it doesn't exist" and O_TRUNC

says "shorten it", none of which is a "flag". A file that was truncated at creation is indistinguishable from a file that was not truncated at creation: they are both just "files". So after the open

file is created or trimmed, it doesn't bother to "remember" the story. It only "remembers" important things, such as whether a file is open for reading or writing.

Edited to add: These flags of different types have semi-official names. O_RDWR

- this is the "access mode" (memorable, not changeable); O_APPEND

is a "mode of operation" (remembered, usually modified); O_TRUNC

is the "open time flag" (refers to the operation itself open

, not the file descriptor, so it is not remembered). Note that the "access mode" is not modified - you cannot use fcntl

to turn a read-only fd into a write-only fd.

When using fcntl(fd, F_SETFL, flag)

, how do I pass the param parameter, I need to first read the flag through fcntl(fd, F_GETFL)

and then change and pass it? Or, internally, is it just performing an operation &

on the new parameter?

F_SETFL

overwrites flags exactly with what you are passing through (although it will ignore your leisurely attempts to set bits-aren't-really-flags, for example O_TRUNC

). If you want to set a specific flag and leave the rest of the flags as they are, then you have to use the F_GETFL

old flags, |

enter a new flag, and then the F_SETFL

result. This must be done as two separate system calls; at least there is no atomic or thread safe way to achieve this as far as I know.

Where can I find a complete list of 32 (or less) bits of open file flags?

In fcntl.h

or its documentation ( man fcntl

). For example, on my MacBook, the man page says:

The flags for the F_GETFL and F_SETFL commands are as follows:

      O_NONBLOCK   Non-blocking I/O; if no data is available to a read call, or if a write operation would block, the read or write
                   call returns -1 with the error EAGAIN.

      O_APPEND     Force each write to append at the end of file; corresponds to the O_APPEND flag of open(2).

      O_ASYNC      Enable the SIGIO signal to be sent to the process group when I/O is possible, e.g., upon availability of data to be
                   read.

      

        
        
        
      

    

In other words, three bits can be set (or disabled) on OS X. If on Linux the man page says this :

On Linux this command can change only the O_APPEND, O_ASYNC,
O_DIRECT, O_NOATIME, and O_NONBLOCK flags.

      

        
        
        
      

    

By the way, some Linux filesystems have a file-only attachment concept at the filesystem level; if you open one of these files and then try to clear the resulting handle O_APPEND

, you will get an error EPERM

. The "append-only" feature of a file can be controlled at the file system level using a utility chattr

.

Here is a more systematic version of your test program. This may not interest you, but I learned something by writing it, so I leave it here. :)

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>

int main() {
    int fd = open("/tmp/fd_share.txt", O_RDWR | O_CREAT | O_TRUNC | O_APPEND, 0644);

    // append to empty file
    write(fd, "aaaaaaaaaa", 10);

    off_t cur = lseek(fd, 1, SEEK_SET);
    printf("offset after being set to 1: %ld\n", (long)cur);

    // append
    write(fd, "bbbbbbbb", 8);

    cur = lseek(fd, 0, SEEK_CUR);
    printf("offset after appending bbbbbbbb: %ld\n", (long)cur);

    cur = lseek(fd, 2, SEEK_SET);
    printf("offset after being set to 2: %ld\n", (long)cur);

    // now toggle "append mode" to FALSE
    int open_flag = fcntl(fd, F_GETFL);
    if (fcntl(fd, F_SETFL, open_flag & ~O_APPEND) == -1) {
        printf("failed to set flag\n");
        return 0;
    }

    cur = lseek(fd, 0, SEEK_CUR);
    printf("offset after unsetting O_APPEND: %ld\n", (long)cur);

    cur = lseek(fd, 3, SEEK_SET);
    printf("offset after being set to 3: %ld\n", (long)cur);

    // write without appending
    write(fd, "cccc", 4);

    cur = lseek(fd, 0, SEEK_CUR);
    printf("offset after writing cccc: %ld\n", (long)cur);

    // now toggle "append mode" to TRUE
    open_flag = fcntl(fd, F_GETFL);
    if (fcntl(fd, F_SETFL, open_flag | O_APPEND) == -1) {
        printf("failed to set flag\n");
        return 0;
    }

    cur = lseek(fd, 0, SEEK_CUR);
    printf("offset after unsetting O_APPEND: %ld\n", (long)cur);

    // append
    write(fd, "dd", 2);

    cur = lseek(fd, 0, SEEK_CUR);
    printf("offset after appending dd: %ld\n", (long)cur);

    close(fd);
}

      

        
        
        
      

    

The output of this program on my MacBook (as with any POSIX AFAIK system):

offset after being set to 1: 1
offset after appending bbbbbbbb: 18
offset after being set to 2: 2
offset after unsetting O_APPEND: 2
offset after being set to 3: 3
offset after writing cccc: 7
offset after unsetting O_APPEND: 7
offset after appending dd: 20