#include <stdio.h>
#include <tamtypes.h>
#include <errno.h>
#include <kernel.h>
#include <string.h>
#include <sifrpc.h>
#include <loadfile.h>
#include <iopheap.h>
#include <malloc.h>
#include "sys/fcntl.h"
#include "sys/stat.h"
#include "sys/ioctl.h"
#include "libhdd.h"
#include "fileXio_rpc.h"
#include "io_common.h"

Include dependency graph for libhdd.c:

Macros
#define	NEWLIB_PORT_AWARE

#define	PFS_ZONE_SIZE 8192

#define	PFS_FRAGMENT_OPT 0x00002d66

#define	PFS_FRAGMENT 0x00000000

#define	_OMIT_SYSTEM_PARTITION

Functions
static void	hddUpdateInfo ()

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)

Variables
static int	pfsFormatArg [1] = { PFS_ZONE_SIZE }

static char *	sizesString [9]

static int	sizesMB [9]

static int	hddStatusCurrent = 0

static u32	hddSize

static u32	hddFree

static u32	hddMaxPartitionSize

Macro Definition Documentation

◆ _OMIT_SYSTEM_PARTITION

#define _OMIT_SYSTEM_PARTITION

Definition at line 43 of file libhdd.c.

◆ NEWLIB_PORT_AWARE

#define NEWLIB_PORT_AWARE

Definition at line 29 of file libhdd.c.

◆ PFS_FRAGMENT

#define PFS_FRAGMENT 0x00000000

Definition at line 35 of file libhdd.c.

◆ PFS_FRAGMENT_OPT

#define PFS_FRAGMENT_OPT 0x00002d66

Definition at line 34 of file libhdd.c.

◆ PFS_ZONE_SIZE

#define PFS_ZONE_SIZE 8192

Definition at line 33 of file libhdd.c.

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

◆ hddUpdateInfo()

static void hddUpdateInfo ( )

static

Definition at line 262 of file libhdd.c.

 {
         iox_dirent_t infoDirEnt;
         int rv;
         int hddFd;
         u32 hddUsed = 0;
  
         hddSize = (u32)fileXioDevctl("hdd0:", HDIOC_TOTALSECTOR, NULL, 0, NULL, 0) / 2048; //sectors * 512 / 1024 / 1024;
  
 /* This gives inaccurate results, due to it being an approximation.
         fileXioDevctl("hdd0:", HDIOC_FREESECTOR, NULL, 0, &rv, 4);
         hddFree = rv * 512 / 1024 / 1024;
 */
         hddFd = fileXioDopen("hdd0:");
         if(hddFd < 0) // For when a HDD is not connected!
                 return;
  
         rv = fileXioDread(hddFd, &infoDirEnt);
         while(rv > 0)
         {
                 if(infoDirEnt.stat.mode != FS_TYPE_EMPTY)
                         hddUsed += infoDirEnt.stat.size / 2048; //Equal to, but avoids overflows of: infoDirEnt.stat.size * 512 / 1024 / 1024;
  
                 rv = fileXioDread(hddFd, &infoDirEnt);
         }
         fileXioDclose(hddFd);
         hddFree = hddSize - hddUsed;
  
         hddMaxPartitionSize = (u32)fileXioDevctl("hdd0:", HDIOC_MAXSECTOR, NULL, 0, NULL, 0) / 2048; //Equal to, but avoids overflows of: sectors * 512 / 1024 / 1024;
  
         hddStatusCurrent = 1;
 }

References fileXioDclose(), fileXioDevctl(), fileXioDopen(), fileXioDread(), FS_TYPE_EMPTY, hddFree, hddMaxPartitionSize, hddSize, hddStatusCurrent, HDIOC_MAXSECTOR, HDIOC_TOTALSECTOR, iox_stat_t::mode, NULL, iox_stat_t::size, and iox_dirent_t::stat.

Referenced by hddCheckFormatted(), hddCheckPresent(), hddExpandFilesystem(), hddFormat(), hddGetFilesystemList(), hddGetInfo(), hddMakeFilesystem(), and hddRemoveFilesystem().

Variable Documentation

◆ hddFree

u32 hddFree

static

Definition at line 73 of file libhdd.c.

Referenced by hddGetInfo(), and hddUpdateInfo().

◆ hddMaxPartitionSize

u32 hddMaxPartitionSize

static

Definition at line 73 of file libhdd.c.

Referenced by hddExpandFilesystem(), hddGetInfo(), hddMakeFilesystem(), and hddUpdateInfo().

◆ hddSize

u32 hddSize

static

Definition at line 73 of file libhdd.c.

Referenced by hddGetInfo(), and hddUpdateInfo().

◆ hddStatusCurrent

int hddStatusCurrent = 0

static

Definition at line 72 of file libhdd.c.

Referenced by hddCheckFormatted(), hddCheckPresent(), hddExpandFilesystem(), hddFormat(), hddGetFilesystemList(), hddMakeFilesystem(), hddRemoveFilesystem(), and hddUpdateInfo().

◆ pfsFormatArg

int pfsFormatArg[1] = { PFS_ZONE_SIZE }

static

Definition at line 40 of file libhdd.c.

Referenced by hddFormat(), and hddMakeFilesystem().

◆ sizesMB

int sizesMB[9]

static

Initial value:

Definition at line 58 of file libhdd.c.

Referenced by hddExpandFilesystem(), and hddMakeFilesystem().

◆ sizesString

char* sizesString[9]

static

Initial value:

Definition at line 46 of file libhdd.c.

Referenced by hddExpandFilesystem(), and hddMakeFilesystem().

Macros

Functions

Variables

Macro Definition Documentation

◆ _OMIT_SYSTEM_PARTITION

◆ NEWLIB_PORT_AWARE

◆ PFS_FRAGMENT

◆ PFS_FRAGMENT_OPT

◆ PFS_ZONE_SIZE

Function Documentation

◆ hddCheckFormatted()

◆ hddCheckPresent()

◆ hddExpandFilesystem()

◆ hddFormat()

◆ hddGetFilesystemList()

◆ hddGetInfo()

◆ hddMakeFilesystem()

◆ hddRemoveFilesystem()

◆ hddUpdateInfo()

Variable Documentation

◆ hddFree

◆ hddMaxPartitionSize

◆ hddSize

◆ hddStatusCurrent

◆ pfsFormatArg

◆ sizesMB

◆ sizesString