fileXio_rpc.h File Reference

#include <fileXio.h>
#include <sys/stat.h>

Include dependency graph for fileXio_rpc.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	FXIO_WAIT   0
#define	FXIO_NOWAIT   1
#define	FXIO_COMPLETE   1
#define	FXIO_INCOMPLETE   0

Functions
int	fileXioInit (void)
void	fileXioExit (void)
void	fileXioSetBlockMode (int blocking)
int	fileXioWaitAsync (int mode, int *retVal)
void	fileXioStop ()
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 *blockdev, 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)
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)
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	fileXioSetRWBufferSize (int size)

Detailed Description

fileXio RPC client header file

Definition in file fileXio_rpc.h.

Macro Definition Documentation

FXIO_COMPLETE

#define FXIO_COMPLETE   1

Definition at line 30 of file fileXio_rpc.h.

FXIO_INCOMPLETE

#define FXIO_INCOMPLETE   0

Definition at line 31 of file fileXio_rpc.h.

FXIO_NOWAIT

#define FXIO_NOWAIT   1

Definition at line 28 of file fileXio_rpc.h.

FXIO_WAIT

#define FXIO_WAIT   0

Definition at line 27 of file fileXio_rpc.h.

Function Documentation

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().

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().

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 *	blockdev,
		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().

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().

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().

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

(

)

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().