Defined In: be/kernel/fs_attr.h

typedef struct attr_info
   uint32 type;
   off_t size;
} attr_info;

The attr_info structure contains the following members

Declared in: be/storage/Entry.h

struct entry_ref {
               entry_ref();
               entry_ref(dev_t device, ino_t dir, const char* name);
               entry_ref(const entry_ref& ref);
               ~entry_ref();

    status_t   set_name(const char* name);
    bool       operator==(const entry_ref& ref) const;
    bool       operator!=(const entry_ref& ref) const;
    entry_ref& operator=(const entry_ref& ref);

    dev_t      device;
    ino_t      directory;
    char*      name;
}

The entry_ref structure describes a single entry in a directory.

The constructor for the entry_ref structure. The first of these creates an empty entry_ref, the second duplicates an existing entry_ref, and the last version of the constructor accepts a device number, directory inode number, and a file name and constructs an entry_ref referring to that entry.

The destructor for entry_ref.

Lets you change the name of the file referred to by the entry_ref structure.

operator ==

Lets you perform comparisons of entry_ref structures to see if they refer to the same entry.

operator !=

Lets you test to see if two entry_ref structures refer to different entries.

Declared in: be/storage/Node.h

struct node_ref {
              node_ref();
              node_ref(const node_ref& ref);
              ~node_ref();

    bool      operator==(const node_ref& ref) const;
    bool      operator!=(const node_ref& ref) const;
    node_ref& operator=(const node_ref& ref);

    dev_t     device;
    ino_t     node;
}

The node_ref structure describes a node in a file system.

The constructor for the node_ref structure. The first of these creates an empty node_ref, and the second duplicates an existing node_ref.

The destructor for node_ref.

operator ==

Lets you perform comparisons of node_ref structures to see if they refer to the same node.

operator !=

Lets you test to see if two node_ref structures refer to different nodes.

Declared in: be/storage/AppFileInfo.h

struct version_info {
    uint32    major;
    uint32    middle;
    uint32    minor;
    uint32    variety;
    uint32    internal;
    char      short_info[64];
    char      long_info[256];
}

The version_info structure is used to contain version information about an application. Although none of these fields have prescribed uses, and you can use them for anything you want, their names do hint at their suggested uses.

The query_op constants are used to construct the predicate for a BQuery:

Declared in: be/posix/sys/stat.h

The stat structure looks like this:

struct stat {
   dev_t         st_dev;
   ino_t         st_ino;
   mode_t        st_mode;
   nlink_t       st_nlink;
   uid_t         st_uid;
   gid_t         st_gid;
   off_t         st_size;
   dev_t         st_rdev;
   size_t        st_blksize;
   time_t        st_atime;
   time_t        st_mtime;
   time_t        st_ctime;
} stat;

And the fields are…

The fs_info structure is defined as:

typedef struct fs_info {
    dev_t     dev;
    ino_t     root;
    uint32    flags;
    off_t     block_size;
    off_t     io_size;
    off_t     total_blocks;
    off_t     free_blocks;
    off_t     total_nodes;
    off_t     free_nodes;
    char      device_name[128];
    char      volume_name[B_FILE_NAME_LENGTH];
    char      fsh_name[B_OS_NAME_LENGTH];
};

The structure's fields are:

The flags can be any combination of the following values, which specify the attributes of the file system on the device:

The information in the fs_info structure is guaranteed to be internally consistent, but the structure as a whole should be considered to be out-of-date as soon as you receive it. It provides a picture of a device as it exists just before the info-retrieving function returns. In particular, the number of free blocks and of free nodes can easily change immediately after you receive this information.