fileXio_rpc.c File Reference

#include <tamtypes.h>
#include <kernel.h>
#include <sifrpc.h>
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <stdarg.h>
#include <sys/fcntl.h>
#include <sys/stat.h>
#include <ps2sdkapi.h>
#include <fileXio_rpc.h>
#include <errno.h>

Include dependency graph for fileXio_rpc.c:

Go to the source code of this file.

Macros
#define	NEWLIB_PORT_AWARE

Functions
static void	_fxio_intr (void)
static int	_lock (void)
static int	_unlock (void)
static time_t	io_to_posix_time (const unsigned char *ps2time)
static mode_t	iox_to_posix_mode (unsigned int ps2mode)
static void	fill_stat (struct stat *stat, const iox_stat_t *fiostat)
static int	fileXioGetstatHelper (const char *path, struct stat *buf)
static DIR *	fileXioOpendirHelper (const char *path)
static struct dirent *	fileXioReaddirHelper (DIR *dir)
static void	fileXioRewinddirHelper (DIR *dir)
static int	fileXioClosedirHelper (DIR *dir)
int	fileXioInit (void)
void	fileXioExit (void)
void	fileXioStop (void)
int	fileXioGetDeviceList (struct fileXioDevice deviceEntry[], unsigned int req_entries)
int	fileXioGetdir (const char *pathname, struct fileXioDirEntry dirEntry[], unsigned int req_entries)
int	fileXioMount (const char *mountpoint, const char *mountstring, int flag)
int	fileXioUmount (const char *mountpoint)
int	fileXioCopyfile (const char *source, const char *dest, int mode)
int	fileXioMkdir (const char *pathname, int mode)
int	fileXioRmdir (const char *pathname)
int	fileXioRemove (const char *pathname)
int	fileXioRename (const char *source, const char *dest)
int	fileXioSymlink (const char *source, const char *dest)
int	fileXioReadlink (const char *source, char *buf, int buflen)
int	fileXioChdir (const char *pathname)
int	fileXioOpen (const char *source, int flags,...)
int	fileXioClose (int fd)
static void	recv_intr (void *data_raw)
int	fileXioRead (int fd, void *buf, int size)
int	fileXioWrite (int fd, const void *buf, int size)
int	fileXioLseek (int fd, int offset, int whence)
s64	fileXioLseek64 (int fd, s64 offset, int whence)
int	fileXioChStat (const char *name, iox_stat_t *stat, int mask)
int	fileXioGetStat (const char *name, iox_stat_t *stat)
int	fileXioFormat (const char *dev, const char *blockdev, const void *args, int arglen)
int	fileXioSync (const char *devname, int flag)
int	fileXioDopen (const char *name)
int	fileXioDclose (int fd)
int	fileXioDread (int fd, iox_dirent_t *dirent)
static void	fxio_ctl_intr (void *data_raw)
int	fileXioDevctl (const char *name, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen)
int	fileXioIoctl (int fd, int cmd, void *arg)
int	fileXioIoctl2 (int fd, int command, void *arg, unsigned int arglen, void *buf, unsigned int buflen)
int	fileXioWaitAsync (int mode, int *retVal)
void	fileXioSetBlockMode (int blocking)
int	fileXioSetRWBufferSize (int size)

Variables
int	_iop_reboot_count
static SifRpcClientData_t	cd0
static unsigned int	sbuff [0x1300]
static int	_intr_data [0xC00]
static int	fileXioInited = 0
static int	fileXioBlockMode
static int	fileXioCompletionSema = -1
static int	_lock_sema_id = -1

Detailed Description

fileXio RPC client

Definition in file fileXio_rpc.c.

Macro Definition Documentation

NEWLIB_PORT_AWARE

#define NEWLIB_PORT_AWARE

Definition at line 27 of file fileXio_rpc.c.

Function Documentation

_fxio_intr()

static void _fxio_intr ( void  )

static

Definition at line 39 of file fileXio_rpc.c.

{
        iSignalSema(fileXioCompletionSema);
}

References fileXioCompletionSema, and iSignalSema().

Referenced by fileXioChdir(), fileXioChStat(), fileXioClose(), fileXioCopyfile(), fileXioDclose(), fileXioDevctl(), fileXioDopen(), fileXioDread(), fileXioFormat(), fileXioGetDeviceList(), fileXioGetdir(), fileXioGetStat(), fileXioIoctl(), fileXioIoctl2(), fileXioLseek(), fileXioLseek64(), fileXioMkdir(), fileXioMount(), fileXioOpen(), fileXioReadlink(), fileXioRemove(), fileXioRename(), fileXioRmdir(), fileXioSetRWBufferSize(), fileXioSymlink(), fileXioSync(), fileXioUmount(), and fileXioWrite().

_lock()

static int _lock ( void  )

inlinestatic

Definition at line 45 of file fileXio_rpc.c.

{
        return(WaitSema(_lock_sema_id));
}

References _lock_sema_id, and WaitSema().

Referenced by fileXioChdir(), fileXioChStat(), fileXioClose(), fileXioCopyfile(), fileXioDclose(), fileXioDevctl(), fileXioDopen(), fileXioDread(), fileXioFormat(), fileXioGetDeviceList(), fileXioGetdir(), fileXioGetStat(), fileXioIoctl(), fileXioIoctl2(), fileXioLseek(), fileXioLseek64(), fileXioMkdir(), fileXioMount(), fileXioOpen(), fileXioRead(), fileXioReadlink(), fileXioRemove(), fileXioRename(), fileXioRmdir(), fileXioSetRWBufferSize(), fileXioSymlink(), fileXioSync(), fileXioUmount(), and fileXioWrite().

_unlock()

static int _unlock ( void  )

inlinestatic

Definition at line 50 of file fileXio_rpc.c.

{
        return(SignalSema(_lock_sema_id));
}

References _lock_sema_id, and SignalSema().

Referenced by fileXioChdir(), fileXioChStat(), fileXioClose(), fileXioCopyfile(), fileXioDclose(), fileXioDevctl(), fileXioDopen(), fileXioDread(), fileXioFormat(), fileXioGetDeviceList(), fileXioGetdir(), fileXioGetStat(), fileXioIoctl(), fileXioIoctl2(), fileXioLseek(), fileXioLseek64(), fileXioMkdir(), fileXioMount(), fileXioOpen(), fileXioRead(), fileXioReadlink(), fileXioRemove(), fileXioRename(), fileXioRmdir(), fileXioSetRWBufferSize(), fileXioSymlink(), fileXioSync(), fileXioUmount(), and fileXioWrite().

fileXioChdir()

int fileXioChdir

(

const char *

pathname

)

Definition at line 556 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_pathsel_packet *packet=(struct fxio_pathsel_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->pathname, pathname, sizeof(packet->pathname));
 
        if((rv = SifCallRpc(&cd0, FILEXIO_CHDIR, fileXioBlockMode, sbuff, sizeof(struct fxio_pathsel_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, FILEXIO_CHDIR, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, packet, fxio_pathsel_packet::pathname, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

fileXioChStat()

int fileXioChStat	(	const char *	name,
		iox_stat_t *	stat,
		int	mask
	)

Definition at line 784 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_chstat_packet *packet=(struct fxio_chstat_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->pathname, name, sizeof(packet->pathname));
        packet->stat = stat;
        packet->mask = mask;
 
        if(!IS_UNCACHED_SEG(stat))
                SifWriteBackDCache(stat, sizeof(iox_stat_t));
 
        if((rv = SifCallRpc(&cd0, FILEXIO_CHSTAT, fileXioBlockMode, sbuff, sizeof(struct fxio_chstat_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, FILEXIO_CHSTAT, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, IS_UNCACHED_SEG, fxio_chstat_packet::mask, NULL, packet, sbuff, SifCallRpc(), SifWriteBackDCache(), SignalSema(), fxio_chstat_packet::stat, and WaitSema().

fileXioClose()

int fileXioClose

(

int

fd

)

Definition at line 612 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_close_packet *packet=(struct fxio_close_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        packet->fd = fd;
 
        if((rv = SifCallRpc(&cd0, FILEXIO_CLOSE, fileXioBlockMode, sbuff, sizeof(struct fxio_close_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, fxio_close_packet::fd, FILEXIO_CLOSE, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, packet, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by fileXioInit(), hddExpandFilesystem(), hddGetFilesystemList(), and hddMakeFilesystem().

fileXioClosedirHelper()

static int fileXioClosedirHelper ( DIR *  dir )

static

Definition at line 163 of file fileXio_rpc.c.

{
        if(dir == NULL) {
                // FIXME: set errno
                return -1;
        }
 
        fileXioDclose(dir->dd_fd); // Check return value?
        free(dir->dd_buf);
        free(dir);
        return 0;
}

References fileXioDclose(), and NULL.

Referenced by fileXioInit().

fileXioCopyfile()

int fileXioCopyfile	(	const char *	source,
		const char *	dest,
		int	mode
	)

Definition at line 371 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_copyfile_packet *packet=(struct fxio_copyfile_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->source, source, sizeof(packet->source));
        strncpy(packet->dest, dest, sizeof(packet->dest));
        packet->mode = mode;
 
        if((rv = SifCallRpc(&cd0, FILEXIO_COPYFILE, fileXioBlockMode, sbuff, sizeof(struct fxio_copyfile_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, fxio_copyfile_packet::dest, ENOPKG, FILEXIO_COPYFILE, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, mode, NULL, packet, sbuff, SifCallRpc(), SignalSema(), fxio_copyfile_packet::source, and WaitSema().

fileXioDclose()

int fileXioDclose

(

int

fd

)

Definition at line 924 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_close_packet *packet=(struct fxio_close_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        packet->fd = fd;
        if((rv = SifCallRpc(&cd0, FILEXIO_DCLOSE, fileXioBlockMode, sbuff, sizeof(struct fxio_close_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, fxio_close_packet::fd, FILEXIO_DCLOSE, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, packet, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by fileXioClosedirHelper(), hddGetFilesystemList(), and hddUpdateInfo().

fileXioDevctl()

int fileXioDevctl	(	const char *	name,
		int	cmd,
		void *	arg,
		unsigned int	arglen,
		void *	buf,
		unsigned int	buflen
	)

Definition at line 986 of file fileXio_rpc.c.

{
        struct fxio_devctl_packet *packet = (struct fxio_devctl_packet *)sbuff;
        int rv;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        if(arglen > CTL_BUF_SIZE) arglen = CTL_BUF_SIZE;
        if(buflen > CTL_BUF_SIZE) buflen = CTL_BUF_SIZE;
        strncpy(packet->name, name, CTL_BUF_SIZE);
        packet->name[CTL_BUF_SIZE-1] = '\0';
        memcpy(packet->arg, arg, arglen);
 
        packet->cmd = cmd;
        packet->arglen = arglen;
        packet->buf = buf;
        packet->buflen = buflen;
        packet->intr_data = _intr_data;
 
        SifWriteBackDCache(buf, buflen);
 
        if(buflen)
                rv = SifCallRpc(&cd0, FILEXIO_DEVCTL, fileXioBlockMode, packet, sizeof(struct fxio_devctl_packet), sbuff, 4, &fxio_ctl_intr, _intr_data);
        else
                rv = SifCallRpc(&cd0, FILEXIO_DEVCTL, fileXioBlockMode, packet, sizeof(struct fxio_devctl_packet), sbuff, 4, (void *)&_fxio_intr, NULL);
 
        if(rv >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _intr_data, _lock(), _unlock(), fxio_devctl_packet::arg, fxio_devctl_packet::arglen, fxio_devctl_packet::buf, fxio_devctl_packet::buflen, cd0, fxio_devctl_packet::cmd, CTL_BUF_SIZE, ENOPKG, FILEXIO_DEVCTL, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), fxio_ctl_intr(), FXIO_NOWAIT, fxio_devctl_packet::name, NULL, packet, sbuff, SifCallRpc(), SifWriteBackDCache(), SignalSema(), and WaitSema().

Referenced by hddCheckFormatted(), hddCheckPresent(), hddGetFilesystemList(), and hddUpdateInfo().

fileXioDopen()

int fileXioDopen

(

const char *

name

)

Definition at line 900 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_pathsel_packet *packet=(struct fxio_pathsel_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->pathname, name, sizeof(packet->pathname));
        if((rv = SifCallRpc(&cd0, FILEXIO_DOPEN, fileXioBlockMode, sbuff, sizeof(struct fxio_pathsel_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, FILEXIO_DOPEN, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, packet, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by fileXioOpendirHelper(), hddGetFilesystemList(), and hddUpdateInfo().

fileXioDread()

int fileXioDread	(	int	fd,
		iox_dirent_t *	dirent
	)

Definition at line 948 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_dread_packet *packet=(struct fxio_dread_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        packet->fd = fd;
        packet->dirent = dirent;
 
        if (!IS_UNCACHED_SEG(dirent))
                SifWriteBackDCache(dirent, sizeof(iox_dirent_t));
 
        if((rv = SifCallRpc(&cd0, FILEXIO_DREAD, fileXioBlockMode, sbuff, sizeof(struct fxio_dread_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, fxio_dread_packet::dirent, ENOPKG, fxio_dread_packet::fd, FILEXIO_DREAD, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, IS_UNCACHED_SEG, NULL, packet, sbuff, SifCallRpc(), SifWriteBackDCache(), SignalSema(), and WaitSema().

Referenced by fileXioReaddirHelper(), hddGetFilesystemList(), and hddUpdateInfo().

fileXioExit()

void fileXioExit

(

void

)

Definition at line 237 of file fileXio_rpc.c.

{
        if(fileXioInited)
        {
                if(_lock_sema_id >= 0) DeleteSema(_lock_sema_id);
                if(fileXioCompletionSema >= 0) DeleteSema(fileXioCompletionSema);
 
                memset(&cd0, 0, sizeof(cd0));
 
                fileXioInited = 0;
        }
}

References _lock_sema_id, cd0, DeleteSema(), fileXioCompletionSema, and fileXioInited.

Referenced by fileXioInit().

fileXioFormat()

int fileXioFormat	(	const char *	dev,
		const char *	blockdev,
		const void *	args,
		int	arglen
	)

Definition at line 843 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_format_packet *packet=(struct fxio_format_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->device, dev, sizeof(packet->device));
        if(blockdev)
                strncpy(packet->blockDevice, blockdev, sizeof(packet->blockDevice));
 
        if(arglen > sizeof(packet->args)) arglen = sizeof(packet->args);
        memcpy(packet->args, args, arglen);
        packet->arglen = arglen;
 
        if((rv = SifCallRpc(&cd0, FILEXIO_FORMAT, fileXioBlockMode,  sbuff, sizeof(struct fxio_format_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), fxio_format_packet::arglen, fxio_format_packet::args, cd0, ENOPKG, FILEXIO_FORMAT, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, packet, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by hddFormat(), and hddMakeFilesystem().

fileXioGetDeviceList()

int fileXioGetDeviceList	(	struct fileXioDevice	deviceEntry[],
		unsigned int	req_entries
	)

Definition at line 260 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_devlist_packet *packet=(struct fxio_devlist_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        packet->deviceEntry = deviceEntry;
        packet->reqEntries = req_entries;
 
        // This will get the directory contents, and fill dirEntry via DMA
        if((rv = SifCallRpc(&cd0, FILEXIO_GETDEVICELIST, fileXioBlockMode, sbuff, sizeof(struct fxio_devlist_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, fxio_devlist_packet::deviceEntry, ENOPKG, FILEXIO_GETDEVICELIST, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, packet, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

fileXioGetdir()

int fileXioGetdir	(	const char *	pathname,
		struct fileXioDirEntry	dirEntry[],
		unsigned int	req_entries
	)

Definition at line 287 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_getdir_packet *packet=(struct fxio_getdir_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        // copy the requested pathname to the rpc buffer
        strncpy(packet->pathname, pathname, sizeof(packet->pathname));
 
        SifWriteBackDCache(dirEntry, (sizeof(struct fileXioDirEntry) * req_entries));
 
        packet->dirEntry = dirEntry;
        packet->reqEntries = req_entries;
 
        // This will get the directory contents, and fill dirEntry via DMA
        if((rv = SifCallRpc(&cd0, FILEXIO_GETDIR, fileXioBlockMode, sbuff, sizeof(struct fxio_getdir_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, fxio_getdir_packet::dirEntry, ENOPKG, FILEXIO_GETDIR, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, packet, fxio_getdir_packet::pathname, sbuff, SifCallRpc(), SifWriteBackDCache(), SignalSema(), and WaitSema().

fileXioGetStat()

int fileXioGetStat	(	const char *	name,
		iox_stat_t *	stat
	)

Definition at line 814 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_getstat_packet *packet=(struct fxio_getstat_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->pathname, name, sizeof(packet->pathname));
        packet->stat = stat;
 
        if(!IS_UNCACHED_SEG(stat))
                SifWriteBackDCache(stat, sizeof(iox_stat_t));
 
        if((rv = SifCallRpc(&cd0, FILEXIO_GETSTAT, fileXioBlockMode, sbuff, sizeof(struct fxio_getstat_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, FILEXIO_GETSTAT, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, IS_UNCACHED_SEG, NULL, packet, sbuff, SifCallRpc(), SifWriteBackDCache(), SignalSema(), fxio_getstat_packet::stat, and WaitSema().

Referenced by fileXioGetstatHelper().

fileXioGetstatHelper()

static int fileXioGetstatHelper ( const char *  path, struct stat *  buf  )

static

Definition at line 101 of file fileXio_rpc.c.

                                                                    {
        iox_stat_t fiostat;
 
        if (fileXioGetStat(path, &fiostat) < 0) {
                // FIXME: set errno
                return -1;
        }
 
        fill_stat(buf, &fiostat);
 
        return 0;
}

References fileXioGetStat(), and fill_stat().

Referenced by fileXioInit().

fileXioInit()

int fileXioInit

(

void

)

Definition at line 176 of file fileXio_rpc.c.

{
        int res;
        ee_sema_t sp;
        static int _rb_count = 0;
 
        if(_rb_count != _iop_reboot_count)
        {
                _rb_count = _iop_reboot_count;
 
                fileXioExit();
        }
 
        if(fileXioInited)
        {
                return 0;
        }
 
        sp.init_count = 1;
        sp.max_count = 1;
        sp.option = 0;
        _lock_sema_id = CreateSema(&sp);
 
        while(((res = SifBindRpc(&cd0, FILEXIO_IRX, 0)) >= 0) && (cd0.server == NULL))
                nopdelay();
 
        if(res < 0)
                return res;
 
        sp.init_count = 1;
        sp.max_count = 1;
        sp.option = 0;
        fileXioCompletionSema = CreateSema(&sp);
        if (fileXioCompletionSema < 0)
                return -1;
 
        fileXioInited = 1;
        fileXioBlockMode = FXIO_WAIT;
 
        _ps2sdk_close = fileXioClose;
        _ps2sdk_open = fileXioOpen;
        _ps2sdk_read = fileXioRead;
        _ps2sdk_lseek = fileXioLseek;
        _ps2sdk_lseek64 = fileXioLseek64;
        _ps2sdk_write = fileXioWrite;
        _ps2sdk_ioctl = fileXioIoctl;
        _ps2sdk_remove= fileXioRemove;
        _ps2sdk_rename= fileXioRename;
        _ps2sdk_mkdir = fileXioMkdir;
        _ps2sdk_rmdir = fileXioRmdir;
 
        _ps2sdk_stat = fileXioGetstatHelper;
 
        _ps2sdk_opendir = fileXioOpendirHelper;
        _ps2sdk_readdir = fileXioReaddirHelper;
        _ps2sdk_rewinddir = fileXioRewinddirHelper;
        _ps2sdk_closedir = fileXioClosedirHelper;
 
        return 0;
}

References _iop_reboot_count, _lock_sema_id, _ps2sdk_close, _ps2sdk_closedir, _ps2sdk_ioctl, _ps2sdk_lseek, _ps2sdk_lseek64, _ps2sdk_mkdir, _ps2sdk_open, _ps2sdk_opendir, _ps2sdk_read, _ps2sdk_readdir, _ps2sdk_remove, _ps2sdk_rename, _ps2sdk_rewinddir, _ps2sdk_rmdir, _ps2sdk_stat, _ps2sdk_write, cd0, CreateSema(), FILEXIO_IRX, fileXioBlockMode, fileXioClose(), fileXioClosedirHelper(), fileXioCompletionSema, fileXioExit(), fileXioGetstatHelper(), fileXioInited, fileXioIoctl(), fileXioLseek(), fileXioLseek64(), fileXioMkdir(), fileXioOpen(), fileXioOpendirHelper(), fileXioRead(), fileXioReaddirHelper(), fileXioRemove(), fileXioRename(), fileXioRewinddirHelper(), fileXioRmdir(), fileXioWrite(), FXIO_WAIT, nopdelay(), NULL, SifRpcClientData_t::server, SifBindRpc(), and sp.

Referenced by fileXioChdir(), fileXioChStat(), fileXioClose(), fileXioCopyfile(), fileXioDclose(), fileXioDevctl(), fileXioDopen(), fileXioDread(), fileXioFormat(), fileXioGetDeviceList(), fileXioGetdir(), fileXioGetStat(), fileXioIoctl(), fileXioIoctl2(), fileXioLseek(), fileXioLseek64(), fileXioMkdir(), fileXioMount(), fileXioOpen(), fileXioRead(), fileXioReadlink(), fileXioRemove(), fileXioRename(), fileXioRmdir(), fileXioSetRWBufferSize(), fileXioStop(), fileXioSymlink(), fileXioSync(), fileXioUmount(), fileXioWaitAsync(), and fileXioWrite().

fileXioIoctl()

int fileXioIoctl	(	int	fd,
		int	cmd,
		void *	arg
	)

Definition at line 1028 of file fileXio_rpc.c.

                                            {
        struct fxio_ioctl_packet *packet = (struct fxio_ioctl_packet *)sbuff;
        int rv;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        memcpy(packet->arg, arg, IOCTL_BUF_SIZE);
 
        packet->fd = fd;
        packet->cmd = cmd;
 
        if((rv = SifCallRpc(&cd0, FILEXIO_IOCTL, fileXioBlockMode, packet, sizeof(struct fxio_ioctl_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), fxio_ioctl_packet::arg, cd0, fxio_ioctl_packet::cmd, ENOPKG, fxio_ioctl_packet::fd, FILEXIO_IOCTL, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, IOCTL_BUF_SIZE, NULL, packet, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by fileXioInit().

fileXioIoctl2()

int fileXioIoctl2	(	int	fd,
		int	command,
		void *	arg,
		unsigned int	arglen,
		void *	buf,
		unsigned int	buflen
	)

Definition at line 1055 of file fileXio_rpc.c.

{
        struct fxio_ioctl2_packet *packet = (struct fxio_ioctl2_packet *)sbuff;
        int rv;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        if(arglen > CTL_BUF_SIZE) arglen = CTL_BUF_SIZE;
        if(buflen > CTL_BUF_SIZE) buflen = CTL_BUF_SIZE;
        memcpy(packet->arg, arg, arglen);
 
        packet->fd = fd;
        packet->cmd = command;
        packet->arglen = arglen;
        packet->buf = buf;
        packet->buflen = buflen;
        packet->intr_data = _intr_data;
 
        SifWriteBackDCache(buf, buflen);
 
        if(buflen)
                rv = SifCallRpc(&cd0, FILEXIO_IOCTL2, fileXioBlockMode, packet, sizeof(struct fxio_ioctl2_packet), sbuff, 4, &fxio_ctl_intr, _intr_data);
        else
                rv = SifCallRpc(&cd0, FILEXIO_IOCTL2, fileXioBlockMode, packet, sizeof(struct fxio_ioctl2_packet), sbuff, 4, (void *)&_fxio_intr, NULL);
 
        if(rv >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _intr_data, _lock(), _unlock(), fxio_ioctl2_packet::arg, fxio_ioctl2_packet::arglen, fxio_ioctl2_packet::buf, fxio_ioctl2_packet::buflen, cd0, command, CTL_BUF_SIZE, ENOPKG, fxio_ioctl2_packet::fd, FILEXIO_IOCTL2, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), fxio_ctl_intr(), FXIO_NOWAIT, NULL, packet, sbuff, SifCallRpc(), SifWriteBackDCache(), SignalSema(), and WaitSema().

Referenced by hddExpandFilesystem(), hddGetFilesystemList(), and hddMakeFilesystem().

fileXioLseek()

int fileXioLseek	(	int	fd,
		int	offset,
		int	whence
	)

Definition at line 720 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_lseek_packet *packet=(struct fxio_lseek_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        packet->fd = fd;
        packet->offset = (u32)offset;
        packet->whence = whence;
 
        if((rv = SifCallRpc(&cd0, FILEXIO_LSEEK, fileXioBlockMode, sbuff, sizeof(struct fxio_lseek_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, fxio_lseek_packet::fd, FILEXIO_LSEEK, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, fxio_lseek_packet::offset, packet, sbuff, SifCallRpc(), SignalSema(), WaitSema(), and fxio_lseek_packet::whence.

Referenced by fileXioInit().

fileXioLseek64()

s64 fileXioLseek64	(	int	fd,
		s64	offset,
		int	whence
	)

Definition at line 750 of file fileXio_rpc.c.

{
        s64 rv;
        struct fxio_lseek64_packet *packet=(struct fxio_lseek64_packet*)sbuff;
        struct fxio_lseek64_return_pkt *ret_packet=(struct fxio_lseek64_return_pkt*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        packet->fd = fd;
        packet->offset_lo = (u32)(offset & 0xffffffff);
        packet->offset_hi = (u32)((offset >> 32) & 0xffffffff);
        packet->whence = whence;
 
        if((rv = SifCallRpc(&cd0, FILEXIO_LSEEK64, fileXioBlockMode, sbuff, sizeof(struct fxio_lseek64_packet), sbuff, 8, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else {
                        s64 rvHI = ret_packet->pos_hi;
                        rvHI = rvHI << 32;
                        rv = rvHI | ret_packet->pos_lo;
                }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
 
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, FILEXIO_LSEEK64, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, packet, fxio_lseek64_return_pkt::pos_hi, fxio_lseek64_return_pkt::pos_lo, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by fileXioInit().

fileXioMkdir()

int fileXioMkdir	(	const char *	pathname,
		int	mode
	)

Definition at line 398 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_mkdir_packet *packet=(struct fxio_mkdir_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->pathname, pathname, sizeof(packet->pathname));
        packet->mode = mode;
 
        if((rv = SifCallRpc(&cd0, FILEXIO_MKDIR, fileXioBlockMode, sbuff, sizeof(struct fxio_mkdir_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, FILEXIO_MKDIR, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, mode, NULL, packet, fxio_mkdir_packet::pathname, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by fileXioInit().

fileXioMount()

int fileXioMount	(	const char *	mountpoint,
		const char *	mountstring,
		int	flag
	)

Definition at line 319 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_mount_packet *packet=(struct fxio_mount_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->blockdevice, mountstring, sizeof(packet->blockdevice));
        strncpy(packet->mountpoint, mountpoint, sizeof(packet->mountpoint));
        packet->flags = flag;
 
        if((rv = SifCallRpc(&cd0, FILEXIO_MOUNT, fileXioBlockMode, sbuff, sizeof(struct fxio_mount_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, FILEXIO_MOUNT, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, fxio_mount_packet::mountpoint, NULL, packet, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by hddGetFilesystemList().

fileXioOpen()

int fileXioOpen	(	const char *	source,
		int	flags,
			...
	)

Definition at line 581 of file fileXio_rpc.c.

{
        int rv, mode;
        struct fxio_open_packet *packet=(struct fxio_open_packet*)sbuff;
        va_list alist;
 
        va_start(alist, flags);
        mode = va_arg(alist, int);      //Retrieve the mode argument, regardless of whether it is expected or not.
        va_end(alist);
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->pathname, source, sizeof(packet->pathname));
        packet->flags = flags;
        packet->mode = mode;
        if((rv = SifCallRpc(&cd0, FILEXIO_OPEN, fileXioBlockMode, sbuff, sizeof(struct fxio_open_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, FILEXIO_OPEN, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), fxio_open_packet::flags, FXIO_NOWAIT, mode, NULL, packet, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by fileXioInit(), hddExpandFilesystem(), hddGetFilesystemList(), and hddMakeFilesystem().

fileXioOpendirHelper()

static DIR* fileXioOpendirHelper ( const char *  path )

static

Definition at line 114 of file fileXio_rpc.c.

{
        int dd;
        DIR *dir;
 
        dd = fileXioDopen(path);
        if (dd < 0) {
                // FIXME: set errno
                //printf("%s: ERROR: fileXioDopen\n", __FUNCTION__);
                return NULL;
        }
 
        dir = malloc(sizeof(DIR));
        dir->dd_fd = dd;
        dir->dd_buf = malloc(sizeof(struct dirent));
 
        return dir;
}

References fileXioDopen(), and NULL.

Referenced by fileXioInit().

fileXioRead()

int fileXioRead	(	int	fd,
		void *	buf,
		int	size
	)

Definition at line 647 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_read_packet *packet=(struct fxio_read_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        packet->fd = fd;
        packet->buffer = buf;
        packet->size = size;
        packet->intrData = _intr_data;
 
        if (!IS_UNCACHED_SEG(buf))
                SifWriteBackDCache(buf, size);
 
        if((rv = SifCallRpc(&cd0, FILEXIO_READ, fileXioBlockMode, sbuff, sizeof(struct fxio_read_packet), sbuff, 4, &recv_intr, _intr_data)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _intr_data, _lock(), _unlock(), cd0, ENOPKG, fxio_read_packet::fd, FILEXIO_READ, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, IS_UNCACHED_SEG, packet, recv_intr(), sbuff, SifCallRpc(), SifWriteBackDCache(), SignalSema(), fxio_read_packet::size, and WaitSema().

Referenced by fileXioInit().

fileXioReaddirHelper()

static struct dirent* fileXioReaddirHelper ( DIR *  dir )

static

Definition at line 133 of file fileXio_rpc.c.

{
        int rv;
        struct dirent *de;
        iox_dirent_t fiode;
 
        if(dir == NULL) {
                // FIXME: set errno
                return NULL;
        }
 
        de = (struct dirent *)dir->dd_buf;
        rv = fileXioDread(dir->dd_fd, &fiode);
        if (rv <= 0) {
                // FIXME: set errno
                return NULL;
        }
 
        fill_stat(&de->d_stat, &fiode.stat);
        strncpy(de->d_name, fiode.name, 255);
        de->d_name[255] = 0;
 
        return de;
}

References fileXioDread(), fill_stat(), iox_dirent_t::name, NULL, and iox_dirent_t::stat.

Referenced by fileXioInit().

fileXioReadlink()

int fileXioReadlink	(	const char *	source,
		char *	buf,
		int	buflen
	)

Definition at line 526 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_readlink_packet *packet=(struct fxio_readlink_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        if( !IS_UNCACHED_SEG(buf))
          SifWriteBackDCache(buf, buflen);
 
        strncpy(packet->source, source, sizeof(packet->source));
        packet->buffer = buf;
        packet->buflen = buflen;
 
        if((rv = SifCallRpc(&cd0, FILEXIO_READLINK, fileXioBlockMode, sbuff, sizeof(struct fxio_readlink_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), fxio_readlink_packet::buflen, cd0, ENOPKG, FILEXIO_READLINK, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, IS_UNCACHED_SEG, NULL, packet, sbuff, SifCallRpc(), SifWriteBackDCache(), SignalSema(), fxio_readlink_packet::source, and WaitSema().

fileXioRemove()

int fileXioRemove

(

const char *

pathname

)

Definition at line 449 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_pathsel_packet *packet=(struct fxio_pathsel_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->pathname, pathname, sizeof(packet->pathname));
 
        if((rv = SifCallRpc(&cd0, FILEXIO_REMOVE, fileXioBlockMode, sbuff, sizeof(struct fxio_pathsel_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, FILEXIO_REMOVE, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, packet, fxio_pathsel_packet::pathname, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by fileXioInit(), and hddRemoveFilesystem().

fileXioRename()

int fileXioRename	(	const char *	source,
		const char *	dest
	)

Definition at line 474 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_rename_packet *packet=(struct fxio_rename_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->source, source, sizeof(packet->source));
        strncpy(packet->dest, dest, sizeof(packet->dest));
 
        if((rv = SifCallRpc(&cd0, FILEXIO_RENAME, fileXioBlockMode, sbuff, sizeof(struct fxio_rename_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, fxio_rename_packet::dest, ENOPKG, FILEXIO_RENAME, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, packet, sbuff, SifCallRpc(), SignalSema(), fxio_rename_packet::source, and WaitSema().

Referenced by fileXioInit().

fileXioRewinddirHelper()

static void fileXioRewinddirHelper ( DIR *  dir )

static

Definition at line 158 of file fileXio_rpc.c.

{
        printf("rewinddir not implemented\n");
}

Referenced by fileXioInit().

fileXioRmdir()

int fileXioRmdir

(

const char *

pathname

)

Definition at line 424 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_pathsel_packet *packet=(struct fxio_pathsel_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->pathname, pathname, sizeof(packet->pathname));
 
        if((rv = SifCallRpc(&cd0, FILEXIO_RMDIR, fileXioBlockMode, sbuff, sizeof(struct fxio_pathsel_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, FILEXIO_RMDIR, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, packet, fxio_pathsel_packet::pathname, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by fileXioInit().

fileXioSetBlockMode()

void fileXioSetBlockMode

(

int

blocking

)

Definition at line 1132 of file fileXio_rpc.c.

{
        fileXioBlockMode = blocking;
}

References fileXioBlockMode.

fileXioSetRWBufferSize()

int fileXioSetRWBufferSize

(

int

size

)

Definition at line 1137 of file fileXio_rpc.c.

                                    {
        struct fxio_rwbuff *packet = (struct fxio_rwbuff *)sbuff;
        int rv;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        packet->size = size;
 
        if((rv = SifCallRpc(&cd0, FILEXIO_SETRWBUFFSIZE, 0, packet, sizeof(struct fxio_rwbuff), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                rv = sbuff[0];
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, FILEXIO_SETRWBUFFSIZE, fileXioCompletionSema, fileXioInit(), NULL, packet, sbuff, SifCallRpc(), SignalSema(), fxio_rwbuff::size, and WaitSema().

fileXioStop()

void fileXioStop

(

void

)

Definition at line 250 of file fileXio_rpc.c.

{
        if(fileXioInit() < 0)
                return;
 
        SifCallRpc(&cd0, FILEXIO_STOP, 0, sbuff, 0, sbuff, 0, 0, 0);
 
        return;
}

References cd0, FILEXIO_STOP, fileXioInit(), sbuff, and SifCallRpc().

fileXioSymlink()

int fileXioSymlink	(	const char *	source,
		const char *	dest
	)

Definition at line 500 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_rename_packet *packet=(struct fxio_rename_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->source, source, sizeof(packet->source));
        strncpy(packet->dest, dest, sizeof(packet->dest));
 
        if((rv = SifCallRpc(&cd0, FILEXIO_SYMLINK, fileXioBlockMode, sbuff, sizeof(struct fxio_rename_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, fxio_rename_packet::dest, ENOPKG, FILEXIO_SYMLINK, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, packet, sbuff, SifCallRpc(), SignalSema(), fxio_rename_packet::source, and WaitSema().

fileXioSync()

int fileXioSync	(	const char *	devname,
		int	flag
	)

Definition at line 874 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_sync_packet *packet=(struct fxio_sync_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->device, devname, sizeof(packet->device));
        packet->flags = flag;
 
        if((rv = SifCallRpc(&cd0, FILEXIO_SYNC, fileXioBlockMode, sbuff, sizeof(struct fxio_sync_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, FILEXIO_SYNC, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, NULL, packet, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

fileXioUmount()

int fileXioUmount

(

const char *

mountpoint

)

Definition at line 346 of file fileXio_rpc.c.

{
        int rv;
        struct fxio_unmount_packet *packet=(struct fxio_unmount_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        strncpy(packet->mountpoint, mountpoint, sizeof(packet->mountpoint));
 
        if((rv = SifCallRpc(&cd0, FILEXIO_UMOUNT, fileXioBlockMode, sbuff, sizeof(struct fxio_unmount_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, FILEXIO_UMOUNT, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, fxio_unmount_packet::mountpoint, NULL, packet, sbuff, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by hddGetFilesystemList().

fileXioWaitAsync()

int fileXioWaitAsync	(	int	mode,
		int *	retVal
	)

Definition at line 1096 of file fileXio_rpc.c.

{
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        if(fileXioBlockMode != FXIO_NOWAIT) return 0;
 
        switch(mode)
        {
                case FXIO_WAIT:
 
                        WaitSema(fileXioCompletionSema);
                        SignalSema(fileXioCompletionSema);
 
                        if(retVal != NULL)
                                *retVal = *(int *)UNCACHED_SEG(&sbuff[0]);
 
                        return FXIO_COMPLETE;
 
                case FXIO_NOWAIT:
 
                        if(PollSema(fileXioCompletionSema) < 0)
                                return FXIO_INCOMPLETE;
 
                        SignalSema(fileXioCompletionSema);
 
                        if(retVal != NULL)
                                *retVal = *(int *)UNCACHED_SEG(&sbuff[0]);
 
                        return FXIO_COMPLETE;
 
                default:
                        return -1;
        }
}

References ENOPKG, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_COMPLETE, FXIO_INCOMPLETE, FXIO_NOWAIT, FXIO_WAIT, mode, NULL, PollSema(), sbuff, SignalSema(), UNCACHED_SEG, and WaitSema().

fileXioWrite()

int fileXioWrite	(	int	fd,
		const void *	buf,
		int	size
	)

Definition at line 678 of file fileXio_rpc.c.

{
        unsigned int miss;
        int rv;
        struct fxio_write_packet *packet=(struct fxio_write_packet*)sbuff;
 
        if(fileXioInit() < 0)
                return -ENOPKG;
 
        _lock();
        WaitSema(fileXioCompletionSema);
 
        if((unsigned int)buf & 0x3F)
        {
                miss = 64 - ((unsigned int)buf & 0x3F);
                if(miss > size) miss = size;
        } else {
                miss = 0;
        }
 
        packet->fd = fd;
        packet->buffer = buf;
        packet->size = size;
        packet->unalignedDataLen = miss;
 
        memcpy(packet->unalignedData, buf, miss);
 
        if(!IS_UNCACHED_SEG(buf))
                SifWriteBackDCache((void*)buf, size);
 
        if((rv = SifCallRpc(&cd0, FILEXIO_WRITE, fileXioBlockMode, sbuff, sizeof(struct fxio_write_packet), sbuff, 4, (void *)&_fxio_intr, NULL)) >= 0)
        {
                if(fileXioBlockMode == FXIO_NOWAIT) { rv = 0; }
                else { rv = sbuff[0]; }
        }
        else
                SignalSema(fileXioCompletionSema);
 
        _unlock();
        return(rv);
}

References _fxio_intr(), _lock(), _unlock(), cd0, ENOPKG, fxio_write_packet::fd, FILEXIO_WRITE, fileXioBlockMode, fileXioCompletionSema, fileXioInit(), FXIO_NOWAIT, IS_UNCACHED_SEG, NULL, packet, sbuff, SifCallRpc(), SifWriteBackDCache(), SignalSema(), fxio_write_packet::size, and WaitSema().

Referenced by fileXioInit().

fill_stat()

static void fill_stat ( struct stat *  stat, const iox_stat_t *  fiostat  )

static

Definition at line 84 of file fileXio_rpc.c.

{
        stat->st_dev = 0;
        stat->st_ino = 0;
        stat->st_mode = iox_to_posix_mode(fiostat->mode);
        stat->st_nlink = 0;
        stat->st_uid = 0;
        stat->st_gid = 0;
        stat->st_rdev = 0;
        stat->st_size = ((off_t)fiostat->hisize << 32) | (off_t)fiostat->size;
        stat->st_atime = io_to_posix_time(fiostat->atime);
        stat->st_mtime = io_to_posix_time(fiostat->mtime);
        stat->st_ctime = io_to_posix_time(fiostat->ctime);
        stat->st_blksize = 16*1024;
        stat->st_blocks = stat->st_size / 512;
}

References iox_stat_t::atime, iox_stat_t::ctime, iox_stat_t::hisize, io_to_posix_time(), iox_to_posix_mode(), iox_stat_t::mode, iox_stat_t::mtime, and iox_stat_t::size.

Referenced by fileXioGetstatHelper(), and fileXioReaddirHelper().

fxio_ctl_intr()

static void fxio_ctl_intr ( void *  data_raw )

static

Definition at line 977 of file fileXio_rpc.c.

{
        struct fxio_ctl_return_pkt *pkt = UNCACHED_SEG(data_raw);
 
        memcpy(pkt->dest, pkt->buf, pkt->len);
 
        iSignalSema(fileXioCompletionSema);
}

References fxio_ctl_return_pkt::buf, fxio_ctl_return_pkt::dest, fileXioCompletionSema, iSignalSema(), fxio_ctl_return_pkt::len, and UNCACHED_SEG.

Referenced by fileXioDevctl(), and fileXioIoctl2().

io_to_posix_time()

static time_t io_to_posix_time ( const unsigned char *  ps2time )

static

Definition at line 55 of file fileXio_rpc.c.

{
        struct tm tim;
        tim.tm_sec  = ps2time[1];
        tim.tm_min  = ps2time[2];
        tim.tm_hour = ps2time[3];
        tim.tm_mday = ps2time[4];
        tim.tm_mon  = ps2time[5] - 1;
        tim.tm_year = ((u16)ps2time[6] | ((u16)ps2time[7] << 8)) - 1900;
        return mktime(&tim);
}

Referenced by fill_stat().

iox_to_posix_mode()

static mode_t iox_to_posix_mode ( unsigned int  ps2mode )

static

Definition at line 67 of file fileXio_rpc.c.

{
        mode_t posixmode = 0;
        if (ps2mode & FIO_S_IFREG) posixmode |= S_IFREG;
        if (ps2mode & FIO_S_IFDIR) posixmode |= S_IFDIR;
        if (ps2mode & FIO_S_IRUSR) posixmode |= S_IRUSR;
        if (ps2mode & FIO_S_IWUSR) posixmode |= S_IWUSR;
        if (ps2mode & FIO_S_IXUSR) posixmode |= S_IXUSR;
        if (ps2mode & FIO_S_IRGRP) posixmode |= S_IRGRP;
        if (ps2mode & FIO_S_IWGRP) posixmode |= S_IWGRP;
        if (ps2mode & FIO_S_IXGRP) posixmode |= S_IXGRP;
        if (ps2mode & FIO_S_IROTH) posixmode |= S_IROTH;
        if (ps2mode & FIO_S_IWOTH) posixmode |= S_IWOTH;
        if (ps2mode & FIO_S_IXOTH) posixmode |= S_IXOTH;
        return posixmode;
}

References FIO_S_IFDIR, FIO_S_IFREG, FIO_S_IRGRP, FIO_S_IROTH, FIO_S_IRUSR, FIO_S_IWGRP, FIO_S_IWOTH, FIO_S_IWUSR, FIO_S_IXGRP, FIO_S_IXOTH, and FIO_S_IXUSR.

Referenced by fill_stat().

recv_intr()

static void recv_intr ( void *  data_raw )

static

Definition at line 637 of file fileXio_rpc.c.

{
        rests_pkt *rests = UNCACHED_SEG(data_raw);
 
        if(rests->ssize) memcpy(rests->sbuf, rests->sbuffer, rests->ssize);
        if(rests->esize) memcpy(rests->ebuf, rests->ebuffer, rests->esize);
 
        iSignalSema(fileXioCompletionSema);
}

References rests_pkt::ebuf, rests_pkt::ebuffer, rests_pkt::esize, fileXioCompletionSema, iSignalSema(), rests_pkt::sbuf, rests_pkt::sbuffer, rests_pkt::ssize, and UNCACHED_SEG.

Referenced by fileXioRead().

Variable Documentation

_intr_data

int _intr_data[0xC00]

static

Definition at line 34 of file fileXio_rpc.c.

Referenced by fileXioDevctl(), fileXioIoctl2(), and fileXioRead().

_iop_reboot_count

int _iop_reboot_count

extern

Referenced by fileXioInit().

_lock_sema_id

int _lock_sema_id = -1

static

Definition at line 44 of file fileXio_rpc.c.

Referenced by _lock(), _unlock(), fileXioExit(), and fileXioInit().

cd0

SifRpcClientData_t cd0

static

Definition at line 32 of file fileXio_rpc.c.

Referenced by fileXioChdir(), fileXioChStat(), fileXioClose(), fileXioCopyfile(), fileXioDclose(), fileXioDevctl(), fileXioDopen(), fileXioDread(), fileXioExit(), fileXioFormat(), fileXioGetDeviceList(), fileXioGetdir(), fileXioGetStat(), fileXioInit(), fileXioIoctl(), fileXioIoctl2(), fileXioLseek(), fileXioLseek64(), fileXioMkdir(), fileXioMount(), fileXioOpen(), fileXioRead(), fileXioReadlink(), fileXioRemove(), fileXioRename(), fileXioRmdir(), fileXioSetRWBufferSize(), fileXioStop(), fileXioSymlink(), fileXioSync(), fileXioUmount(), and fileXioWrite().

fileXioBlockMode

int fileXioBlockMode

static

Definition at line 36 of file fileXio_rpc.c.

Referenced by fileXioChdir(), fileXioChStat(), fileXioClose(), fileXioCopyfile(), fileXioDclose(), fileXioDevctl(), fileXioDopen(), fileXioDread(), fileXioFormat(), fileXioGetDeviceList(), fileXioGetdir(), fileXioGetStat(), fileXioInit(), fileXioIoctl(), fileXioIoctl2(), fileXioLseek(), fileXioLseek64(), fileXioMkdir(), fileXioMount(), fileXioOpen(), fileXioRead(), fileXioReadlink(), fileXioRemove(), fileXioRename(), fileXioRmdir(), fileXioSetBlockMode(), fileXioSymlink(), fileXioSync(), fileXioUmount(), fileXioWaitAsync(), and fileXioWrite().

fileXioCompletionSema

int fileXioCompletionSema = -1

static

Definition at line 37 of file fileXio_rpc.c.

Referenced by _fxio_intr(), fileXioChdir(), fileXioChStat(), fileXioClose(), fileXioCopyfile(), fileXioDclose(), fileXioDevctl(), fileXioDopen(), fileXioDread(), fileXioExit(), fileXioFormat(), fileXioGetDeviceList(), fileXioGetdir(), fileXioGetStat(), fileXioInit(), fileXioIoctl(), fileXioIoctl2(), fileXioLseek(), fileXioLseek64(), fileXioMkdir(), fileXioMount(), fileXioOpen(), fileXioRead(), fileXioReadlink(), fileXioRemove(), fileXioRename(), fileXioRmdir(), fileXioSetRWBufferSize(), fileXioSymlink(), fileXioSync(), fileXioUmount(), fileXioWaitAsync(), fileXioWrite(), fxio_ctl_intr(), and recv_intr().

fileXioInited

int fileXioInited = 0

static

Definition at line 35 of file fileXio_rpc.c.

Referenced by fileXioExit(), and fileXioInit().

sbuff

unsigned int sbuff[0x1300]

static

Definition at line 33 of file fileXio_rpc.c.

Referenced by fileXioChdir(), fileXioChStat(), fileXioClose(), fileXioCopyfile(), fileXioDclose(), fileXioDevctl(), fileXioDopen(), fileXioDread(), fileXioFormat(), fileXioGetDeviceList(), fileXioGetdir(), fileXioGetStat(), fileXioIoctl(), fileXioIoctl2(), fileXioLseek(), fileXioLseek64(), fileXioMkdir(), fileXioMount(), fileXioOpen(), fileXioRead(), fileXioReadlink(), fileXioRemove(), fileXioRename(), fileXioRmdir(), fileXioSetRWBufferSize(), fileXioStop(), fileXioSymlink(), fileXioSync(), fileXioUmount(), fileXioWaitAsync(), and fileXioWrite().