On Linux, symbolic links always have permissions lrwxrwxrwx (0777). These permissions have no enforcement meaning — the kernel ignores them. The actual permission check happens on the target file when the symlink is dereferenced.

The problem: EA access control depends on file permissions. If a symlink’s permissions can’t be restricted, then any user could set user EAs on any symlink — there’s no way to say “only the owner can modify this symlink’s EAs”.

The kernel’s solution: Simply ban user EAs on symlinks entirely.

/* This will fail with EPERM (operation not permitted) */
#include <sys/xattr.h>
#include <stdio.h>
#include <string.h>

int main() {
    /* Create a symlink first */
    symlink("/etc/passwd", "/tmp/my_symlink");

    /* Try to set a user EA on the symlink (NOT the target) */
    const char *val = "test";
    int ret = lsetxattr("/tmp/my_symlink", "user.tag", val, strlen(val), 0);
    if (ret == -1) {
        perror("lsetxattr on symlink");
        /* Output: lsetxattr on symlink: Operation not permitted */
    }
    return 0;
}

Even though directories support user EAs, there is a special restriction: an unprivileged process cannot set user EAs on a directory owned by another user if the sticky bit is set on that directory.

The sticky bit on a directory (like /tmp) means “users can’t delete other users’ files here”. The same logic extends to EAs: you can’t modify another user’s EA in a sticky directory.

# /tmp typically has the sticky bit set (shown as 't' in permissions)
$ ls -ld /tmp
drwxrwxrwt 20 root root 4096 Jan 10 09:00 /tmp

# Alice tries to set a user EA on a file owned by ravi inside /tmp
# This will fail with EPERM if /tmp has sticky bit
$ setfattr -n user.tag -v "hello" /tmp/ravis_file.txt
setfattr: /tmp/ravis_file.txt: Operation not permitted

File systems can impose tighter constraints than the VFS layer allows.

When you call setxattr(), you may hit these limits. The kernel returns specific errors:

#include <sys/xattr.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

/*
 * Safely set a user EA with proper error handling.
 * Returns 0 on success, -1 on failure.
 */
int safe_set_ea(const char *path, const char *ea_name, const char *value) {
    if (setxattr(path, ea_name, value, strlen(value), 0) == -1) {
        switch (errno) {
        case ENOSPC:
            fprintf(stderr, "Error: EA block full on this file (ext4 limit)\n");
            break;
        case E2BIG:
            fprintf(stderr, "Error: EA value too large (>64KB)\n");
            break;
        case EPERM:
            fprintf(stderr, "Error: Not permitted (symlink or sticky dir?)\n");
            break;
        case EACCES:
            fprintf(stderr, "Error: No write permission on file\n");
            break;
        case ENOTSUP:
            fprintf(stderr, "Error: File system does not support EAs\n");
            break;
        default:
            perror("setxattr");
            break;
        }
        return -1;
    }
    return 0;
}

int main() {
    /* Works fine: small value, regular file */
    safe_set_ea("/tmp/test.txt", "user.status", "active");

    /* This would fail on ext4 if EA block is already full */
    char big_value[5000];
    memset(big_value, 'A', sizeof(big_value) - 1);
    big_value[4999] = '\0';
    safe_set_ea("/tmp/test.txt", "user.big_data", big_value);

    return 0;
}

Before your program relies on EAs, you can probe whether the file system supports them:

#include <sys/xattr.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>

/*
 * Returns 1 if the given path's filesystem supports user EAs.
 * Returns 0 if not supported.
 */
int ea_supported(const char *path) {
    /* Try to set a test EA */
    int ret = setxattr(path, "user.__ea_probe__", "1", 1, 0);
    if (ret == -1) {
        if (errno == ENOTSUP || errno == EOPNOTSUPP)
            return 0;
        /* Other errors (EACCES etc.) — FS supports EAs but we have other issues */
        if (errno == EACCES)
            return 1;  /* FS supports EAs, we just lack permission */
    } else {
        /* Clean up the test EA */
        removexattr(path, "user.__ea_probe__");
    }
    return 1;
}

int main() {
    const char *paths[] = { "/tmp/test.txt", "/proc/self", NULL };
    for (int i = 0; paths[i] != NULL; i++) {
        printf("EA support on '%s': %s\n",
               paths[i],
               ea_supported(paths[i]) ? "YES" : "NO");
    }
    return 0;
}

JFS supports a fifth namespace called os2, which is not available on any other Linux file system. It exists only to provide backward compatibility with OS/2 file system extended attributes.

• Only available on JFS.
• No privilege required to create os2 EAs.
• Exists for legacy compatibility — not for new development.