from small one page howto to huge articles all in one place
 

search text in:





Poll
Which linux distribution do you use?







poll results

Last additions:
using iotop to find disk usage hogs

using iotop to find disk usage hogs

words:

887

views:

110936

userrating:

average rating: 1.7 (85 votes) (1=very good 6=terrible)


May 25th. 2007:
Words

486

Views

224834

why adblockers are bad


Workaround and fixes for the current Core Dump Handling vulnerability affected kernels

Workaround and fixes for the current Core Dump Handling vulnerability affected kernels

words:

161

views:

105066

userrating:

average rating: 1.3 (28 votes) (1=very good 6=terrible)


April, 26th. 2006:

Druckversion
You are here: manpages





IOCTL-FAT

Section: Linux Programmer's Manual (2)
Updated: 2017-09-15
Index Return to Main Contents
 

NAME

ioctl_fat - manipulating the FAT filesystem  

SYNOPSIS

#include <linux/msdos_fs.h>
#include <sys/ioctl.h>

int ioctl(int fd, FAT_IOCTL_GET_ATTRIBUTES, uint32_t *attr);
int ioctl(int fd, FAT_IOCTL_SET_ATTRIBUTES, uint32_t *attr);
int ioctl(int fd, FAT_IOCTL_GET_VOLUME_ID, uint32_t *id);
int ioctl(int fd, VFAT_IOCTL_READDIR_BOTH,
          struct __fat_dirent[2] entry);
int ioctl(int fd, VFAT_IOCTL_READDIR_SHORT,
          struct __fat_dirent[2] entry);
 

DESCRIPTION

The ioctl(2) system call can be used to read and write metadata of FAT filesystems that are not accessible using other system calls.  

Reading and setting file attributes

Files and directories in the FAT filesystem possess an attribute bit mask that can be read with FAT_IOCTL_GET_ATTRIBUTES and written with FAT_IOCTL_SET_ATTRIBUTES.

The fd argument contains a file descriptor for a file or directory. It is sufficient to create the file descriptor by calling open(2) with the O_RDONLY flag.

The attr argument contains a pointer to a bit mask. The bits of the bit mask are:

ATTR_RO
This bit specifies that the file or directory is read-only.
ATTR_HIDDEN
This bit specifies that the file or directory is hidden.
ATTR_SYS
This bit specifies that the file is a system file.
ATTR_VOLUME
This bit specifies that the file is a volume label. This attribute is read-only.
ATTR_DIR
This bit specifies that this is a directory. This attribute is read-only.
ATTR_ARCH
This bit indicates that this file or directory should be archived. It is set when a file is created or modified. It is reset by an archiving system.

The zero value ATTR_NONE can be used to indicate that no attribute bit is set.  

Reading the volume ID

FAT filesystems are identified by a volume ID. The volume ID can be read with FAT_IOCTL_GET_VOLUME_ID.

The fd argument can be a file descriptor for any file or directory of the filesystem. It is sufficient to create the file descriptor by calling open(2) with the O_RDONLY flag.

The id argument is a pointer to the field that will be filled with the volume ID. Typically the volume ID is displayed to the user as a group of two 16-bit fields:

printf("Volume ID %04x-%04x\n", id >> 16, id & 0xFFFF);  

Reading short file names of a directory

A file or directory on a FAT filesystem always has a short filename consisting of up to 8 capital letters, optionally followed by a period and up to 3 capital letters for the file extension. If the actual filename does not fit into this scheme, it is stored as a long filename of up to 255 UTF-16 characters.

The short filenames in a directory can be read with VFAT_IOCTL_READDIR_SHORT. VFAT_IOCTL_READDIR_BOTH reads both the short and the long filenames.

The fd argument must be a file descriptor for a directory. It is sufficient to create the file descriptor by calling open(2) with the O_RDONLY flag. The file descriptor can be used only once to iterate over the directory entries by calling ioctl(2) repeatedly.

The entry argument is a two-element array of the following structures:

struct __fat_dirent {
    long            d_ino;
    __kernel_off_t  d_off;
    uint32_t short  d_reclen;
    char            d_name[256]; };

The first entry in the array is for the short filename. The second entry is for the long filename.

The d_ino and d_off fields are filled only for long filenames. The d_ino field holds the inode number of the directory. The d_off field holds the offset of the file entry in the directory. As these values are not available for short filenames, the user code should simply ignore them.

The field d_reclen contains the length of the filename in the field d_name. To keep backward compatibility, a length of 0 for the short filename signals that the end of the directory has been reached. However, the preferred method for detecting the end of the directory is to test the ioctl(2) return value. If no long filename exists, field d_reclen is set to 0 and d_name is a character string of length 0 for the long filename.  

RETURN VALUE

On error, -1 is returned, and errno is set to indicate the error.

For VFAT_IOCTL_READDIR_BOTH and VFAT_IOCTL_READDIR_SHORT a return value of 1 signals that a new directory entry has been read and a return value of 0 signals that the end of the directory has been reached.  

ERRORS

ENOENT
This error is returned by VFAT_IOCTL_READDIR_BOTH and VFAT_IOCTL_READDIR_SHORT if the file descriptor fd refers to a removed, but still open directory.
ENOTDIR
This error is returned by VFAT_IOCTL_READDIR_BOTH and VFAT_IOCTL_READDIR_SHORT if the file descriptor fd does not refer to a directory.
ENOTTY
The file descriptor fd does not refer to an object in a FAT filesystem.

For further error values, see ioctl(2).  

VERSIONS

VFAT_IOCTL_READDIR_BOTH and VFAT_IOCTL_READDIR_SHORT first appeared in Linux 2.0.

FAT_IOCTL_GET_ATTRIBUTES and FAT_IOCTL_SET_ATTRIBUTES first appeared in Linux 2.6.12.

FAT_IOCTL_GET_VOLUME_ID was introduced in version 3.11 of the Linux kernel.  

CONFORMING TO

This API is Linux-specific.  

EXAMPLE

 

Toggling the archive flag

The following program demonstrates the usage of ioctl(2) to manipulate file attributes. The program reads and displays the archive attribute of a file. After inverting the value of the attribute, the program reads and displays the attribute again.

The following was recorded when applying the program for the file /mnt/user/foo:

# ./toggle_fat_archive_flag /mnt/user/foo Archive flag is set Toggling archive flag Archive flag is not set  

Program source (toggle_fat_archive_flag.c)

#include <fcntl.h> #include <linux/msdos_fs.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/ioctl.h> #include <unistd.h>

/*
 * Read file attributes of a file on a FAT filesystem.
 * Output the state of the archive flag.
 */ static uint32_t readattr(int fd) {
    uint32_t attr;
    int ret;


    ret = ioctl(fd, FAT_IOCTL_GET_ATTRIBUTES, &attr);
    if (ret == -1) {
        perror("ioctl");
        exit(EXIT_FAILURE);
    }


    if (attr & ATTR_ARCH)
        printf("Archive flag is set\n");
    else
        printf("Archive flag is not set\n");


    return attr; }

int main(int argc, char *argv[]) {
    uint32_t attr;
    int fd;
    int ret;


    if (argc != 2) {
        printf("Usage: %s FILENAME\n", argv[0]);
        exit(EXIT_FAILURE);
    }


    fd = open(argv[1], O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }


    /*
     * Read and display the FAT file attributes.
     */
    attr = readattr(fd);


    /*
     * Invert archive attribute.
     */
    printf("Toggling archive flag\n");
    attr ^= ATTR_ARCH;


    /*
     * Write the changed FAT file attributes.
     */
    ret = ioctl(fd, FAT_IOCTL_SET_ATTRIBUTES, &attr);
    if (ret == -1) {
        perror("ioctl");
        exit(EXIT_FAILURE);
    }


    /*
     * Read and display the FAT file attributes.
     */
    readattr(fd);


    close(fd);


    exit(EXIT_SUCCESS); }  

Reading the volume ID

The following program demonstrates the use of ioctl(2) to display the volume ID of a FAT filesystem.

The following output was recorded when applying the program for directory /mnt/user:

$ ./display_fat_volume_id /mnt/user Volume ID 6443-6241  

Program source (display_fat_volume_id.c)

#include <fcntl.h> #include <linux/msdos_fs.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/ioctl.h> #include <unistd.h>

int main(int argc, char *argv[]) {
    uint32_t id;
    int fd;
    int ret;


    if (argc != 2) {
        printf("Usage: %s FILENAME\n", argv[0]);
        exit(EXIT_FAILURE);
    }


    fd = open(argv[1], O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }


    /*
     * Read volume ID.
     */
    ret = ioctl(fd, FAT_IOCTL_GET_VOLUME_ID, &id);
    if (ret == -1) {
        perror("ioctl");
        exit(EXIT_FAILURE);
    }


    /*
     * Format the output as two groups of 16 bits each.
     */
    printf("Volume ID %04x-%04x\n", id >> 16, id & 0xFFFF);


    close(fd);


    exit(EXIT_SUCCESS); }  

Listing a directory

The following program demonstrates the use of ioctl(2) to list a directory.

The following was recorded when applying the program to the directory /mnt/user:

$ ./fat_dir /mnt/user [char46] -> '' [char46]. -> '' ALONGF~1.TXT -> 'a long filename.txt' UPPER.TXT -> '' LOWER.TXT -> 'lower.txt'  

Program source

#include <fcntl.h> #include <linux/msdos_fs.h> #include <stdio.h> #include <stdlib.h> #include <sys/ioctl.h> #include <unistd.h>

int main(int argc, char *argv[]) {
    struct __fat_dirent entry[2];
    int fd;
    int ret;


    if (argc != 2) {
        printf("Usage: %s DIRECTORY\n", argv[0]);
        exit(EXIT_FAILURE);
    }


    /*
     * Open file descriptor for the directory.
     */
    fd = open(argv[1], O_RDONLY | O_DIRECTORY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }


    for (;;) {


        /*
         * Read next directory entry.
         */
        ret = ioctl( fd, VFAT_IOCTL_READDIR_BOTH, entry);


        /*
         * If an error occurs, the return value is -1.
         * If the end of the directory list has been reached,
         * the return value is 0.
         * For backward compatibility the end of the directory
         * list is also signaled by d_reclen == 0.
         */
        if (ret < 1)
            break;


        /*
         * Write both the short name and the long name.
         */
        printf("%s -> '%s'\n", entry[0].d_name, entry[1].d_name);
    }


    if (ret == -1) {
        perror("VFAT_IOCTL_READDIR_BOTH");
        exit(EXIT_FAILURE);
    }


    /*
     * Close the file descriptor.
     */
    close(fd);


    exit(EXIT_SUCCESS); }  

SEE ALSO

ioctl(2)  

COLOPHON

This page is part of release 4.13 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 https://www.kernel.org/doc/man-pages/.


 

Index

NAME
SYNOPSIS
DESCRIPTION
Reading and setting file attributes
Reading the volume ID
Reading short file names of a directory
RETURN VALUE
ERRORS
VERSIONS
CONFORMING TO
EXAMPLE
Toggling the archive flag
Program source (toggle_fat_archive_flag.c)
Reading the volume ID
Program source (display_fat_volume_id.c)
Listing a directory
Program source
SEE ALSO
COLOPHON


Please read "Why adblockers are bad".



Other free services
toURL.org
Shorten long
URLs to short
links like
http://tourl.org/2
tourl.org
.
Reverse DNS lookup
Find out which hostname(s)
resolve to a
given IP or other hostnames for the server
www.reversednslookup.org
rdf newsfeed | rss newsfeed | Atom newsfeed
- Powered by LeopardCMS - Running on Gentoo -
Copyright 2004-2017 Sascha Nitsch Unternehmensberatung UG(haftungsbeschränkt)
Valid XHTML1.1 : Valid CSS : buttonmaker
- Level Triple-A Conformance to Web Content Accessibility Guidelines 1.0 -
- Copyright and legal notices -
Time to create this page: 2.8 ms