System.h

Go to the documentation of this file.

/* ========================================
 
Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
 
File: System.h
Purpose: System Call Interface.
 
======================================== */
 
#ifndef LIBSYS_SYSTEM_CALLS_H
#define LIBSYS_SYSTEM_CALLS_H
 
#include <libSystem/SystemKit/Macros.h>

#define kPrintDevicePath "/devices/tty{}"
#define kCDDevicePath "/devices/dvd{}"
 
// ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------ //
 
struct REF_TYPE {
  UInt64  __hash;  
  VoidPtr __self;  
};
 
typedef REF_TYPE* Ref;
 
typedef Ref IORef;
typedef Ref FSRef;
typedef Ref DylibRef;
typedef Ref ThreadRef;
typedef Ref SocketRef;
typedef Ref NetworkRef;
typedef Ref MutexRef;
typedef Ref EventRef;
typedef Ref SemaphoreRef;
 
// ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------ //

IMPORT_C Ref LdrGetDylibSymbolFromHandle(_Input const Char* symbol, _Input Ref dll_handle);

IMPORT_C Ref LdrOpenDylibHandle(_Input const Char* path, _Input const Char* drive_letter);

IMPORT_C UInt32 LdrCloseDylibHandle(_Input Ref* dll_handle);
 
// ------------------------------------------------------------------------------------------ //
// File API.
// ------------------------------------------------------------------------------------------ //

IMPORT_C Ref IoOpenFile(const Char* fs_path, const Char* drive_letter);

IMPORT_C Void IoCloseFile(_Input Ref file_desc);

IMPORT_C SInt32 IoCtrlFile(_Input Ref file_desc, _Input UInt32 ioctl_code, _Input VoidPtr in_data,
                           _Output VoidPtr out_data);

IMPORT_C const Char* IoMimeFile(_Input Ref file_desc);

IMPORT_C const Char* IoDimFile(_Input Ref dir_desc);

IMPORT_C UInt32 IoWriteFile(_Input Ref file_desc, _Output VoidPtr out_data, UInt64 sz_data);

IMPORT_C UInt32 IoReadFile(_Input Ref file_desc, _Output VoidPtr* out_data, UInt64 sz_data);

IMPORT_C UInt64 IoRewindFile(_Input Ref file_desc);

IMPORT_C UInt64 IoTellFile(_Input Ref file_desc);

IMPORT_C UInt64 IoSeekFile(_Input Ref file_desc, UInt64 file_offset);
 
// ------------------------------------------------------------------------
// Process API.
// ------------------------------------------------------------------------

IMPORT_C UInt32 RtlSpawnIB(UIntPtr process_id);

IMPORT_C UIntPtr RtlSpawnProcess(const Char* process_path, UInt32 argc, Char** argv, Char** envp,
                                 UInt32 envp_len);

IMPORT_C Bool RtlExitProcess(UIntPtr handle, UIntPtr exit_code);
 
// ------------------------------------------------------------------------
// Memory Manager API.
// ------------------------------------------------------------------------

IMPORT_C VoidPtr MmCreateHeap(_Input UInt64 len, _Input UInt32 flags);

IMPORT_C SInt32 MmDestroyHeap(_Input VoidPtr heap);

IMPORT_C SInt32 MmSetHeapFlags(_Input VoidPtr heap, _Input UInt32 flags);

IMPORT_C UInt32 MmGetHeapFlags(_Input VoidPtr heap);

IMPORT_C UInt32 MmFillCRC32Heap(_Input VoidPtr heap);

IMPORT_C VoidPtr MmCopyMemory(_Input VoidPtr dest, _Input VoidPtr src, _Input UInt64 len);

IMPORT_C SInt64 MmCmpMemory(_Input VoidPtr dest, _Input VoidPtr src, _Input UInt64 len);

IMPORT_C VoidPtr MmFillMemory(_Input VoidPtr dest, _Input UInt64 len, _Input UInt8 value);

IMPORT_C SInt64 MmStrCmp(_Input const Char* dest, _Input const Char* src);

IMPORT_C SInt64 MmStrLen(const Char* str);
 
// ------------------------------------------------------------------------
// @brief Error API.
// ------------------------------------------------------------------------
 
IMPORT_C SInt32 ErrGetLastError(Void);
 
// ------------------------------------------------------------------------
// @brief Threading API.
// ------------------------------------------------------------------------

IMPORT_C SInt32 ThrExitCurrentThread(_Input SInt32 exit_code);

IMPORT_C SInt32 ThrExitMainThread(_Input SInt32 exit_code);

IMPORT_C SInt32 ThrExitThread(_Input ThreadRef thread, _Input SInt32 exit_code);

typedef SInt32 (*ThrProcKind)(SInt32 argc, Char** argv);

IMPORT_C ThreadRef ThrCreateThread(const Char* thread_name, ThrProcKind procedure,
                                   SInt32 argument_count, SInt32 flags);

IMPORT_C SInt32 ThrYieldThread(ThreadRef thrd);

IMPORT_C SInt32 ThrJoinThread(ThreadRef thrd);

IMPORT_C SInt32 ThrDetachThread(ThreadRef thrd);
 
// ------------------------------------------------------------------------
// @brief Drive Management API.
// ------------------------------------------------------------------------
 
// ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------ //
IMPORT_C Char* DrvGetDefaultDriveLetter(Void);
 
// ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------ //
IMPORT_C Char* DrvGetDriveLetterFromPath(_Input const Char* path);
 
// ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------ //
IMPORT_C Ref DrvGetMountedDrive(_Input Char letter);
 
// ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------ //
IMPORT_C Void DrvMountDrive(_Input const Char* path, _Input const Char* letter);
 
// ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------ //
IMPORT_C Void DrvUnmountDrive(_Input Char letter);
 
// ------------------------------------------------------------------------
// Event handling API, use to listen to OS specific events.
// ------------------------------------------------------------------------
 
// ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------ //
 
IMPORT_C Void EvtAddListener(_Input const Char* event_name, _Input Ref listener);
 
// ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------ //
 
IMPORT_C Void EvtRemoveListener(_Input const Char* event_name, _Input Ref listener);
 
// ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------ //
 
IMPORT_C VoidPtr EvtDispatchEvent(_Input const Char* event_name, _Input VoidPtr event_data);
 
// ------------------------------------------------------------------------------------------ //
// Power API.
// ------------------------------------------------------------------------------------------ //
 
enum {
  kPowerCodeInvalid  = 0,
  kPowerCodeShutdown = 12,
  kPowerCodeReboot,
  kPowerCodeSleep,
  kPowerCodeWake,
  kPowerCodeCount,
};
 
IMPORT_C SInt32 PwrReadCode(_Output SInt32& code);
 
IMPORT_C SInt32 PwrSendCode(_Output SInt32& code);
 
// ------------------------------------------------------------------------------------------ //
// CD-ROM API.
// ------------------------------------------------------------------------------------------ //
 
IMPORT_C IORef CdOpenTray(Void);
 
IMPORT_C SInt32 CdEjectDrive(_Input IORef cdrom);
 
IMPORT_C SInt32 CdCloseTray(Void);
 
// ------------------------------------------------------------------------------------------ //
// TTY API.
// ------------------------------------------------------------------------------------------ //
 
IMPORT_C SInt32 PrintOut(IORef file /* nullptr to direct to stdout */, const Char* fmt, ...);
 
IMPORT_C SInt32 PrintIn(IORef file /* nullptr to direct to stdout */, const Char* fmt, ...);
 
IMPORT_C IORef PrintCreate(Void);
 
IMPORT_C SInt32 PrintRelease(IORef);
 
IMPORT_C IORef PrintGet(const Char* path);
 
// ------------------------------------------------------------------------------------------ //
// @brief Scheduler/Debug API.
// ------------------------------------------------------------------------------------------ //
 
typedef SInt32 AffinityRef;
typedef UInt64 ProcessRef;
 
IMPORT_C SInt32 SchedSetAffinity(_Input ProcessRef, SInt32 req, _Input AffinityRef*);
 
IMPORT_C SInt32 SchedGetAffinity(_Input ProcessRef, _InOut AffinityRef*);
 
IMPORT_C SInt32 SchedFireSignal(_Input ProcessRef, SInt32);
 
IMPORT_C SInt32 SchedReadMemory(_Input ProcessRef, SInt32, SInt32);
 
IMPORT_C SInt32 SchedWriteMemory(_Input ProcessRef, SInt32, SInt32);
 
IMPORT_C UIntPtr SchedGetCurrentProcessID(Void);
 
// ------------------------------------------------------------------------------------------ //
// @brief Filesystem API.
// ------------------------------------------------------------------------------------------ //
 
IMPORT_C BOOL FsCopy(const Char* path, const Char* dst);
 
IMPORT_C BOOL FsMove(const Char* path, const Char* dst);
 
IMPORT_C BOOL FsExists(const Char* path);
 
IMPORT_C BOOL FsCreateDir(const Char* path);
 
IMPORT_C BOOL FsCreateFile(const Char* path);
 
IMPORT_C BOOL FsCreateAlias(const Char* path, const Char* from);
 
// ------------------------------------------------------------------------------------------ //
// @brief Installable Filesystem API.
// ------------------------------------------------------------------------------------------ //
 
IMPORT_C BOOL IfsMount(const Char* path, const Char* drive_letter);
 
IMPORT_C BOOL IfsUnmount(const Char* drive_letter);
 
IMPORT_C BOOL IfsIsMounted(const Char* drive_letter);
 
// ------------------------------------------------------------------------------------------ //
// @brief String Manip API.
// ------------------------------------------------------------------------------------------ //
 
IMPORT_C Char* StrFmt(const Char* fmt, ...);
 
IMPORT_C UInt64 StrMathToNumber(const Char* in, const Char** endp, const SInt16 base);
 
#endif  // ifndef LIBSYS_SYSTEM_CALLS_H