vfs.h

Go to the documentation of this file.

 
#ifndef _PSP2KERN_VFS_H_
#define _PSP2KERN_VFS_H_
 
#include <vitasdk/build_utils.h>
#include <psp2common/kernel/iofilemgr.h>
#include <psp2kern/kernel/threadmgr/fast_mutex.h>
#include <psp2kern/types.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
// Forward declarations
typedef struct SceVfsMount SceVfsMount;
typedef struct SceVfsVnode SceVfsVnode;
typedef struct SceVfsFile SceVfsFile;
typedef struct SceVfsOpTable SceVfsOpTable;
typedef struct SceVopTable SceVopTable;
 
#define SCE_VFS_TYPE_FS    (0x00000000)
#define SCE_VFS_TYPE_DEVFS (0x00000010)
 
typedef struct SceVfsInfo {
    const SceVfsOpTable *vfs_ops;    
    const char *vfs_name;            
    SceSize vfs_name_len;            
 
    SceUInt32 ref_count;             
    SceUInt32 type;                  
 
    const SceVopTable *default_vops; 
    void *vfs_data;                  
 
    struct SceVfsInfo *next;         
} SceVfsInfo;
VITASDK_BUILD_ASSERT_EQ(0x20, SceVfsInfo);
 
typedef struct SceVfsPath {
    const char *name;    
    SceSize name_length; 
    const char *path;    
} SceVfsPath;
VITASDK_BUILD_ASSERT_EQ(0xC, SceVfsPath);
 
typedef struct SceVfsMountData {
    const char *assign_name;           
    const char *fs_name;               
    const char *blockdev_name;         
    const char *blockdev_name_no_part; 
    SceUInt32 mnt_id;                  
} SceVfsMountData;
VITASDK_BUILD_ASSERT_EQ(0x14, SceVfsMountData);
 
#define SCE_VFS_FS_TYPE_FS      (0x01) 
#define SCE_VFS_FS_TYPE_PFS     (0x03) 
#define SCE_VFS_FS_TYPE_HOSTFS  (0x04) 
#define SCE_VFS_FS_TYPE_BLKDEV  (0x10) 
#define SCE_VFS_FS_TYPE_CHRDEV  (0x20) 
 
#define SCE_VFS_MOUNT_TYPE_PFS          (0x00000001) 
#define SCE_VFS_MOUNT_TYPE_FSROOT       (0x00000002) 
#define SCE_VFS_MOUNT_TYPE_DEVFS        (0x00000003) 
#define SCE_VFS_MOUNT_TYPE_STACKFS      (0x00000005) 
#define SCE_VFS_MOUNT_TYPE_HOSTFS       (0x00000006) 
#define SCE_VFS_MOUNT_FLAG_TYPE_MASK    (0x000000FF)
#define SCE_VFS_MOUNT_FLAG_RDONLY       (0x00001000) 
#define SCE_VFS_MOUNT_FLAG_NOBUF        (0x00002000) 
#define SCE_VFS_MOUNT_FLAG_NUMBERED     (0x00004000)
#define SCE_VFS_MOUNT_FLAG_REMOTE       (0x00008000) 
#define SCE_VFS_MOUNT_FLAG_INTERNAL     (0x00010000)
#define SCE_VFS_MOUNT_FLAG_EXTERNAL     (0x00020000)
#define SCE_VFS_MOUNT_FLAG_WRITE_CACHE  (0x00040000) 
#define SCE_VFS_MOUNT_FLAG_NO_RECLAIM   (0x00100000) 
 
typedef struct SceVfsMount {
    SceKernelFastMutex fast_mutex;
 
    SceVfsVnode *mnt_vnode;
 
    SceUID allocator;
 
    SceUInt32 state;
    SceUInt8 fs_type;    
    SceUInt16 opt;
    SceUInt32 mnt_flags; 
 
    SceVfsVnode *vnode_list;
    SceUInt32 vnode_num;
 
    SceVfsInfo *mnt_vfs_inf;
    SceUInt32 mnt_ref_count;
 
    SceUInt32 opened_entry_num;
    SceUInt32 available_entry_num;
 
    SceUID pid;
 
    SceVfsMount *mnted_on_list;
    SceVfsMount *mnted_on_list_prev;
    SceVfsMount *mnt_list_next;
 
    SceVfsMountData *mnt_data;
    char path[64];
 
    SceUInt32 default_io_cache_size;
 
    void *data;  
 
    struct FdLock *fd_lock;
    struct Fumount *fumount;
 
    SceUInt32 opaque[4];  // Backing storage for pFdLock
    SceUInt32 opaque2[4]; // Backing storage for pFumount
 
    SceUInt8 padding[16];
} SceVfsMount;
VITASDK_BUILD_ASSERT_EQ(0x100, SceVfsMount);
 
#define SCE_VNODE_TYPE_REG     (0x00000001) 
#define SCE_VNODE_TYPE_DIR     (0x00000002) 
#define SCE_VNODE_TYPE_CHR     (0x00000010) 
#define SCE_VNODE_TYPE_ROOT    (0x00001000) 
#define SCE_VNODE_TYPE_DEV     (0x00002000) 
#define SCE_VNODE_TYPE_MOUNTED (0x00004000) 
 
#define SCE_VNODE_TYPE_CHRDEV        (SCE_VNODE_TYPE_DEV | SCE_VNODE_TYPE_CHR)
#define SCE_VNODE_TYPE_ROOTDIR       (SCE_VNODE_TYPE_ROOT | SCE_VNODE_TYPE_DIR) 
#define SCE_VNODE_TYPE_ROOTDIR_DEVFS (0x10000 | 0x20) 
 
#define SCE_VNODE_STATE_ACTIVE    (0x00000001) 
#define SCE_VNODE_STATE_INACTIVE  (0x00000100) 
#define SCE_VNODE_STATE_UNMOUNTED (0x00000200)
#define SCE_VNODE_STATE_DELETED   (0x00000400)
#define SCE_VNODE_STATE_RECLAIMED (0x00002000)
#define SCE_VNODE_STATE_NEW       (0x00008000)
 
typedef struct SceVfsVnode {
    struct {
        SceUInt32 waiter;
        SceUID owner_id;
        SceUInt32 recursive_count;
        SceUID wait_id;
        SceUInt32 wait_pattern;
    } vdlock;
 
    SceUInt8 padding[44];
 
    struct {  
        SceVopTable *ops;
 
        SceUInt32 node_inf; 
        void *node_data;    
 
        SceVfsMount *mnt;
 
        SceVfsVnode *dd;   
        SceVfsVnode *next;
 
        SceUInt32 ref_count;
 
        struct BuffCache *bc;
 
        SceUInt32 fid[2];
        struct Flock *flock;
 
        SceUID allocator;
 
        struct Ncache *ncache;
 
        SceUInt32 state; 
        SceUInt32 type;  
 
        SceVopTable *vop_tbl; 
 
        SceUInt64 size;
        SceUInt32 acl_data[2]; 
 
        SceVfsFile *fd_list;
        SceUInt32 fd_num;
 
        SceVfsVnode *link_to;
        SceUInt32 linked_num;
 
        SceUInt8 unused[48];
 
        SceUInt32 mnt_opt;
        SceUInt32 unk_0xd4;
    } core;
 
    SceUInt8 padding2[40];
} SceVfsVnode;
VITASDK_BUILD_ASSERT_EQ(0x100, SceVfsVnode);
 
#define SCE_VFS_FILE_STATE_OPEN   (0x00000001) 
#define SCE_VFS_FILE_STATE_CLOSED (0x00000200) 
#define SCE_VFS_FILE_STATE_UNK    (0x00000800) 
#define SCE_VFS_FILE_STATE_DUMMY  (0x00010000) 
 
typedef struct SceVfsFile {
    SceUInt32 is_dir;
    SceUInt32 flags;
 
    SceOff position;
 
    SceUInt32 state;
    SceUID pid;
 
    SceVfsVnode *vp;
    SceVfsFile *next;
 
    SceUInt32 fd; 
    SceUInt16 flock_busy_count;
 
    SceUInt8 is_locked;
    SceUInt8 has_flock_ent;
 
    struct FdLock *fd_lock;
 
    SceUInt32 idata;
 
    struct DebugPath *debug_path; 
 
    SceUInt32 ioSchedData[3];
} SceVfsFile;
VITASDK_BUILD_ASSERT_EQ(0x40, SceVfsFile);
typedef struct SceVfsOpMountArgs {
    SceVfsMount *mnt;
    SceVfsPath *dev_file_path; 
} SceVfsOpMountArgs;
VITASDK_BUILD_ASSERT_EQ(0x8, SceVfsOpMountArgs);
 
typedef struct SceVfsOpUmountArgs {
    SceVfsMount *mnt;
    int flags;
} SceVfsOpUmountArgs;
VITASDK_BUILD_ASSERT_EQ(0x8, SceVfsOpUmountArgs);
 
typedef struct SceVfsOpSetRootArgs {
    SceVfsMount *mnt;
    int unk;
    struct SceVfsVnode *vp;
} SceVfsOpSetRootArgs;
VITASDK_BUILD_ASSERT_EQ(0xC, SceVfsOpSetRootArgs);
 
typedef struct SceVfsOpGetRootArgs {
    SceVfsMount *mnt;
    int unk;
    struct SceVfsVnode **vpp;
} SceVfsOpGetRootArgs;
VITASDK_BUILD_ASSERT_EQ(0xC, SceVfsOpGetRootArgs);
 
typedef struct SceVfsOpSyncArgs {
    SceVfsMount *mnt;
    int flags;
} SceVfsOpSyncArgs;
VITASDK_BUILD_ASSERT_EQ(0x8, SceVfsOpSyncArgs);
 
typedef struct SceVfsOpInitArgs {
    SceVfsInfo *vfs_inf;
} SceVfsOpInitArgs;
VITASDK_BUILD_ASSERT_EQ(0x4, SceVfsOpInitArgs);
 
typedef struct SceVfsOpFiniArgs {
    SceVfsInfo *vfs_inf;
} SceVfsOpFiniArgs;
VITASDK_BUILD_ASSERT_EQ(0x4, SceVfsOpFiniArgs);
 
typedef struct SceVfsOpDevctlArg {
    SceVfsMount *mnt;
    const char *dev;
    unsigned int cmd;
    const void *arg;
    SceSize arg_len;
    void *buf;
    SceSize buf_len;
} SceVfsOpDevctlArg;
VITASDK_BUILD_ASSERT_EQ(0x1C, SceVfsOpDevctlArg);
 
typedef struct SceVfsOpDecodePathElemArgs { 
    SceVfsMount *mnt;
    const char *path;
    const char **path2;  // path + something
    const char **path3;  // path3 + *decodeLen
    char *buf;
    SceSize buf_len;
    SceSize *decode_len; // out
} SceVfsOpDecodePathElemArgs;
VITASDK_BUILD_ASSERT_EQ(0x1C, SceVfsOpDecodePathElemArgs);
 
typedef struct SceVfsOpTable {
    int (*vfs_mount)(SceVfsOpMountArgs *argp);
    int (*vfs_umount)(SceVfsOpUmountArgs *argp);
    int (*vfs_set_root)(SceVfsOpSetRootArgs *argp);
    int (*vfs_get_root)(SceVfsOpGetRootArgs *argp);
 
    void *reserved[2]; // Unused
 
    int (*vfs_sync)(SceVfsOpSyncArgs *argp);
 
    void *reserved2; // Unused
 
    int (*vfs_init)(SceVfsOpInitArgs *argp);
    int (*vfs_fini)(SceVfsOpFiniArgs *argp);
 
    void *reserved3; // Unused
 
    int (*vfs_devctl)(SceVfsOpDevctlArg *arg);
    int (*vfs_decode_path_elem)(SceVfsOpDecodePathElemArgs *argp);
} SceVfsOpTable;
VITASDK_BUILD_ASSERT_EQ(0x34, SceVfsOpTable);
typedef struct SceVopOpenArgs {
    SceVfsVnode *vp;
    SceVfsPath *path;
    int flags;
    SceVfsFile *file;
} SceVopOpenArgs;
VITASDK_BUILD_ASSERT_EQ(0x10, SceVopOpenArgs);
 
typedef struct SceVopCreateArgs {
    SceVfsVnode *dvp;
    SceVfsVnode **vpp;
    SceVfsPath *path;
    int flags;
    int mode;
} SceVopCreateArgs;
VITASDK_BUILD_ASSERT_EQ(0x14, SceVopCreateArgs);
 
typedef struct SceVopCloseArgs {
    SceVfsVnode *vp;
    SceVfsFile *file;
} SceVopCloseArgs;
VITASDK_BUILD_ASSERT_EQ(0x8, SceVopCloseArgs);
 
typedef struct SceVopLookupArgs {
    SceVfsVnode  *dvp;
    SceVfsVnode **vpp;
    SceVfsPath *path;
    SceUInt32 flags;
} SceVopLookupArgs;
VITASDK_BUILD_ASSERT_EQ(0x10, SceVopLookupArgs);
 
typedef struct SceVopReadArgs {
    SceVfsVnode *vp;
    SceVfsFile *file;
    void *buf;
    SceSize nbyte;
} SceVopReadArgs;
VITASDK_BUILD_ASSERT_EQ(0x10, SceVopReadArgs);
 
typedef struct SceVopWriteArgs {
    SceVfsVnode *vp;
    SceVfsFile *file;
    const void *buf;
    SceSize nbyte;
} SceVopWriteArgs;
VITASDK_BUILD_ASSERT_EQ(0x10, SceVopWriteArgs);
 
typedef struct SceVopLseekArgs {
    SceVfsVnode *vp;
    SceVfsFile *file;
    SceOff offset;
    int whence;
} SceVopLseekArgs;
VITASDK_BUILD_ASSERT_EQ(0x18, SceVopLseekArgs); // really 0x18 by SceOff align 8?
 
typedef struct SceVopIoctlArgs {
    SceVfsVnode *vp;
    SceVfsFile *file;
    int cmd;
    const void *in_data;
    SceSize in_len;
    void *out_data;
    SceSize out_len;
} SceVopIoctlArgs;
VITASDK_BUILD_ASSERT_EQ(0x1C, SceVopIoctlArgs);
 
typedef struct SceVopRemoveArgs {
    SceVfsVnode *dvp;
    SceVfsVnode *vp;
    SceVfsPath *path;
    SceUInt32 flags;
} SceVopRemoveArgs;
VITASDK_BUILD_ASSERT_EQ(0x10, SceVopRemoveArgs);
 
typedef struct SceVopMkdirArgs {
    SceVfsVnode  *dvp;
    SceVfsVnode **vpp;
    SceVfsPath *path;
    int mode;
} SceVopMkdirArgs;
VITASDK_BUILD_ASSERT_EQ(0x10, SceVopMkdirArgs);
 
typedef struct SceVopRmdirArgs {
    SceVfsVnode *dvp;
    SceVfsVnode *vp;
    SceVfsPath *path;
} SceVopRmdirArgs;
VITASDK_BUILD_ASSERT_EQ(0xC, SceVopRmdirArgs);
 
typedef struct SceVopDopenAgrs {
    SceVfsVnode *vp;
    SceVfsPath *path;
    SceVfsFile *file;
} SceVopDopenAgrs;
VITASDK_BUILD_ASSERT_EQ(0xC, SceVopDopenAgrs);
 
typedef struct SceVopDcloseArgs {
    SceVfsVnode *vp;
    SceVfsFile *file;
} SceVopDcloseArgs;
VITASDK_BUILD_ASSERT_EQ(0x8, SceVopDcloseArgs);
 
typedef struct SceVopDreadArgs {
    SceVfsVnode *vp;
    SceVfsFile *file;
    SceIoDirent *dir;
} SceVopDreadArgs;
VITASDK_BUILD_ASSERT_EQ(0xC, SceVopDreadArgs);
 
typedef struct SceVopGetstatArgs {
    SceVfsVnode *vp;
    SceVfsPath *path;
    SceIoStat *stat;
} SceVopGetstatArgs;
VITASDK_BUILD_ASSERT_EQ(0xC, SceVopGetstatArgs);
 
typedef struct SceVopChstatArgs {
    SceVfsVnode *vp;
    SceVfsPath *path;
    SceIoStat *stat;
    int bit;
} SceVopChstatArgs;
VITASDK_BUILD_ASSERT_EQ(0x10, SceVopChstatArgs);
 
typedef struct SceVopFchstatArgs {
    SceVfsVnode *vp;
    SceVfsFile *file;
    SceIoStat *stat;
    SceUInt32 bit;
} SceVopFchstatArgs;
VITASDK_BUILD_ASSERT_EQ(0x10, SceVopFchstatArgs);
 
typedef struct SceVopFgetstatArgs {
    SceVfsVnode *vp;
    SceVfsFile *file;
    SceIoStat *stat;
} SceVopFgetstatArgs;
VITASDK_BUILD_ASSERT_EQ(0xC, SceVopFgetstatArgs);
 
typedef struct SceVopInactiveArgs {
    SceVfsVnode *vp;
} SceVopInactiveArgs;
VITASDK_BUILD_ASSERT_EQ(0x4, SceVopInactiveArgs);
 
typedef struct SceVopLinkArgs {
    SceVfsVnode *fvp;
    SceVfsVnode *tvp;
} SceVopLinkArgs;
VITASDK_BUILD_ASSERT_EQ(0x8, SceVopLinkArgs);
 
typedef struct SceVopUnlinkArgs {
    SceVfsVnode *fvp;
    SceVfsVnode *tvp;
} SceVopUnlinkArgs;
VITASDK_BUILD_ASSERT_EQ(0x8, SceVopUnlinkArgs);
 
typedef struct SceVopSyncArgs {
    SceVfsVnode *vp;
    SceVfsFile *file;
    int flags;
} SceVopSyncArgs;
VITASDK_BUILD_ASSERT_EQ(0xC, SceVopSyncArgs);
 
typedef struct SceVopRenameArgs {
    SceVfsVnode *odvp;
    SceVfsVnode *ovp;
    SceVfsPath *old_path;
    SceVfsVnode *ndvp;
    SceVfsVnode **nvpp;
    SceVfsPath *new_path;
} SceVopRenameArgs;
VITASDK_BUILD_ASSERT_EQ(0x18, SceVopRenameArgs);
 
typedef struct SceVopPreadArgs {
    SceVfsVnode *vp;
    SceVfsFile *file;
    void *buf;
    SceSize nbyte;
    SceOff offset;
} SceVopPreadArgs;
VITASDK_BUILD_ASSERT_EQ(0x18, SceVopPreadArgs);
 
typedef struct SceVopPwriteArgs {
    SceVfsVnode *vp;
    SceVfsFile *file;
    const void *buf;
    SceSize nbyte;
    SceOff offset;
} SceVopPwriteArgs;
VITASDK_BUILD_ASSERT_EQ(0x18, SceVopPwriteArgs);
 
typedef struct SceVopWhiteoutArgs {
    SceVfsVnode *dvp;
    SceVfsVnode *vp;
    SceVfsPath *old_path;
    SceVfsPath *new_path;
} SceVopWhiteoutArgs;
VITASDK_BUILD_ASSERT_EQ(0x10, SceVopWhiteoutArgs);
 
typedef struct SceVopCleanupArgs {
    SceVfsVnode *vp;
    SceVfsFile *file;
} SceVopCleanupArgs;
VITASDK_BUILD_ASSERT_EQ(0x8, SceVopCleanupArgs);
 
typedef struct SceVopZerofillArgs {
    SceVfsVnode *vp;
    SceUInt64 unk;
    SceUInt64 unk1;
    SceUInt64 unk2;
} SceVopZerofillArgs;
VITASDK_BUILD_ASSERT_EQ(0x20, SceVopZerofillArgs);
 
typedef struct SceVopTable {
    int (*vop_open)(SceVopOpenArgs *argp);
    int (*vop_create)(SceVopCreateArgs *argp);
    int (*vop_close)(SceVopCloseArgs *argp);
    int (*vop_lookup)(SceVopLookupArgs *argp);
 
    SceSSize (*vop_read)(SceVopReadArgs *argp);
    SceSSize (*vop_write)(SceVopWriteArgs *argp);
    SceOff (*vop_lseek)(SceVopLseekArgs *argp);
 
    int (*vop_ioctl)(SceVopIoctlArgs *argp);
 
    int (*vop_remove)(SceVopRemoveArgs *argp);
 
    int (*vop_mkdir)(SceVopMkdirArgs *argp);
    int (*vop_rmdir)(SceVopRmdirArgs *argp);
 
    int (*vop_dopen)(SceVopDopenAgrs *argp);
    int (*vop_dclose)(SceVopDcloseArgs *argp);
    int (*vop_dread)(SceVopDreadArgs *argp);
 
    int (*vop_getstat)(SceVopGetstatArgs *argp);
    int (*vop_chstat)(SceVopChstatArgs *argp);
 
    int (*vop_rename)(SceVopRenameArgs *argp);
 
    const void *reserved; // Unused
 
    SceSSize (*vop_pread)(SceVopPreadArgs *argp);
    SceSSize (*vop_pwrite)(SceVopPwriteArgs *argp);
 
    int (*vop_inactive)(SceVopInactiveArgs *argp);
    int (*vop_link)(SceVopLinkArgs *argp);
    int (*vop_unlink)(SceVopUnlinkArgs *argp);
 
    int (*vop_sync)(SceVopSyncArgs *argp);
 
    int (*vop_fgetstat)(SceVopFgetstatArgs *argp);
    int (*vop_fchstat)(SceVopFchstatArgs *argp);
 
    int (*vop_whiteout)(SceVopWhiteoutArgs *argp);
    int (*vop_cleanup)(SceVopCleanupArgs *argp);
    int (*vop_verofill)(SceVopZerofillArgs *argp);
} SceVopTable;
VITASDK_BUILD_ASSERT_EQ(0x74, SceVopTable);
typedef struct SceVfsMountParam {
    const char *root_path;       
    const char *blockdev_name;   
 
    SceUInt8 fs_type;      
    SceUInt16 opt;         
    SceUInt32 mnt_flags;   
 
    const char *vfs_name;        
 
    void *data;            
 
    SceVfsMountData *misc;
 
    SceVopTable *vops;     
} SceVfsMountParam;
VITASDK_BUILD_ASSERT_EQ(0x20, SceVfsMountParam);
 
#define SCE_VFS_UMOUNT_FLAG_FORCE (0x1) 
 
typedef struct SceVfsUmountParam {
    const char *assign_name; 
    int flag;         
} SceVfsUmountParam;
VITASDK_BUILD_ASSERT_EQ(0x8, SceVfsUmountParam);
 
int ksceVfsAddVfs(SceVfsInfo *vfs_info);
int ksceVfsDeleteVfs(const char *name, SceVfsInfo **vfs_info);
 
int vfsMount(SceVfsMountParam *param);
int vfsUmount(SceVfsUmountParam *param);
 
int vfsMountForPFS(SceVfsMountParam *param);
int vfsUmountForPFS(SceVfsUmountParam *param, int unk, int unk2);
 
int vfsLockMnt(SceVfsMount *mnt);
int vfsUnlockMnt(SceVfsMount *mnt);
SceBool vfsIsLockedMnt(SceVfsMount *mnt);
 
SceUID vfsAllocateFile(SceVfsVnode *vp, SceVfsFile **file, const char *name);
int vfsFreeFile(SceVfsVnode *vp, SceUID fd);
 
int vfsGetNewVnode(SceVfsMount *mnt, SceVopTable *vops, int unk, SceVfsVnode **vpp);
int vfsFreeVnode(SceVfsVnode *vp);
 
int vfsLockVnode(SceVfsVnode *vp);
int vfsUnlockVnode(SceVfsVnode *vp);
SceBool vfsIsOwnerVnode(SceVfsVnode *vp);
 
int vfsGetVnodeName(SceVfsVnode *vp, char *name, SceSize n, SceSize *result);
int ksceVopOpen(SceVfsVnode *vp, SceVfsPath *path, int flags, SceVfsFile *file);
int ksceVopCreate(SceVfsVnode *dvp, SceVfsVnode **vpp, SceVfsPath *path, int flags, int mode);
int ksceVopClose(SceVfsVnode *vp, SceVfsFile *file);
int ksceVopLookup(SceVfsVnode *dvp, SceVfsVnode **vpp, SceVfsPath *path, SceUInt32 flags);
int ksceVopRead(SceVfsVnode *vp, SceVfsFile *file, void *data, SceSize nbyte, SceSize *result);
int ksceVopWrite(SceVfsVnode *vp, SceVfsFile *file, const void *data, SceSize nbyte, SceSize *result);
SceOff ksceVopLseek(SceVfsVnode *vp, SceVfsFile *file, SceOff offset, int whence);
 
int ksceVopIoctl(SceVfsVnode *vp, SceVfsFile *file, int cmd, const void *in_data, SceSize in_len, void *out_data, SceSize out_len);
int ksceVopRemove(SceVfsVnode *dvp, SceVfsVnode *vp, SceVfsPath *path, SceUInt32 flags); 
int ksceVopMkdir(SceVfsVnode *dvp, SceVfsVnode **vpp, SceVfsPath *path, int mode);
int ksceVopRmdir(SceVfsVnode *dvp, SceVfsVnode *vp, SceVfsPath *path);
 
int ksceVopDopen(SceVfsVnode *vp, SceVfsPath *path, SceVfsFile *file);
int ksceVopDclose(SceVfsVnode *vp, SceVfsFile *file);
int ksceVopDread(SceVfsVnode *vp, SceVfsFile *file, SceIoDirent *dir);
 
int ksceVopGetstat(SceVfsVnode *vp, SceVfsPath *path, SceIoStat *stat);
int ksceVopChstat(SceVfsVnode *vp, SceVfsPath *path, SceIoStat *stat, int bit);
 
int ksceVopRename(SceVfsVnode *odvp, SceVfsVnode *ovp, SceVfsPath *old_path, SceVfsVnode *ndvp, SceVfsVnode **nvpp, SceVfsPath *new_path);
int ksceVopPread(SceVfsVnode *vp, SceVfsFile *file, void *data, SceSize nbyte, SceOff offset, SceSize *pResult);
int ksceVopPwrite(SceVfsVnode *vp, SceVfsFile *file, const void *data, SceSize nbyte, SceOff offset, SceSize *result);
int ksceVopInactive(SceVfsVnode *vp);
int ksceVopSync(SceVfsVnode *vp, SceVfsFile *file, int flags);
int ksceVopFgetstat(SceVfsVnode *vp, SceVfsFile *file, SceIoStat *stat);
int ksceVopFchstat(SceVfsVnode *vp, SceVfsFile *file, SceIoStat *stat, int bit);
 
int ksceVopLink(SceVfsVnode *fvp, SceVfsVnode *tvp);
int ksceVopUnlink(SceVfsVnode *fvp, SceVfsVnode *tvp);
 
int ksceVopWhiteout(SceVfsVnode *dvp, SceVfsVnode *vp, SceVfsPath *old_path, SceVfsPath *new_path);
int ksceVopCleanup(SceVfsVnode *vp, SceVfsFile *file);
int ksceVopZerofill(SceVfsVnode *vp, SceUInt64 unk, SceUInt64 unk1, SceUInt64 unk2);
#ifdef __cplusplus
}
#endif
 
#endif /* _PSP2KERN_VFS_VNODE_H_ */