vfs.c File Reference

#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <sys/kassert.h>
#include <sys/kdebug.h>
#include <sys/spinlock.h>
#include <sys/disk.h>
#include <sys/vfs.h>
#include <sys/handle.h>

Include dependency graph for vfs.c:

Go to the source code of this file.

Functions
VFS *	O2FS_Mount (Disk *root)
	DEFINE_SLAB (VFS, &vfsSlab)
	DEFINE_SLAB (VNode, &vnodeSlab)
int	VFS_MountRoot (Disk *rootDisk)
VNode *	VFS_Lookup (const char *path)
int	VFS_Stat (const char *path, struct stat *sb)
int	VFS_Open (VNode *fn)
int	VFS_Close (VNode *fn)
int	VFS_Read (VNode *fn, void *buf, uint64_t off, uint64_t len)
int	VFS_Write (VNode *fn, void *buf, uint64_t off, uint64_t len)
int	VFS_ReadDir (VNode *fn, void *buf, uint64_t len, uint64_t *off)

Variables
static Spinlock	vfsLock
static VFS *	rootFS
static VNode *	rootNode
static Slab	vfsSlab
static Slab	vnodeSlab

Function Documentation

DEFINE_SLAB() [1/2]

DEFINE_SLAB	(	VFS	,
		&	vfsSlab
	)

DEFINE_SLAB() [2/2]

DEFINE_SLAB	(	VNode	,
		&	vnodeSlab
	)

O2FS_Mount()

VFS * O2FS_Mount

(

Disk *

root

)

Definition at line 42 of file o2fs.c.

{
    int status;
    VFS *fs = VFS_Alloc();
    BufCacheEntry *entry;
    SuperBlock *sb;
 
    ASSERT(sizeof(BDirEntry) == 512);
 
    if (!fs)
        return NULL;
 
    status = BufCache_Read(disk, 0, &entry);
    if (status < 0) {
        Alert(o2fs, "Disk cache read failed\n");
        return NULL;
    }
 
    // Read superblock
    sb = entry->buffer;
    if (memcmp(sb->magic, SUPERBLOCK_MAGIC, 8) != 0) {
        Alert(o2fs, "Invalid file system\n");
        BufCache_Release(entry);
        return NULL;
    }
    if (sb->versionMajor != O2FS_VERSION_MAJOR ||
        sb->versionMinor != O2FS_VERSION_MINOR) {
        Alert(o2fs, "Unsupported file system version\n");
        BufCache_Release(entry);
        return NULL;
    }
 
    // Read bitmap
    for (int i = 0; i < sb->bitmapSize; i++) {
        ASSERT(i < 16);
 
        BufCacheEntry *bentry;
        uint64_t offset = sb->bitmapOffset + i * sb->blockSize;
 
        if (BufCache_Read(disk, offset, &bentry) < 0) {
            Alert(o2fs, "Bitmap read failed\n");
            for (i = 0; i < 16; i++)
                BufCache_Release(fs->bitmap[i]);
            BufCache_Release(entry);
            return NULL;
        }
 
        fs->bitmap[i] = bentry;
    }
 
    DLOG(o2fs, "File system mounted\n");
    DLOG(o2fs, "Root @ 0x%llx\n", sb->root.offset);
 
    fs->fsptr = entry;
    fs->fsval = sb->root.offset;
    fs->blksize = sb->blockSize;
 
    // Setup VFS structure
    fs->op = &O2FSOperations;
    fs->disk = disk;
    Spinlock_Init(&fs->lock, "O2FS Lock", SPINLOCK_TYPE_NORMAL);
    fs->refCount = 1;
    fs->root = NULL;
 
    status = O2FS_GetRoot(fs, &fs->root);
    if (status < 0) {
        Alert(o2fs, "Mount failed");
        BufCache_Release(entry);
        return NULL;
    }
 
    return fs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

VFS_Close()

int VFS_Close

(

VNode *

fn

)

VFS_Close –

Close a vnode.

Parameters

[in]

fn

VNode to close.

Returns

Return status

Definition at line 162 of file vfs.c.

{
    return fn->op->close(fn);
}

Here is the caller graph for this function:

VFS_Lookup()

VNode * VFS_Lookup

(

const char *

path

)

VFS_Lookup –

Lookup a VNode by a path. This function recursively searches the directory heirarchy until the given path is found otherwise returns NULL if not found.

Definition at line 63 of file vfs.c.

{
    int status;
    const char *start = path + 1; 
    const char *end = path + 1;
    uint64_t len;
    VNode *curNode;
    VNode *oldNode;
    char curName[256];
 
    if (path[0] != '/')
        return NULL;
 
    status = rootFS->op->getroot(rootFS, &curNode);
    if (status < 0)
        Panic("Failed to get root VNode\n");
 
    while (1) {
        while (*end != '\0' && *end != '/')
            end++;
 
        len = (size_t)(end - start);
        if (len == 0) {
            // Handle root and trailing slash
            return curNode;
        }
        if (len > 256) {
            // Release
            return NULL;
        }
 
        memcpy(curName, start, len);
        curName[len] = '\0';
 
        oldNode = curNode;
        curNode = NULL;
        status = oldNode->op->lookup(oldNode, &curNode, curName);
        if (status < 0) {
            // Release
            return NULL;
        }
 
        // Release oldNode
 
        if (*end == '\0') {
            Log(vfs, "%s %lx\n", path, curNode);
            return curNode;
        }
 
        start = end + 1;
        end = end + 1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

VFS_MountRoot()

int VFS_MountRoot

(

Disk *

rootDisk

)

VFS_MountRoot –

Mount the root file system from a specific disk.

Definition at line 36 of file vfs.c.

{
    int status;
 
    Spinlock_Init(&vfsLock, "VFS Lock", SPINLOCK_TYPE_NORMAL);
 
    Slab_Init(&vfsSlab, "VFS Slab", sizeof(VFS), 16);
    Slab_Init(&vnodeSlab, "VNode Slab", sizeof(VNode), 16);
 
    rootFS = O2FS_Mount(rootDisk);
    if (!rootFS)
        return -1;
 
    status = rootFS->op->getroot(rootFS, &rootNode);
    if (status < 0)
        Panic("Failed to get root VNode\n");
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

VFS_Open()

int VFS_Open

(

VNode *

fn

)

VFS_Open –

Open a vnode for reading and writing.

Parameters

[in]

fn

VNode to open.

Returns

Return status

Definition at line 147 of file vfs.c.

{
    return fn->op->open(fn);
}

Here is the caller graph for this function:

VFS_Read()

int VFS_Read	(	VNode *	fn,
		void *	buf,
		uint64_t	off,
		uint64_t	len
	)

VFS_Read –

Read from a vnode.

Parameters

[in]	fn	VNode to read from.
[in]	buf	Buffer to write the data to.
[in]	off	File offset in bytes.
[in]	len	Length to read in bytes.

Returns

Return status

Definition at line 180 of file vfs.c.

{
    return fn->op->read(fn, buf, off, len);
}

Here is the caller graph for this function:

VFS_ReadDir()

int VFS_ReadDir	(	VNode *	fn,
		void *	buf,
		uint64_t	len,
		uint64_t *	off
	)

VFS_ReadDir –

Read a directory entry from a vnode.

Parameters

[in]	fn	VNode to read from.
[in]	buf	Buffer to write the data to.
[in]	off	Directory offset in bytes.
[in]	len	Length to read in bytes.

Returns

Return status

Definition at line 216 of file vfs.c.

{
    return fn->op->readdir(fn, buf, len, off);
}

Here is the caller graph for this function:

VFS_Stat()

int VFS_Stat	(	const char *	path,
		struct stat *	sb
	)

VFS_Stat –

Return the struct stat that contains the file and directory information for a given VNode.

Definition at line 124 of file vfs.c.

{
    VNode *vn = VFS_Lookup(path);
    if (vn == NULL)
        return -ENOENT;
 
    vn->op->stat(vn, sb);
 
    // Release
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

VFS_Write()

int VFS_Write	(	VNode *	fn,
		void *	buf,
		uint64_t	off,
		uint64_t	len
	)

VFS_Write –

Write from a vnode.

Parameters

[in]	fn	VNode to write to.
[in]	buf	Buffer to read the data from.
[in]	off	File offset in bytes.
[in]	len	Length to read in bytes.

Returns

Return status

Definition at line 198 of file vfs.c.

{
    return fn->op->write(fn, buf, off, len);
}

Here is the caller graph for this function:

Variable Documentation

rootFS

VFS* rootFS

static

Definition at line 21 of file vfs.c.

rootNode

VNode* rootNode

static

Definition at line 22 of file vfs.c.

vfsLock

Spinlock vfsLock

static

Definition at line 20 of file vfs.c.

vfsSlab

Slab vfsSlab

static

Definition at line 24 of file vfs.c.

vnodeSlab

Slab vnodeSlab

static

Definition at line 25 of file vfs.c.