berkus
/
essence-os
mirror of https://gitlab.com/nakst/essence
1
0
Fork 0
Code Releases Activity

introduce ES_SYSCALL_HANDLE_SHARE

This commit is contained in:
nakst 2021-09-11 13:45:13 +01:00
parent 28d6f9eb00
commit fcaa141e68
15 changed files with 93 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
apps/installer.cpp
View File

@ -1,6 +1,11 @@
#define INSTALLER
#define ES_CRT_WITHOUT_PREFIX
#include <essence.h>
#include <ports/lzma/LzmaDec.c>
#include <shared/hash.cpp>
#define Log(...)
#define exit(x) EsThreadTerminate(ES_CURRENT_THREAD)
#include <shared/esfs2.h>
#define BUFFER_SIZE (1048576)
#define NAME_MAX (4096)
@ -52,8 +57,10 @@ bool Decompress(Extractor *e, void *_buffer, size_t bytes) {
return true;
}
EsError Extract(Extractor *e, const char *pathIn, size_t pathInBytes, const char *pathOut, size_t pathOutBytes) {
EsMemoryZero(e, sizeof(Extractor));
EsError Extract(const char *pathIn, size_t pathInBytes, const char *pathOut, size_t pathOutBytes) {
Extractor *e = (Extractor *) EsHeapAllocate(sizeof(Extractor), true);
if (!e) return ES_ERROR_INSUFFICIENT_RESOURCES;
EsDefer(EsHeapFree(e));
e->fileIn = EsFileOpen(pathIn, pathInBytes, ES_FILE_READ);
if (e->fileIn.error != ES_SUCCESS) return e->fileIn.error;
@ -107,11 +114,18 @@ EsError Extract(Extractor *e, const char *pathIn, size_t pathInBytes, const char
return crc64 == actualCRC64 ? ES_SUCCESS : ES_ERROR_CORRUPT_DATA;
}
void ReadBlock(uint64_t, uint64_t, void *) {
}
void WriteBlock(uint64_t, uint64_t, void *) {
}
void WriteBytes(uint64_t, uint64_t, void *) {
}
void _start() {
_init();
EsPerformanceTimerPush();
Extractor *e = (Extractor *) EsHeapAllocate(sizeof(Extractor), false);
EsAssert(ES_SUCCESS == Extract(e, EsLiteral("0:/installer_archive.dat"), EsLiteral("0:/extracted")));
EsHeapFree(e);
EsAssert(ES_SUCCESS == Extract(EsLiteral("0:/installer_archive.dat"), EsLiteral("0:/extracted")));
EsPrint("time: %Fs\n", EsPerformanceTimerPop());
}

1
apps/installer.ini
View File

@ -1,6 +1,7 @@
[general]
name=Installer
permission_all_files=1
permission_all_devices=1
hidden=1
[build]

57
apps/test.cpp
View File

@ -1,6 +1,5 @@
#include <essence.h>
#include <shared/strings.cpp>
#include <ports/lzma/LzmaDec.c>
// #include <shared/stb_ds.h>
@ -198,65 +197,9 @@ void InitialiseInstance(EsInstance *instance) {
EsCustomElementCreate(panel)->messageUser = TestCanvasMessage;
}
void *DecompressAllocate(ISzAllocPtr, size_t size) { return EsHeapAllocate(size, false); }
void DecompressFree(ISzAllocPtr, void *address) { EsHeapFree(address); }
const ISzAlloc decompressAllocator = { DecompressAllocate, DecompressFree };
void TestDecompress() {
EsFileInformation fileIn = EsFileOpen(EsLiteral("0:/test.lzma"), ES_FILE_READ);
EsFileInformation fileOut = EsFileOpen(EsLiteral("0:/test.png"), ES_FILE_WRITE);
size_t bufferSize = 16384;
uint8_t *memory = (uint8_t *) EsHeapAllocate(bufferSize * 2, false);
if (fileIn.error == ES_SUCCESS && fileOut.error == ES_SUCCESS && memory) {
uint8_t header[LZMA_PROPS_SIZE + 8];
EsFileReadSync(fileIn.handle, 0, sizeof(header), header);
CLzmaDec state;
LzmaDec_Construct(&state);
LzmaDec_Allocate(&state, header, LZMA_PROPS_SIZE, &decompressAllocator);
LzmaDec_Init(&state);
uint8_t *inBuffer = memory + bufferSize * 0;
uint8_t *outBuffer = memory + bufferSize * 1;
size_t inFileOffset = sizeof(header);
size_t outFileOffset = 0;
size_t inBytes = 0;
size_t inPosition = 0;
while (true) {
if (inBytes == inPosition) {
inBytes = EsFileReadSync(fileIn.handle, inFileOffset, bufferSize, inBuffer);
if (!inBytes) break;
inPosition = 0;
inFileOffset += inBytes;
}
size_t inProcessed = inBytes - inPosition;
size_t outProcessed = bufferSize;
ELzmaStatus status;
LzmaDec_DecodeToBuf(&state, outBuffer, &outProcessed, inBuffer + inPosition, &inProcessed, LZMA_FINISH_ANY, &status);
EsFileWriteSync(fileOut.handle, outFileOffset, outProcessed, outBuffer);
inPosition += inProcessed;
outFileOffset += outProcessed;
}
LzmaDec_Free(&state, &decompressAllocator);
}
EsHandleClose(fileIn.handle);
EsHandleClose(fileOut.handle);
EsHeapFree(memory);
}
void _start() {
_init();
TestDecompress();
while (true) {
EsMessage *message = EsMessageReceive();

19
desktop/desktop.cpp
View File

@ -37,6 +37,7 @@
#define APPLICATION_PERMISSION_RUN_TEMPORARY_APPLICATION (1 << 3)
#define APPLICATION_PERMISSION_SHUTDOWN (1 << 4)
#define APPLICATION_PERMISSION_VIEW_FILE_TYPES (1 << 5)
#define APPLICATION_PERMISSION_ALL_DEVICES (1 << 6)
#define APPLICATION_ID_DESKTOP_BLANK_TAB (-0x70000000)
#define APPLICATION_ID_DESKTOP_SETTINGS (-0x70000001)
@ -1300,7 +1301,7 @@ bool ApplicationInstanceStart(int64_t applicationID, EsApplicationStartupInforma
}
instance->processID = EsProcessGetID(process);
instance->processHandle = EsSyscall(ES_SYSCALL_PROCESS_SHARE, process, ES_CURRENT_PROCESS, 0, 0);
instance->processHandle = EsSyscall(ES_SYSCALL_HANDLE_SHARE, process, ES_CURRENT_PROCESS, 0, 0);
if (startupInformation->documentID) {
instance->documentID = startupInformation->documentID;
@ -1324,7 +1325,7 @@ bool ApplicationInstanceStart(int64_t applicationID, EsApplicationStartupInforma
// Share handles to the file and the startup information buffer.
if (startupInformation->readHandle) {
startupInformation->readHandle = EsSyscall(ES_SYSCALL_NODE_SHARE, startupInformation->readHandle, process, 0, 0);
startupInformation->readHandle = EsSyscall(ES_SYSCALL_HANDLE_SHARE, startupInformation->readHandle, process, 0, 0);
}
if (!application->useSingleProcess && !application->createInstance) {
@ -1651,7 +1652,7 @@ void ApplicationInstanceRequestSave(ApplicationInstance *instance, const char *n
if (m.tabOperation.error == ES_SUCCESS) {
document->currentWriter = instance->embeddedWindowID;
m.tabOperation.handle = EsSyscall(ES_SYSCALL_NODE_SHARE, fileHandle, instance->processHandle, 0, 0);
m.tabOperation.handle = EsSyscall(ES_SYSCALL_HANDLE_SHARE, fileHandle, instance->processHandle, 0, 0);
EsHandleClose(fileHandle);
}
}
@ -1764,7 +1765,7 @@ void ApplicationInstanceCompleteSave(ApplicationInstance *fromInstance) {
EsMessage m = { ES_MSG_INSTANCE_DOCUMENT_UPDATED };
m.tabOperation.isSource = instance == fromInstance;
m.tabOperation.id = instance->embeddedWindowID;
m.tabOperation.handle = EsSyscall(ES_SYSCALL_NODE_SHARE, document->readHandle, instance->processHandle, 0, 0);
m.tabOperation.handle = EsSyscall(ES_SYSCALL_HANDLE_SHARE, document->readHandle, instance->processHandle, 0, 0);
EsMessagePostRemote(instance->processHandle, &m);
}
}
@ -1828,6 +1829,7 @@ void ConfigurationLoadApplications() {
#define READ_PERMISSION(x, y) if (EsSystemConfigurationGroupReadInteger(group, EsLiteral(x), 0)) application->permissions |= y
READ_PERMISSION("permission_all_files", APPLICATION_PERMISSION_ALL_FILES);
READ_PERMISSION("permission_all_devices", APPLICATION_PERMISSION_ALL_DEVICES);
READ_PERMISSION("permission_manage_processes", APPLICATION_PERMISSION_MANAGE_PROCESSES);
READ_PERMISSION("permission_posix_subsystem", APPLICATION_PERMISSION_POSIX_SUBSYSTEM);
READ_PERMISSION("permission_run_temporary_application", APPLICATION_PERMISSION_RUN_TEMPORARY_APPLICATION);
@ -2199,7 +2201,7 @@ void DesktopSyscall(EsMessage *message, uint8_t *buffer, EsBuffer *pipe) {
desktop.nextClipboardFile = handle;
desktop.nextClipboardProcessID = message->desktop.processID;
handle = EsSyscall(ES_SYSCALL_NODE_SHARE, handle, processHandle, 0, 0);
handle = EsSyscall(ES_SYSCALL_HANDLE_SHARE, handle, processHandle, 0, 0);
EsHeapFree(path);
} else {
@ -2242,7 +2244,7 @@ void DesktopSyscall(EsMessage *message, uint8_t *buffer, EsBuffer *pipe) {
if (processHandle) {
EsHandle fileHandle = desktop.clipboardFile
? EsSyscall(ES_SYSCALL_NODE_SHARE, desktop.clipboardFile, processHandle, 0, 1 /* ES_FILE_READ_SHARED */) : ES_INVALID_HANDLE;
? EsSyscall(ES_SYSCALL_HANDLE_SHARE, desktop.clipboardFile, processHandle, 1 /* ES_FILE_READ_SHARED */, 0) : ES_INVALID_HANDLE;
EsBufferWrite(pipe, &desktop.clipboardInformation, sizeof(desktop.clipboardInformation));
EsBufferWrite(pipe, &fileHandle, sizeof(fileHandle));
EsHandleClose(processHandle);
@ -2493,7 +2495,7 @@ void DesktopMessage(EsMessage *message) {
if (instance->application && (instance->application->permissions & APPLICATION_PERMISSION_ALL_FILES)
&& instance->processHandle && !instance->application->notified) {
message->registerFileSystem.rootDirectory = EsSyscall(ES_SYSCALL_NODE_SHARE, rootDirectory, instance->processHandle, 0, 0);
message->registerFileSystem.rootDirectory = EsSyscall(ES_SYSCALL_HANDLE_SHARE, rootDirectory, instance->processHandle, 0, 0);
EsMessagePostRemote(instance->processHandle, message);
if (instance->application->useSingleProcess) instance->application->notified = true;
}
@ -2518,6 +2520,7 @@ void DesktopMessage(EsMessage *message) {
}
} else if (message->type == ES_MSG_DEVICE_CONNECTED) {
desktop.connectedDevices.Add(message->device);
// TODO Propagate message.
} else if (message->type == ES_MSG_DEVICE_DISCONNECTED) {
for (uintptr_t i = 0; i < desktop.connectedDevices.Length(); i++) {
if (desktop.connectedDevices[i].id == message->device.id) {
@ -2526,6 +2529,8 @@ void DesktopMessage(EsMessage *message) {
break;
}
}
// TODO Propagate message.
} else if (message->type == ES_MSG_SET_SCREEN_RESOLUTION) {
if (desktop.setupDesktopUIComplete) {
DesktopSetup(); // Refresh desktop UI.

14
desktop/os.header
View File

@ -752,7 +752,6 @@ enum EsSyscallType {
ES_SYSCALL_MEMORY_ALLOCATE
ES_SYSCALL_MEMORY_FREE
ES_SYSCALL_MEMORY_SHARE
ES_SYSCALL_MEMORY_MAP_OBJECT
ES_SYSCALL_MEMORY_OPEN
ES_SYSCALL_MEMORY_COMMIT
@ -776,7 +775,6 @@ enum EsSyscallType {
ES_SYSCALL_PROCESS_OPEN
ES_SYSCALL_PROCESS_PAUSE
ES_SYSCALL_PROCESS_SET_TLS
ES_SYSCALL_PROCESS_SHARE
ES_SYSCALL_PROCESS_TERMINATE
ES_SYSCALL_SLEEP
ES_SYSCALL_THREAD_CREATE
@ -823,7 +821,6 @@ enum EsSyscallType {
ES_SYSCALL_NODE_OPEN
ES_SYSCALL_NODE_DELETE
ES_SYSCALL_NODE_MOVE
ES_SYSCALL_NODE_SHARE
ES_SYSCALL_FILE_READ_SYNC
ES_SYSCALL_FILE_WRITE_SYNC
ES_SYSCALL_FILE_RESIZE
@ -843,7 +840,6 @@ enum EsSyscallType {
// IPC.
ES_SYSCALL_CONSTANT_BUFFER_READ
ES_SYSCALL_CONSTANT_BUFFER_SHARE
ES_SYSCALL_CONSTANT_BUFFER_CREATE
ES_SYSCALL_PIPE_CREATE
ES_SYSCALL_PIPE_WRITE
@ -851,12 +847,13 @@ enum EsSyscallType {
// Misc.
ES_SYSCALL_PRINT
ES_SYSCALL_HANDLE_CLOSE
ES_SYSCALL_HANDLE_SHARE
ES_SYSCALL_BATCH
ES_SYSCALL_SHUTDOWN
ES_SYSCALL_POSIX
ES_SYSCALL_DEBUG_COMMAND
ES_SYSCALL_POSIX
ES_SYSCALL_PRINT
ES_SYSCALL_SHUTDOWN
ES_SYSCALL_SYSTEM_TAKE_SNAPSHOT
// End.
@ -1258,6 +1255,9 @@ struct EsMountPoint {
struct EsProcessCreationArguments {
EsHandle executable;
EsHandle *handles;
size_t handleCount;
const void *environmentBlock;
size_t environmentBlockBytes;

4
desktop/syscall.cpp
View File

@ -288,7 +288,7 @@ EsHandle EsMemoryOpen(size_t size, const char *name, ptrdiff_t nameLength, unsig
}
EsHandle EsMemoryShare(EsHandle sharedMemoryRegion, EsHandle targetProcess, bool readOnly) {
return EsSyscall(ES_SYSCALL_MEMORY_SHARE, sharedMemoryRegion, targetProcess, readOnly, 0);
return EsSyscall(ES_SYSCALL_HANDLE_SHARE, sharedMemoryRegion, targetProcess, readOnly, 0);
}
void *EsObjectMap(EsHandle sharedMemoryRegion, uintptr_t offset, size_t size, unsigned flags) {
@ -623,7 +623,7 @@ EsHandle EsProcessOpen(uint64_t pid) {
#ifndef KERNEL
EsHandle EsConstantBufferShare(EsHandle constantBuffer, EsHandle targetProcess) {
return EsSyscall(ES_SYSCALL_CONSTANT_BUFFER_SHARE, constantBuffer, targetProcess, 0, 0);
return EsSyscall(ES_SYSCALL_HANDLE_SHARE, constantBuffer, targetProcess, 0, 0);
}
EsHandle EsConstantBufferCreate(const void *data, size_t dataBytes, EsHandle targetProcess) {

2
drivers/esfs2.cpp
View File

@ -1,7 +1,7 @@
#include <module.h>
// Filesystem structures and constant definitions.
#include <util/esfs2.h>
#include <shared/esfs2.h>
// TODO Calling FSDirectoryEntryFound on all directory entries seen during scanning, even if they're not the target.
// TODO Informing the block cache when a directory is truncated and its extents are freed.

1
kernel/files.cpp
View File

@ -1899,6 +1899,7 @@ void FSRegisterBlockDevice(KBlockDevice *device) {
FSDetectFileSystem((KBlockDevice *) context);
}, (uintptr_t) device);
#endif
KDeviceSendConnectedMessage(device, ES_DEVICE_BLOCK);
}
void FSShutdown() {

1
kernel/module.h
View File

@ -220,7 +220,6 @@ enum KernelObjectType : uint32_t {
#endif
KERNEL_OBJECT_PIPE = 0x00000200, // A pipe through which data can be sent between processes, blocking when full or empty.
KERNEL_OBJECT_EMBEDDED_WINDOW = 0x00000400, // An embedded window object, referencing its container Window.
KERNEL_OBJECT_DIRECTORY_MONITOR = 0x00000100, // Monitors a directory, sending messages to the owner process.
KERNEL_OBJECT_EVENT_SINK = 0x00002000, // An event sink. Events can be forwarded to it, allowing waiting on many objects.
KERNEL_OBJECT_CONNECTION = 0x00004000, // A network connection.
KERNEL_OBJECT_DEVICE = 0x00008000, // A device.

53
kernel/syscall.cpp
View File

@ -720,17 +720,6 @@ SYSCALL_IMPLEMENT(ES_SYSCALL_MEMORY_MAP_OBJECT) {
SYSCALL_RETURN(0, false);
}
SYSCALL_IMPLEMENT(ES_SYSCALL_CONSTANT_BUFFER_SHARE) {
KObject buffer(currentProcess, argument0, KERNEL_OBJECT_CONSTANT_BUFFER);
CHECK_OBJECT(buffer);
ConstantBuffer *object = (ConstantBuffer *) buffer.object;
KObject process(currentProcess, argument1, KERNEL_OBJECT_PROCESS);
CHECK_OBJECT(process);
SYSCALL_RETURN(MakeConstantBuffer(object + 1, object->bytes, (Process *) process.object), false);
}
SYSCALL_IMPLEMENT(ES_SYSCALL_CONSTANT_BUFFER_CREATE) {
if (argument2 > SYSCALL_BUFFER_LIMIT) SYSCALL_RETURN(ES_FATAL_ERROR_INVALID_BUFFER, true);
SYSCALL_BUFFER(argument0, argument2, 1, false);
@ -741,38 +730,30 @@ SYSCALL_IMPLEMENT(ES_SYSCALL_CONSTANT_BUFFER_CREATE) {
SYSCALL_RETURN(MakeConstantBuffer((void *) argument0, argument2, (Process *) process.object), false);
}
SYSCALL_IMPLEMENT(ES_SYSCALL_MEMORY_SHARE) {
// TODO Sort out flags.
KObject _region(currentProcess, argument0, KERNEL_OBJECT_SHMEM);
CHECK_OBJECT(_region);
MMSharedRegion *region = (MMSharedRegion *) _region.object;
SYSCALL_IMPLEMENT(ES_SYSCALL_HANDLE_SHARE) {
KObject share(currentProcess, argument0, KERNEL_OBJECT_SHMEM | KERNEL_OBJECT_CONSTANT_BUFFER | KERNEL_OBJECT_PROCESS
| KERNEL_OBJECT_DEVICE | KERNEL_OBJECT_NODE | KERNEL_OBJECT_EVENT | KERNEL_OBJECT_PIPE);
CHECK_OBJECT(share);
KObject _process(currentProcess, argument1, KERNEL_OBJECT_PROCESS);
CHECK_OBJECT(_process);
Process *process = (Process *) _process.object;
uint32_t sharedFlags = share.flags;
OpenHandleToObject(region, KERNEL_OBJECT_SHMEM);
if (share.type == KERNEL_OBJECT_SHMEM) {
sharedFlags = argument2; // TODO Sort out flags.
} else if (share.type == KERNEL_OBJECT_NODE) {
sharedFlags = (argument2 & 1) && (share.flags & (ES_FILE_WRITE_SHARED | ES_FILE_WRITE)) ? ES_FILE_READ_SHARED : share.flags;
} else if (share.type == KERNEL_OBJECT_PIPE) {
// TODO Sort out flags.
}
SYSCALL_RETURN(process->handleTable.OpenHandle(region, argument2, KERNEL_OBJECT_SHMEM), false);
if (!OpenHandleToObject(share.object, share.type, sharedFlags)) {
SYSCALL_RETURN(ES_ERROR_PERMISSION_NOT_GRANTED, false);
} else {
SYSCALL_RETURN(process->handleTable.OpenHandle(share.object, sharedFlags, share.type), false);
}
}
#define SYSCALL_SHARE_OBJECT(syscallName, objectType, _sharedFlags) \
SYSCALL_IMPLEMENT(syscallName) { \
KObject share(currentProcess, argument0, objectType); \
CHECK_OBJECT(share); \
KObject _process(currentProcess, argument1, KERNEL_OBJECT_PROCESS); \
CHECK_OBJECT(_process); \
Process *process = (Process *) _process.object; \
uint32_t sharedFlags = _sharedFlags; \
if (!OpenHandleToObject(share.object, objectType, sharedFlags)) return ES_ERROR_PERMISSION_NOT_GRANTED; \
SYSCALL_RETURN(process->handleTable.OpenHandle(share.object, sharedFlags, objectType), false); \
}
SYSCALL_SHARE_OBJECT(ES_SYSCALL_PROCESS_SHARE, KERNEL_OBJECT_PROCESS, share.flags);
SYSCALL_SHARE_OBJECT(ES_SYSCALL_NODE_SHARE, KERNEL_OBJECT_NODE,
(argument3 & 1) && (share.flags & (ES_FILE_WRITE_SHARED | ES_FILE_WRITE)) ? ES_FILE_READ_SHARED : share.flags);
SYSCALL_IMPLEMENT(ES_SYSCALL_VOLUME_GET_INFORMATION) {
if (~currentProcess->permissions & ES_PERMISSION_GET_VOLUME_INFORMATION) {
SYSCALL_RETURN(0, false);

4
ports/lzma/LzmaDec.c
View File

@ -1228,11 +1228,7 @@ SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *sr
inSize -= inSizeCur;
*srcLen += inSizeCur;
outSizeCur = p->dicPos - dicPos;
#ifdef OS_ESSENCE
EsMemoryCopy(dest, p->dic + dicPos, outSizeCur);
#else
memcpy(dest, p->dic + dicPos, outSizeCur);
#endif
dest += outSizeCur;
outSize -= outSizeCur;
*destLen += outSizeCur;

52
util/esfs2.h → shared/esfs2.h
View File

@ -262,50 +262,6 @@ bool DecodeExtent(uint64_t *previousExtentStart, uint64_t *extentCount, uint8_t
#ifndef KERNEL
typedef struct ImportNode {
const char *name, *path;
struct ImportNode *children;
bool isFile;
} ImportNode;
ImportNode *ImportNodeFindChild(ImportNode *thisNode, const char *name) {
for (uintptr_t i = 0; i < arrlenu(thisNode->children); i++) {
if (0 == strcmp(thisNode->children[i].name, name)) {
return thisNode->children + i;
}
}
return NULL;
}
void ImportNodeAddFile(ImportNode *thisNode, const char *name, const char *path) {
assert(!ImportNodeFindChild(thisNode, name));
ImportNode node = {};
node.name = name;
node.path = path;
node.isFile = true;
arrput(thisNode->children, node);
}
ImportNode *ImportNodeMakeDirectory(ImportNode *thisNode, const char *name) {
assert(!ImportNodeFindChild(thisNode, name));
ImportNode node = {};
node.name = name;
arrput(thisNode->children, node);
return &arrlast(thisNode->children);
}
void ImportNodeRemoveChild(ImportNode *thisNode, const char *name) {
for (uintptr_t i = 0; i < arrlenu(thisNode->children); i++) {
if (0 == strcmp(thisNode->children[i].name, name)) {
arrdel(thisNode->children, i);
return;
}
}
assert(false);
}
uint64_t blockSize;
Superblock superblock;
GroupDescriptor *groupDescriptorTable;
@ -1007,6 +963,13 @@ void Read(char *target, DirectoryEntryReference parentDirectory) {
}
#endif
#ifndef INSTALLER
typedef struct ImportNode {
const char *name, *path;
struct ImportNode *children;
bool isFile;
} ImportNode;
uint64_t Import(ImportNode node, DirectoryEntryReference parentDirectory) {
uint64_t totalSize = 0;
@ -1047,6 +1010,7 @@ uint64_t Import(ImportNode node, DirectoryEntryReference parentDirectory) {
return totalSize;
}
#endif
void Format(uint64_t driveSize, const char *volumeName, EsUniqueIdentifier osInstallation,
void *kernel, size_t kernelBytes) {

23
util/build.c
View File

@ -374,7 +374,9 @@ void Build(bool enableOptimisations, bool compile) {
" &" /* don't block */);
#endif
Compile((enableOptimisations ? COMPILE_ENABLE_OPTIMISATIONS : 0) | (compile ? 0 : COMPILE_SKIP_COMPILE) | COMPILE_DO_BUILD | COMPILE_FOR_EMULATOR, 1024, NULL);
LoadOptions();
Compile((enableOptimisations ? COMPILE_ENABLE_OPTIMISATIONS : 0) | (compile ? 0 : COMPILE_SKIP_COMPILE) | COMPILE_DO_BUILD | COMPILE_FOR_EMULATOR,
atoi(GetOptionString("Emulator.PrimaryDriveMB")), NULL);
clock_gettime(CLOCK_REALTIME, &endTime);
@ -442,17 +444,29 @@ void Run(int emulator, int log, int debug) {
const char *audioFlags2 = withAudio ? "-soundhw pcspk,hda" : "";
unlink("bin/audio.wav");
const char *secondaryDriveMB = GetOptionString("Emulator.SecondaryDriveMB");
char secondaryDriveFlags[256];
if (secondaryDriveMB) {
CallSystemF("dd if=/dev/zero of=bin/drive2 bs=1048576 count=%d", atoi(secondaryDriveMB));
snprintf(secondaryDriveFlags, sizeof(secondaryDriveFlags),
"-drive file=bin/drive2,if=none,id=mydisk2,format=raw "
"-device nvme,drive=mydisk2,serial=1234 ");
} else {
secondaryDriveFlags[0] = 0;
}
const char *logFlags = log == LOG_VERBOSE ? "-d cpu_reset,int > bin/qemu_log.txt 2>&1"
: (log == LOG_NORMAL ? " > bin/qemu_log.txt 2>&1" : " > /dev/null 2>&1");
CallSystemF("%s %s qemu-system-x86_64 %s %s -m %d -s %s -smp cores=%d -cpu Haswell "
" -device qemu-xhci,id=xhci -device usb-kbd,bus=xhci.0,id=mykeyboard -device usb-mouse,bus=xhci.0,id=mymouse "
" -netdev user,id=u1 -device e1000,netdev=u1 -object filter-dump,id=f1,netdev=u1,file=bin/net.dat "
" %s %s %s %s ",
" %s %s %s %s %s ",
audioFlags, IsOptionEnabled("Emulator.RunWithSudo") ? "sudo " : "", driveFlags, cdromFlags,
atoi(GetOptionString("Emulator.MemoryMB")),
debug ? (debug == DEBUG_NONE ? "-enable-kvm" : "-S") : "",
atoi(GetOptionString("Emulator.Cores")), audioFlags2, logFlags, usbFlags, usbFlags2);
atoi(GetOptionString("Emulator.Cores")), audioFlags2, logFlags, usbFlags, usbFlags2, secondaryDriveFlags);
} break;
case EMULATOR_BOCHS: {
@ -1077,7 +1091,8 @@ void DoCommand(const char *l) {
} else if (0 == strcmp(l, "exit") || 0 == strcmp(l, "x") || 0 == strcmp(l, "quit") || 0 == strcmp(l, "q")) {
exit(0);
} else if (0 == strcmp(l, "compile") || 0 == strcmp(l, "c")) {
Compile(COMPILE_FOR_EMULATOR, 1024, NULL);
LoadOptions();
Compile(COMPILE_FOR_EMULATOR, atoi(GetOptionString("Emulator.PrimaryDriveMB")), NULL);
} else if (0 == strcmp(l, "build-cross")) {
BuildCrossCompiler();
SaveConfig();

2
util/build_common.h
View File

@ -301,6 +301,8 @@ Option options[] = {
{ "Emulator.Audio", OPTION_TYPE_BOOL, { .b = false } },
{ "Emulator.MemoryMB", OPTION_TYPE_STRING, { .s = "1024" } },
{ "Emulator.Cores", OPTION_TYPE_STRING, { .s = "1" } },
{ "Emulator.PrimaryDriveMB", OPTION_TYPE_STRING, { .s = "1024" } },
{ "Emulator.SecondaryDriveMB", OPTION_TYPE_STRING, { .s = NULL } },
{ "General.first_application", OPTION_TYPE_STRING, { .s = NULL } },
{ "General.wallpaper", OPTION_TYPE_STRING, { .s = NULL } },
};

5
util/build_core.c
View File

@ -129,7 +129,7 @@ File FileOpen(const char *path, char mode) {
#include "../shared/hash.cpp"
#include "build_common.h"
#include "esfs2.h"
#include "../shared/esfs2.h"
#include "header_generator.c"
// Toolchain flags:
@ -1159,6 +1159,8 @@ void Install(const char *driveFile, uint64_t partitionSize, const char *partitio
ImportNode root = {};
CreateImportNode("root", &root);
// TODO Update this.
#if 0
if (convertFonts) {
ImportNode *fontsFolder = ImportNodeMakeDirectory(ImportNodeFindChild(&root, "Essence"), "Fonts");
@ -1171,6 +1173,7 @@ void Install(const char *driveFile, uint64_t partitionSize, const char *partitio
}
}
}
#endif
MountVolume();
Import(root, superblock.root);