superblock.h

Go to the documentation of this file.

#pragma once
 
#include <kernel/fs/devfs.h>
#include <kernel/io/irp.h>
#include <kernel/utils/ref.h>
 
#include <stdint.h>
#include <sys/fs.h>
#include <sys/list.h>
 
typedef struct filesystem filesystem_t;
typedef struct superblock superblock_t;
typedef struct superblock_ops superblock_ops_t;
typedef struct dentry_ops dentry_ops_t;
typedef struct vnode vnode_t;
typedef struct dentry dentry_t;
 
/**
 * @brief Mounted filesystem.
 * @defgroup kernel_fs_superblock Superblock
 * @ingroup kernel_fs
 *
 * A superblock represents a mounted filesystem.
 *
 * @{
 */
 
/**
 * @brief Superblock structure.
 * @struct superblock_t
 */
typedef struct superblock
{
    ref_t ref;
    list_entry_t entry;
    sbid_t id;
    uint64_t blockSize;
    uint64_t maxFileSize;
    void* data;
    dentry_t* root; ///< Root dentry of the filesystem, should not take a reference.
    const superblock_ops_t* ops;
    const dentry_ops_t* dentryOps;
    const irp_vtable_t* vtable;
    filesystem_t* fs;
    /**
     * The number of mounts of this superblock.
     *
     * Note that this does need to be separate from the reference count as a superblock is referenced by mounts,
     * but it can also be referenced by other things like open files.
     */
    atomic_uint64_t mountCount;
} superblock_t;
 
/**
 * @brief Superblock operations structure.
 * @struct superblock_ops_t
 */
typedef struct superblock_ops
{
    /**
     * Called when the filesystem is superblock is being freed to give the filesystem a chance to clean up any private
     * data.
     */
    void (*cleanup)(superblock_t* superblock);
    /**
     * Called when the the superblocks `mountCount` reaches zero, meaning it is not visible anywhere in any namespace.
     */
    void (*unmount)(superblock_t* superblock);
} superblock_ops_t;
 
/**
 * @brief Create a new superblock.
 *
 * This does not add the superblock to the superblock cache, the `vfs_mount()` function will do that using
 * `vfs_add_superblock()`.
 *
 * There is no `superblock_free()` instead use `UNREF()`.
 *
 * Note that the superblock's `root` dentry must be created and assigned after calling this function.
 *
 * @param fs The filesystem type of the superblock.
 * @param ops The superblock operations, can be NULL.
 * @param dentryOps The dentry operations for dentries in this superblock, can be NULL.
 * @return On success, the new superblock. On failure, returns `NULL` and `errno` is set to:
 * - `EINVAL`: Invalid parameters.
 * - `ENOMEM`: Out of memory.
 */
superblock_t* superblock_new(filesystem_t* fs, const superblock_ops_t* ops, const dentry_ops_t* dentryOps);
 
/**
 * @brief Increment the mount count of a superblock.
 *
 * @param superblock Pointer to the superblock.
 */
void superblock_inc_mount_count(superblock_t* superblock);
 
/**
 * @brief Decrement the mount count of a superblock.
 *
 * If the mount count reaches zero, the `unmount` operation is called if its not `NULL`.
 *
 * @param superblock Pointer to the superblock.
 */
void superblock_dec_mount_count(superblock_t* superblock);
 
/** @} */