public int sceKernelAllocPartitionMemory(MemoryPartitions PartitionId, string Name,
HleMemoryManager.BlockTypeEnum Type, int Size, /* void* */ uint Address)
{
if ((int)PartitionId <= 0 || (int)PartitionId == 7 || (int)PartitionId >= 10)
{
throw (new SceKernelException(SceKernelErrors.ERROR_KERNEL_ILLEGAL_ARGUMENT));
}
if (Size <= 0)
{
throw (new SceKernelException(SceKernelErrors.ERROR_KERNEL_FAILED_ALLOC_MEMBLOCK));
}
//Console.Error.WriteLineColored(ConsoleColor.Yellow, "sceKernelAllocPartitionMemory: {0}, {1}, {2}, {3}, {4}", PartitionId, MemoryManager.GetPartition(PartitionId).MaxFreeSize, Name, Type, Size);
if (Name == null)
{
throw (new SceKernelException(SceKernelErrors.ERROR_ERROR));
}
MemoryPartition MemoryPartition;
int Alignment = 1;
switch (Type)
{
case HleMemoryManager.BlockTypeEnum.HighAligned:
case HleMemoryManager.BlockTypeEnum.LowAligned:
Alignment = (int)Address;
break;
}
if ((Alignment == 0) || !MathUtils.IsPowerOfTwo((uint)Alignment))
{
throw (new SceKernelException(SceKernelErrors.ERROR_KERNEL_ILLEGAL_ALIGNMENT_SIZE));
}
try
{
switch (Type)
{
case HleMemoryManager.BlockTypeEnum.Low:
case HleMemoryManager.BlockTypeEnum.LowAligned:
MemoryPartition = MemoryManager.GetPartition(PartitionId).Allocate(Size,
MemoryPartition.Anchor.Low, Alignment: Alignment, Name: Name);
break;
case HleMemoryManager.BlockTypeEnum.High:
case HleMemoryManager.BlockTypeEnum.HighAligned:
MemoryPartition = MemoryManager.GetPartition(PartitionId).Allocate(Size,
MemoryPartition.Anchor.High, Alignment: Alignment, Name: Name);
break;
case HleMemoryManager.BlockTypeEnum.Address:
if (Address == 0)
{
throw (new SceKernelException(SceKernelErrors.ERROR_KERNEL_FAILED_ALLOC_MEMBLOCK));
}
MemoryPartition = MemoryManager.GetPartition(PartitionId).Allocate(Size,
MemoryPartition.Anchor.Low, Position: Address, Alignment: Alignment, Name: Name);
break;
default:
Console.Error.WriteLineColored(ConsoleColor.Red,
"Not Implemented sceKernelAllocPartitionMemory with Type='" + Type + "'");
throw (new SceKernelException(SceKernelErrors.ERROR_KERNEL_ILLEGAL_MEMBLOCK_ALLOC_TYPE));
}
}
catch (MemoryPartitionNoMemoryException MemoryPartitionNoMemoryException)
{
//Console.Error.WriteLine(InvalidOperationException);
Console.Error.WriteLine(MemoryPartitionNoMemoryException);
throw (new SceKernelException(SceKernelErrors.ERROR_KERNEL_NO_MEMORY));
}
//Console.Error.WriteLineColored(ConsoleColor.Cyan, " sceKernelAllocPartitionMemory: {0}", MemoryPartition);
return((int)MemoryManager.MemoryPartitionsUid.Create(MemoryPartition));
//return MemoryPartition;
}
public int sceKernelAllocPartitionMemory(HleMemoryManager.Partitions PartitionId, string Name, HleMemoryManager.BlockTypeEnum Type, int Size, /* void* */ uint Address)
{
MemoryPartition MemoryPartition;
int Alignment = 1;
switch (Type)
{
case HleMemoryManager.BlockTypeEnum.HighAligned:
case HleMemoryManager.BlockTypeEnum.LowAligned:
Alignment = (int)Address;
break;
}
if (Type == HleMemoryManager.BlockTypeEnum.Low || Type == HleMemoryManager.BlockTypeEnum.LowAligned)
{
try
{
MemoryPartition = HleState.MemoryManager.GetPartition(PartitionId).Allocate(Size, MemoryPartition.Anchor.Low, Alignment: Alignment);
}
catch (InvalidOperationException InvalidOperationException)
{
//Console.Error.WriteLine(InvalidOperationException);
Console.Error.WriteLine(InvalidOperationException.Message);
throw(new SceKernelException(SceKernelErrors.ERROR_KERNEL_NO_MEMORY));
}
}
else
{
throw (new NotImplementedException("Not Implemented sceKernelAllocPartitionMemory with '" + Type + "'"));
}
return((int)HleState.MemoryManager.MemoryPartitionsUid.Create(MemoryPartition));
/*
* throw(new NotImplementedException());
* const uint ERROR_KERNEL_ILLEGAL_MEMBLOCK_ALLOC_TYPE = 0x800200d8;
* const uint ERROR_KERNEL_FAILED_ALLOC_MEMBLOCK = 0x800200d9;
*
* try {
* MemorySegment memorySegment;
*
* Logger.log(Logger.Level.INFO, "SysMemUserForUser", "sceKernelAllocPartitionMemory(%d:'%s':%s:%d,0x%08X)", PartitionId, Name, std.conv.to!string(Type), Size, Address);
* //Logger.log(Logger.Level.INFO, "SysMemUserForUser", "sceKernelAllocPartitionMemory(%d:'%s':%d:%d)", partitionid, name, (type), size);
*
* int alignment = 1;
* if ((Type == PspSysMemBlockTypes.PSP_SMEM_Low_Aligned) || (Type == PspSysMemBlockTypes.PSP_SMEM_High_Aligned)) {
* alignment = Address;
* }
*
* switch (Type) {
* default: return ERROR_KERNEL_ILLEGAL_MEMBLOCK_ALLOC_TYPE;
* case PspSysMemBlockTypes.PSP_SMEM_Low_Aligned:
* case PspSysMemBlockTypes.PSP_SMEM_Low : memorySegment = pspMemorySegment[PartitionId].allocByLow (Size, dupStr(Name), 0, alignment); break;
* case PspSysMemBlockTypes.PSP_SMEM_High_Aligned:
* case PspSysMemBlockTypes.PSP_SMEM_High: memorySegment = pspMemorySegment[PartitionId].allocByHigh(Size, dupStr(Name), alignment); break;
* case PspSysMemBlockTypes.PSP_SMEM_Addr: memorySegment = pspMemorySegment[PartitionId].allocByAddr(Address, Size, dupStr(Name)); break;
* }
*
* if (memorySegment is null) return ERROR_KERNEL_FAILED_ALLOC_MEMBLOCK;
*
* SceUID sceUid = uniqueIdFactory.add(memorySegment);
*
* Logger.log(Logger.Level.INFO, "SysMemUserForUser", "sceKernelAllocPartitionMemory(%d:'%s':%s:%d) :: (%d) -> %s", PartitionId, Name, std.conv.to!string(Type), Size, sceUid, memorySegment.block);
* //Logger.log(Logger.Level.INFO, "SysMemUserForUser", "sceKernelAllocPartitionMemory(%d:'%s':%d:%d) :: (%d) -> %s", partitionid, name, (type), size, sceUid, memorySegment.block);
*
* return sceUid;
* }
* catch (Exception Exception)
* {
* //logError("ERROR: %s", o);
* return ERROR_KERNEL_FAILED_ALLOC_MEMBLOCK;
* }
*/
}
