libhdd.h File Reference

#include <tamtypes.h>
#include <hdd-ioctl.h>
#include <libpwroff.h>

Include dependency graph for libhdd.h:

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

Go to the source code of this file.

Data Structures
struct	t_hddFilesystem
struct	t_hddInfo

Macros
#define	PFS_MT_ROBUST   0x02
#define	FS_COMMON_PREFIX   '+'
#define	FS_GROUP_SYSTEM   0x00
#define	FS_GROUP_COMMON   0x01
#define	FS_GROUP_APPLICATION   0x02
#define	FS_TYPE_EXT2   0x0083
#define	FS_TYPE_EXT2_SWAP   0x0082
#define	FS_TYPE_PFS   0x0100
#define	FS_TYPE_EMPTY   0x0000
#define	ATTR_MAIN_PARTITION   0x0000
#define	ATTR_SUB_PARTITION   0x0001
#define	hddPreparePoweroff   poweroffInit
#define	hddSetUserPoweroffCallback   poweroffSetCallback
#define	hddPowerOff   poweroffShutdown

Functions
int	hddCheckPresent ()
int	hddCheckFormatted ()
int	hddFormat ()
int	hddGetFilesystemList (t_hddFilesystem hddFs[], int maxEntries)
void	hddGetInfo (t_hddInfo *info)
int	hddMakeFilesystem (int fsSizeMB, char *name, int type)
int	hddRemoveFilesystem (t_hddFilesystem *fs)
int	hddExpandFilesystem (t_hddFilesystem *fs, int extraMB)

Detailed Description

HDD library functions

Definition in file libhdd.h.

Macro Definition Documentation

ATTR_MAIN_PARTITION

#define ATTR_MAIN_PARTITION   0x0000

Definition at line 36 of file libhdd.h.

ATTR_SUB_PARTITION

#define ATTR_SUB_PARTITION   0x0001

Definition at line 37 of file libhdd.h.

FS_COMMON_PREFIX

#define FS_COMMON_PREFIX   '+'

Definition at line 25 of file libhdd.h.

FS_GROUP_APPLICATION

#define FS_GROUP_APPLICATION   0x02

Definition at line 29 of file libhdd.h.

FS_GROUP_COMMON

#define FS_GROUP_COMMON   0x01

Definition at line 28 of file libhdd.h.

FS_GROUP_SYSTEM

#define FS_GROUP_SYSTEM   0x00

Definition at line 27 of file libhdd.h.

FS_TYPE_EMPTY

#define FS_TYPE_EMPTY   0x0000

Definition at line 34 of file libhdd.h.

FS_TYPE_EXT2

#define FS_TYPE_EXT2   0x0083

Definition at line 31 of file libhdd.h.

FS_TYPE_EXT2_SWAP

#define FS_TYPE_EXT2_SWAP   0x0082

Definition at line 32 of file libhdd.h.

FS_TYPE_PFS

#define FS_TYPE_PFS   0x0100

Definition at line 33 of file libhdd.h.

hddPowerOff

#define hddPowerOff   poweroffShutdown

Definition at line 85 of file libhdd.h.

hddPreparePoweroff

#define hddPreparePoweroff   poweroffInit

Definition at line 83 of file libhdd.h.

hddSetUserPoweroffCallback

#define hddSetUserPoweroffCallback   poweroffSetCallback

Definition at line 84 of file libhdd.h.

PFS_MT_ROBUST

#define PFS_MT_ROBUST   0x02

Definition at line 23 of file libhdd.h.

Function Documentation

hddCheckFormatted()

int hddCheckFormatted

(

)

Definition at line 90 of file libhdd.c.

{
        int rv;
 
        if(!hddStatusCurrent)
                hddUpdateInfo();
 
        rv = fileXioDevctl("hdd0:", HDIOC_STATUS, NULL, 0, NULL, 0);
        if((rv >= 1) || (rv < 0))
                return -1;
        else
                return 0;
}

References fileXioDevctl(), hddStatusCurrent, hddUpdateInfo(), HDIOC_STATUS, and NULL.

hddCheckPresent()

int hddCheckPresent

(

)

Definition at line 75 of file libhdd.c.

{
        int rv;
 
        if(!hddStatusCurrent)
                hddUpdateInfo();
 
        rv = fileXioDevctl("hdd0:", HDIOC_STATUS, NULL, 0, NULL, 0);
 
        if((rv >= 3) || (rv < 0))
                return -1;
        else
                return 0;
}

References fileXioDevctl(), hddStatusCurrent, hddUpdateInfo(), HDIOC_STATUS, and NULL.

hddExpandFilesystem()

int hddExpandFilesystem	(	t_hddFilesystem *	fs,
		int	extraMB
	)

Definition at line 473 of file libhdd.c.

{
        int maxIndex;
        int useIndex;
        int partSize;
        int fsSizeLeft = extraMB;
        int partFd;
        int retVal;
 
        if(!hddStatusCurrent)
                hddUpdateInfo();
 
        if(extraMB % 128)
                return -EINVAL;
 
        // Get index for max partition size
        for(maxIndex = 0; maxIndex < 9; maxIndex++)
                if(sizesMB[maxIndex] == hddMaxPartitionSize)
                        break;
 
        // Get index of size we will use to create new subs
        for(useIndex = maxIndex; sizesMB[useIndex] > extraMB; useIndex--);
 
        partSize = sizesMB[useIndex];
 
        // Open partition
        partFd = fileXioOpen(fs->filename, FIO_O_RDWR);
        if(partFd < 0)
                return partFd;
 
        while(fsSizeLeft)
        {
                // Adjust size if necessary
                if(fsSizeLeft < partSize)
                {
#ifdef DEBUG
                        printf(">>> Adjusting sub size: %d MB to ", sizesMB[useIndex]);
#endif
                        for(useIndex = maxIndex; sizesMB[useIndex] > fsSizeLeft; useIndex--);
                        partSize = sizesMB[useIndex];
                        maxIndex = useIndex;
#ifdef DEBUG
                        printf("%d MB\n", sizesMB[useIndex]);
#endif
                }
 
                // Try and allocate new sub
#ifdef DEBUG
                printf(">>> Attempting to create sub partition of size %d MB\n", sizesMB[useIndex]);
#endif
                retVal = fileXioIoctl2(partFd, HIOCADDSUB, sizesString[useIndex], strlen(sizesString[useIndex]) + 1, NULL, 0);
                if(retVal == -ENOSPC)
                {
                        // If sub alloc fails due to size, we decrease size and try again.
                        // If we've run out of sizes, break the loop (give up)
                        useIndex--;
                        partSize = sizesMB[useIndex];
                        maxIndex = useIndex;
 
                        if(useIndex < 0)
                        {
#ifdef DEBUG
                                printf(">>> Out of sizes to try. Giving up.\n");
#endif
                                break;
                        }
#ifdef DEBUG
                        printf(">>> Subpartition alloc FAILED! Trying with size of %d MB\n", partSize);
#endif
 
                        continue;
                }
                // If we've reached the max number of subs, bail.
                else if(retVal == -EFBIG)
                        break;
                else if(retVal >= 0)
                {
#ifdef DEBUG
                        printf(">>> Sub creation successfull!\n");
#endif
                }
                else
                {
#ifdef DEBUG
                        printf(">>> Unknown error while creating sub: %d\n", retVal);
#endif
                }
 
                fsSizeLeft -= sizesMB[useIndex];
        }
 
        fileXioClose(partFd);
 
        hddUpdateInfo();
 
        return extraMB - fsSizeLeft;
}

References EFBIG, EINVAL, ENOSPC, t_hddFilesystem::filename, fileXioClose(), fileXioIoctl2(), fileXioOpen(), FIO_O_RDWR, hddMaxPartitionSize, hddStatusCurrent, hddUpdateInfo(), HIOCADDSUB, NULL, sizesMB, and sizesString.

hddFormat()

int hddFormat

(

)

Definition at line 105 of file libhdd.c.

{
        int retVal, i;
        const char *partitionList[] = {
                "hdd0:__net",
                "hdd0:__system",
                "hdd0:__sysconf",
                "hdd0:__common",
                NULL
        };
 
        if(!hddStatusCurrent)
                hddUpdateInfo();
 
        retVal = fileXioFormat("hdd0:", NULL, NULL, 0);
        if(retVal < 0)
                return retVal;
 
        for(i = 0; partitionList[i] != NULL; i++)
        {
                retVal = fileXioFormat("pfs:", partitionList[i], (const char*)&pfsFormatArg, sizeof(pfsFormatArg));
                if(retVal < 0)
                        return retVal;
        }
 
        hddUpdateInfo();
 
        return 0;
}

References fileXioFormat(), hddStatusCurrent, hddUpdateInfo(), NULL, and pfsFormatArg.

hddGetFilesystemList()

int hddGetFilesystemList	(	t_hddFilesystem	hddFs[],
		int	maxEntries
	)

Definition at line 135 of file libhdd.c.

{
        iox_dirent_t dirEnt;
        int count = 0;
        u32 size = 0;
        int hddFd;
        int rv;
 
        if(!hddStatusCurrent)
                hddUpdateInfo();
 
        hddFd = fileXioDopen("hdd0:");
 
        if(hddFd < 0)
                return hddFd;
 
        rv = fileXioDread(hddFd, &dirEnt);
 
        while((rv > 0) && (count < maxEntries))
        {
                int i;
                int partitionFd;
                u32 zoneFree, zoneSize;
 
                // We only want to know about main partitions (non-empty ones at that :P)
                if((dirEnt.stat.attr & ATTR_SUB_PARTITION) || (dirEnt.stat.mode == FS_TYPE_EMPTY))
                {
                        rv = fileXioDread(hddFd, &dirEnt);
                        continue;
                }
 
                memset(&hddFs[count], 0, sizeof(t_hddFilesystem));
                snprintf(hddFs[count].filename, 40, "hdd0:%.34s", dirEnt.name);
 
                // Work out filesystem type
                if((dirEnt.name[0] == '_') && (dirEnt.name[1] == '_'))
                {
                        hddFs[count].fileSystemGroup = FS_GROUP_SYSTEM;
                        strcpy(hddFs[count].name, &dirEnt.name[2]);
                }
                else if(dirEnt.name[0] == FS_COMMON_PREFIX)
                {
                        hddFs[count].fileSystemGroup = FS_GROUP_COMMON;
                        strcpy(hddFs[count].name, &dirEnt.name[1]);
                }
                else
                {
                        hddFs[count].fileSystemGroup = FS_GROUP_APPLICATION;
                        strcpy(hddFs[count].name, dirEnt.name);
                }
 
#ifdef  _OMIT_SYSTEM_PARTITION
                if(hddFs[count].fileSystemGroup == FS_GROUP_SYSTEM)
                {
                        rv = fileXioDread(hddFd, &dirEnt);
                        continue;
                }
#endif
 
#ifdef DEBUG
                printf("> Filename: %s\n> Name: %s\n> Type: %d\n", hddFs[count].filename, hddFs[count].name, hddFs[count].fileSystemGroup);
#endif
 
                // Calculate filesystem size
                partitionFd = fileXioOpen(hddFs[count].filename, FIO_O_RDONLY);
 
                // If we failed to open the partition, then a password is probably set
                // (usually this means we have tried to access a game partition). We
                // dont want to return un-accessible game partitions in the filesystem list..
                if(partitionFd < 0)
                {
                        rv = fileXioDread(hddFd, &dirEnt);
                        continue;
                }
 
                for(i = 0, size = 0; i < dirEnt.stat.private_0 + 1; i++)
                {
                        rv = fileXioIoctl2(partitionFd, HIOCGETSIZE, &i, 4, NULL, 0);
                        size += (u32)rv / 2048; //Equal to, but avoids overflows of: rv * 512 / 1024 / 1024;
                }
 
                fileXioClose(partitionFd);
 
                hddFs[count].size = size;
 
                // Get filesystem free space & format status
                hddFs[count].freeSpace = 0;
                hddFs[count].formatted = 0;
 
                if(dirEnt.stat.mode == FS_TYPE_PFS)
                {
                        rv = fileXioMount("pfs0:", hddFs[count].filename, FIO_MT_RDONLY);
                        if(rv == 0)
                        {
 
                                zoneFree = fileXioDevctl("pfs0:", PDIOC_ZONEFREE, NULL, 0, NULL, 0);
                                zoneSize = fileXioDevctl("pfs0:", PDIOC_ZONESZ, NULL, 0, NULL, 0);
 
                                hddFs[count].freeSpace = zoneFree * zoneSize / 1024 / 1024;
                                hddFs[count].formatted = 1;
 
                                fileXioUmount("pfs0:");
                        }
                }
 
#ifdef DEBUG
                printf("> Formatted: %d\n> Size: %d\n> Free: %d\n", hddFs[count].formatted, (int)hddFs[count].size, (int)hddFs[count].freeSpace);
#endif
 
                count++;
                rv = fileXioDread(hddFd, &dirEnt);
        }
 
        rv = fileXioDclose(hddFd);
 
        return count;
}

References iox_stat_t::attr, ATTR_SUB_PARTITION, t_hddFilesystem::fileSystemGroup, fileXioClose(), fileXioDclose(), fileXioDevctl(), fileXioDopen(), fileXioDread(), fileXioIoctl2(), fileXioMount(), fileXioOpen(), fileXioUmount(), FIO_MT_RDONLY, FIO_O_RDONLY, t_hddFilesystem::formatted, t_hddFilesystem::freeSpace, FS_COMMON_PREFIX, FS_GROUP_APPLICATION, FS_GROUP_COMMON, FS_GROUP_SYSTEM, FS_TYPE_EMPTY, FS_TYPE_PFS, hddStatusCurrent, hddUpdateInfo(), HIOCGETSIZE, iox_stat_t::mode, iox_dirent_t::name, NULL, PDIOC_ZONEFREE, PDIOC_ZONESZ, iox_stat_t::private_0, t_hddFilesystem::size, and iox_dirent_t::stat.

hddGetInfo()

void hddGetInfo

(

t_hddInfo *

info

)

Definition at line 253 of file libhdd.c.

{
        hddUpdateInfo();
 
        info->hddSize = hddSize;
        info->hddFree = hddFree;
        info->hddMaxPartitionSize = hddMaxPartitionSize;
}

References hddFree, hddMaxPartitionSize, hddSize, hddUpdateInfo(), and info.

hddMakeFilesystem()

int hddMakeFilesystem	(	int	fsSizeMB,
		char *	name,
		int	type
	)

Definition at line 295 of file libhdd.c.

{
        int maxIndex;
        int useIndex;
        int partSize;
        int fsSizeLeft = fsSizeMB;
        int partFd;
        char openString[256];
        char fsName[256];
        int retVal;
 
        if(!hddStatusCurrent)
                hddUpdateInfo();
 
        if(fsSizeMB % 128)
                return -EINVAL;
 
        switch(type)
        {
                case FS_GROUP_SYSTEM:
                        sprintf(fsName, "__%s", name);
                        break;
                case FS_GROUP_COMMON:
                        sprintf(fsName, "+%s", name);
                        break;
                default:
                        strcpy(fsName, name);
                        break;
        }
 
        // Check if filesystem already exists
        sprintf(openString, "hdd0:%s", fsName);
        partFd = fileXioOpen(openString, FIO_O_RDONLY);
        if(partFd > 0 || partFd == -EACCES)     // Filesystem already exists
        {
                fileXioClose(partFd);
                return -1;
        }
 
        // Get index for max partition size
        for(maxIndex = 0; maxIndex < 9; maxIndex++)
                if(sizesMB[maxIndex] == hddMaxPartitionSize)
                        break;
 
        // Get index of size we will use to create main partition
        for(useIndex = maxIndex; sizesMB[useIndex] > fsSizeMB; useIndex--);
 
        for(partSize = sizesMB[useIndex]; useIndex >= 0; useIndex--,partSize = sizesMB[useIndex])
        {
#ifdef DEBUG
                printf(">>> Attempting to create main partition, size %d MB\n", partSize);
#endif
 
                sprintf(openString, "hdd0:%s,,,%s,PFS", fsName, sizesString[useIndex]);
#ifdef DEBUG
                printf(">>> openString = %s\n", openString);
#endif
 
                partFd = fileXioOpen(openString, FIO_O_RDWR | FIO_O_CREAT);
                if(partFd >= 0)
                        break;
                else {
                        if(partFd != -ENOSPC)
                        {
#ifdef DEBUG
                                printf(">>> Could not create Main Partition (error %d)!\n", partFd);
#endif
                                return partFd;
                        }
                }
        }
 
        if(useIndex < 0)
        {
#ifdef DEBUG
                printf(">>> Could not create Main Partition (no space)!\n");
#endif
                return -ENOSPC;
        }
 
        fsSizeLeft -= partSize;
#ifdef DEBUG
        printf(">>> Main partition of %d MB created!\n", partSize);
#endif
 
        while(fsSizeLeft)
        {
 
                // Adjust size if necessary
                if(fsSizeLeft < partSize)
                {
#ifdef DEBUG
                        printf(">>> Adjusting sub size: %d MB to ", sizesMB[useIndex]);
#endif
                        for(useIndex = maxIndex; sizesMB[useIndex] > fsSizeLeft; useIndex--);
                        partSize = sizesMB[useIndex];
                        maxIndex = useIndex;
#ifdef DEBUG
                        printf("%d MB\n", sizesMB[useIndex]);
#endif
                }
 
                // Try and allocate sub
#ifdef DEBUG
                printf(">>> Attempting to create sub partition of size %d MB\n", sizesMB[useIndex]);
#endif
                retVal = fileXioIoctl2(partFd, HIOCADDSUB, sizesString[useIndex], strlen(sizesString[useIndex]) + 1, NULL, 0);
                if(retVal == -ENOSPC)
                {
                        // If sub alloc fails due to size, we decrease size and try again.
                        // If we've run out of sizes, break the loop (give up)
                        useIndex--;
                        partSize = sizesMB[useIndex];
                        maxIndex = useIndex;
 
                        if(useIndex < 0)
                        {
#ifdef DEBUG
                                printf(">>> Out of sizes to try. Giving up.\n");
#endif
                                break;
                        }
#ifdef DEBUG
                        printf(">>> Subpartition alloc FAILED! Trying with size of %d MB\n", partSize);
#endif
 
                        continue;
                }
                // If we've reached the max number of subs, bail.
                else if(retVal == -EFBIG)
                        break;
                else if(retVal >= 0)
                {
#ifdef DEBUG
                        printf(">>> Sub creation successfull!\n");
#endif
                }
                else
                {
#ifdef DEBUG
                        printf(">>> Unknown error while creating sub: %d\n", retVal);
#endif
                }
 
                fsSizeLeft -= sizesMB[useIndex];
        }
 
        fileXioClose(partFd);
 
        sprintf(openString, "hdd0:%s", fsName);
        retVal = fileXioFormat("pfs:", openString, (const char*)&pfsFormatArg, sizeof(pfsFormatArg));
        if(retVal < 0)
        {
#ifdef DEBUG
                printf(">>> Failed to format new partition: %d\n", retVal);
#endif
                return retVal;
        }
 
        hddUpdateInfo();
 
        return fsSizeMB - fsSizeLeft;
}

References EACCES, EFBIG, EINVAL, ENOSPC, fileXioClose(), fileXioFormat(), fileXioIoctl2(), fileXioOpen(), FIO_O_CREAT, FIO_O_RDONLY, FIO_O_RDWR, FS_GROUP_COMMON, FS_GROUP_SYSTEM, hddMaxPartitionSize, hddStatusCurrent, hddUpdateInfo(), HIOCADDSUB, NULL, pfsFormatArg, sizesMB, and sizesString.

hddRemoveFilesystem()

int hddRemoveFilesystem

(

t_hddFilesystem *

fs

)

Definition at line 459 of file libhdd.c.

{
        int rv;
 
        if(!hddStatusCurrent)
                hddUpdateInfo();
 
        rv = fileXioRemove(fs->filename);
 
        hddUpdateInfo();
 
        return rv;
}

References t_hddFilesystem::filename, fileXioRemove(), hddStatusCurrent, and hddUpdateInfo().