Libsys NPM | npm.io

libsys

Execute Linux/Mac syscalls from Node.js
Get memory address of Buffer, ArrayBuffer, TypedArray
Call arbitrary machine code from Node.js
Create machine code trampolines that will call Node.js functions

Installation

npm install libsys

Compiles on Linux, Mac and Windows (in WSL process).

Usage

Print Hello world to console

const libsys = require('libsys');

const STDOUT = 1;
const isMac = process.platform === 'darwin';
const SYS_write = isMac ? 0x2000004 : 1;
const buf = Buffer.from('Hello world\n');

libsys.syscall(SYS_write, STDOUT, buf, buf.length);

More goodies

libjs — POSIX command implementation (libc in JavaScript).
bamboo — Node.js clone in pure JavaScript.
jskernel — proposal of Node in kernel space.
Assembler.js — X86_64 assembler in JavaScript.

Reference

syscall — Executes system call with varied type arguments, returns 32-bit result
syscall64 — Executes system call with varied type arguments, return 64-bit result
syscall_N — Executes system call with N number arguments, returns 32-bit result
syscall64_N — Executes system call with N number arguments, returns 64-bit result
getAddressArrayBuffer — Returns 64-bit address of ArrayBuffer
getAddressTypedArray — Returns 64-bit address of TypedArray (including Uint8Array, etc..)
getAddressBuffer — Returns 64-bit address of Node's Buffer
getAddress — Returns 64-bit address of any buffer type
frame — Creates ArrayBuffer in the specified memory location
call — Calls machine code at specified address with up to 10 arguments, returns 32-bit result
call64 — Calls machine code at specified address with up to 10 arguments, returns 64-bit result
call_0 — Call machine code with no arguments
call_1
call64_0
call64_1
jumper
sigaction - Executes sigaction system call
cmpxchg8 - Compare and exchange value at memory location
cmpxchg16 - Compare and exchange value at memory location
cmpxchg32 - Compare and exchange value at memory location

Arguments

Different JavaScript types can be used as Targ argument in some functions. Here is how they are converted to 64-bit integers:

type Targ = number | [number, number] | [number, number, number] | string | ArrayBuffer | TypedArray | Buffer;

number is treated as 32-bit integer and gets extended to 64-bit integer;
[number, number] treated as a [lo, hi] tuple of two 32-bit integers, which are combined into 64-bit integer;
[number, number, number] treated as a [lo, hi, offset] tuple, same as above with the difference that offset is added to the resulting 64-bit integer;
string gets converted to C null-terminated string and 64-bit pointer created to the beginning of that string;
ArrayBuffer, TypedArray, Buffer 64-bit pointer to the beginning of data contents of those objects is created;

`syscall`

syscall(command: number, ...args: Targ[]): number;

syscall accepts up to 6 command arguments args. See discussion on Arguments above to see how JavaScript objects are converted to 64-bit integers.

syscall returns a number which is the result returned by the kernel, negative numbers usually represent an error.

`syscall64`

syscall64(command: number, ...args: TArg[]): [number, number];

Same as syscall, but returns 64-bit result.

`syscall_0`

syscall_0(command: number): number;
syscall_1(command: number, arg1: number): number;
syscall_2(command: number, arg1: number, arg2: number): number;
syscall_3(command: number, arg1: number, arg2: number, arg3: number): number;
syscall_4(command: number, arg1: number, arg2: number, arg3: number, arg4: number): number;
syscall_5(command: number, arg1: number, arg2: number, arg3: number, arg4: number, arg5: number): number;
syscall_6(command: number, arg1: number, arg2: number, arg3: number, arg4: number, arg5: number, arg6: number): number;

Executes system calls and returns 32-bit result. Expects all arguments to be of type number.

`syscall64_0`

syscall64_0(command: number): [number, number];
syscall64_1(command: number, arg1: number): [number, number];
syscall64_2(command: number, arg1: number, arg2: number): [number, number];
syscall64_3(command: number, arg1: number, arg2: number, arg3: number): [number, number];
syscall64_4(command: number, arg1: number, arg2: number, arg3: number, arg4: number): [number, number];
syscall64_5(command: number, arg1: number, arg2: number, arg3: number, arg4: number, arg5: number): [number, number];
syscall64_6(command: number, arg1: number, arg2: number, arg3: number, arg4: number, arg5: number, arg6: number): [number, number];

Executes system calls and returns 64-bit result. Expects all arguments to be of type number.

`getAddressArrayBuffer`

getAddressArrayBuffer(ab: ArrayBuffer): [number, number];

`getAddressTypedArray`

getAddressTypedArray(ta: TypedArray | Uint8Array): [number, number];

`getAddressBuffer`

getAddressBuffer(buf: Buffer): [number, number];

Return memory address of Buffer's data contents.

`getAddress`

getAddress(buffer: Buffer | ArrayBuffer | TypedArray): [number, number];

`frame`

frame(addresss: Targ, size: number): ArrayBuffer;

frame returns an ArrayBuffer object of size size that is mapped to memory location specified in addr argument.

`call`

call(address: Targ, offset?: number, arguments?: Targ[]);

Execute machine code at specified memory address address. The memory address is converted to function pointer and called using your architecture calling conventions. offest is added to the address, but defaults to 0.

Up to 10 arguments can be supplied.