@k13engineering/linux-dmabuf-allocator 0.0.1 → 0.0.3

package/dist/lib/allocation-size.d.ts

@@ -0,0 +1,8 @@
+declare const createDefaultAllocationSizeDeterminer: ({ pageSize }: {
+    pageSize: number;
+}) => {
+    determineOptimalAllocationSize: ({ minimumSize }: {
+        minimumSize: number;
+    }) => number;
+};
+export { createDefaultAllocationSizeDeterminer };

package/dist/lib/allocation-size.js

@@ -0,0 +1,15 @@
+const createDefaultAllocationSizeDeterminer = ({ pageSize }/*: { pageSize: number }*/) => {
+
+  const determineOptimalAllocationSize = ({ minimumSize }/*: { minimumSize: number }*/)/*: number*/ => {
+    const pagesNeeded = Math.ceil(minimumSize / pageSize);
+    return pagesNeeded * pageSize;
+  };
+
+  return {
+    determineOptimalAllocationSize
+  };
+};
+
+export {
+  createDefaultAllocationSizeDeterminer
+};

package/dist/lib/dmabuf-allocator-interface.d.ts

@@ -0,0 +1,18 @@
+type TDmabufAllocateArgs = {
+    size: number;
+};
+type TDmabufAllocateResult = {
+    error: Error;
+    dmabufFd: undefined;
+} | {
+    error: undefined;
+    dmabufFd: number;
+};
+type TDmabufAllocator = {
+    allocate: (args: TDmabufAllocateArgs) => TDmabufAllocateResult;
+    pageSize: number;
+    determineOptimalAllocationSize: (args: {
+        minimumSize: number;
+    }) => number;
+};
+export type { TDmabufAllocator };

package/dist/lib/dmabuf-allocator-interface.js

@@ -0,0 +1,23 @@
+/* c8 ignore start */
+/*type TDmabufAllocateArgs = {
+  size: number;
+};*/
+
+/*type TDmabufAllocateResult = {
+  error: Error;
+  dmabufFd: undefined;
+} | {
+  error: undefined;
+  dmabufFd: number;
+};*/
+
+/*type TDmabufAllocator = {
+  allocate: (args: TDmabufAllocateArgs) => TDmabufAllocateResult;
+  pageSize: number;
+  determineOptimalAllocationSize: (args: { minimumSize: number }) => number;
+};*/
+
+/*export type {
+  TDmabufAllocator
+};*/
+/* c8 ignore end */

package/dist/lib/dmabuf-heap/dmabuf-heap-ioctl.d.ts

@@ -0,0 +1,19 @@
+import type { TDmabufHeapIoctlKernelInterface } from "../kernel-interface.js";
+type TDmabufHeapIoctlAllocateResult = {
+    errno: undefined;
+    dmabufFd: number;
+} | {
+    errno: number;
+    dmabufFd: undefined;
+};
+declare const createDmabufHeapIoctls: ({ kernelIoctlInterface }: {
+    kernelIoctlInterface: TDmabufHeapIoctlKernelInterface;
+}) => {
+    dmabufHeapIoctlAllocate: ({ dmabufHeapFd, size, fdFlags, heapFlags }: {
+        dmabufHeapFd: number;
+        size: number;
+        fdFlags: bigint;
+        heapFlags: bigint;
+    }) => TDmabufHeapIoctlAllocateResult;
+};
+export { createDmabufHeapIoctls };

package/dist/lib/dmabuf-heap/dmabuf-heap-ioctl.js

@@ -0,0 +1,97 @@
+import { endianBufferViewFor } from "../endian-buffer.js";
+/*import type { TDmabufHeapIoctlKernelInterface } from "../kernel-interface.ts";*/
+
+/*type TDmabufHeapIoctlAllocateResult = {
+  errno: undefined;
+  dmabufFd: number;
+} | {
+  errno: number;
+  dmabufFd: undefined;
+};*/
+
+const formatAllocationData = ({
+  endianness,
+  len,
+  fdFlags,
+  heapFlags
+}/*: {
+  endianness: TDmabufHeapIoctlKernelInterface["endianness"];
+  len: number;
+  fdFlags: bigint;
+  heapFlags: bigint;
+}*/) => {
+
+  const allocationData = new Uint8Array(24);
+
+  const view = endianBufferViewFor({ buffer: allocationData, endianness });
+
+  // struct dma_heap_allocation_data {
+  //   __u64 len
+  view.writeU64({ offset: 0, value: BigInt(len) });
+  //   __u32 fd
+  view.writeU32({ offset: 8, value: 0 });
+  //   __u32 fd_flags
+  view.writeU32({ offset: 12, value: Number(fdFlags) });
+  //   __u64 heap_flags
+  view.writeU64({ offset: 16, value: heapFlags });
+  // }
+
+  return allocationData;
+};
+
+const DMA_HEAP_IOCTL_ALLOC = BigInt(0xc0184800);
+
+const createDmabufHeapIoctls = ({
+  kernelIoctlInterface
+}/*: {
+  kernelIoctlInterface: TDmabufHeapIoctlKernelInterface
+}*/) => {
+  const dmabufHeapIoctlAllocate = ({
+    dmabufHeapFd,
+    size,
+    fdFlags,
+    heapFlags
+  }/*: {
+    dmabufHeapFd: number;
+    size: number;
+    fdFlags: bigint;
+    heapFlags: bigint;
+  }*/)/*: TDmabufHeapIoctlAllocateResult*/ => {
+
+    const allocationData = formatAllocationData({
+      endianness: kernelIoctlInterface.endianness,
+      len: size,
+      fdFlags,
+      heapFlags
+    });
+
+    const { errno } = kernelIoctlInterface.ioctl({
+      fd: dmabufHeapFd,
+      request: DMA_HEAP_IOCTL_ALLOC,
+      arg: allocationData
+    });
+
+    if (errno !== undefined) {
+      return {
+        errno,
+        dmabufFd: undefined
+      };
+    }
+
+    const view = endianBufferViewFor({ buffer: allocationData, endianness: kernelIoctlInterface.endianness });
+    const dmabufFd = view.readU32({ offset: 8 });
+
+    return {
+      errno: undefined,
+      dmabufFd
+    };
+  };
+
+  return {
+    dmabufHeapIoctlAllocate
+  };
+};
+
+export {
+  createDmabufHeapIoctls
+};

package/dist/lib/dmabuf-heap/dmabuf-heap-manager.d.ts

@@ -0,0 +1,42 @@
+import { type TDmabufHeap } from "./dmabuf-heap.js";
+import type { TDmabufHeapKernelInterface } from "../kernel-interface.js";
+declare const findDefaultDmabufHeapDevFolder: () => string;
+type TDmabufHeapInfo = {
+    name: string;
+    properties: {
+        physicalMemory: {
+            contiguous: boolean | undefined;
+        };
+        cachable: boolean | undefined;
+        protected: boolean | undefined;
+    };
+};
+type TDmabufHeapPropertySpecification = "required" | "preferred" | "optional" | "forbidden";
+type TDmabufHeapSpecification = {
+    physicalMemory: {
+        contiguous: TDmabufHeapPropertySpecification;
+    };
+    cachable: TDmabufHeapPropertySpecification;
+    protected: TDmabufHeapPropertySpecification;
+};
+declare const createDmabufHeapManager: ({ dmabufHeapDevFolder, kernelInterface }: {
+    dmabufHeapDevFolder: string;
+    kernelInterface: TDmabufHeapKernelInterface;
+}) => {
+    findAvailableDmabufHeapInfos: () => TDmabufHeapInfo[];
+    findDmabufHeapInfosBySpecification: ({ specification }: {
+        specification: TDmabufHeapSpecification;
+    }) => any;
+    openDmabufHeapByName: ({ name }: {
+        name: string;
+    }) => {
+        error: Error;
+        dmabufHeap: undefined;
+    } | {
+        error: undefined;
+        dmabufHeap: TDmabufHeap;
+    };
+};
+type TDmabufHeapManager = ReturnType<typeof createDmabufHeapManager>;
+export { findDefaultDmabufHeapDevFolder, createDmabufHeapManager };
+export type { TDmabufHeapManager, };

package/dist/lib/dmabuf-heap/dmabuf-heap-manager.js

@@ -0,0 +1,215 @@
+import { createDmabufHeapFactory, /*type TDmabufHeap */} from "./dmabuf-heap.js";
+/*import type { TDmabufHeapKernelInterface } from "../kernel-interface.ts";*/
+
+const findDefaultDmabufHeapDevFolder = ()/*: string*/ => {
+  return "/dev/dma_heap";
+};
+
+/*type TDmabufHeapInfo = {
+  name: string;
+  properties: {
+    physicalMemory: {
+      contiguous: boolean | undefined;
+    },
+    cachable: boolean | undefined;
+    protected: boolean | undefined;
+  }
+};*/
+
+/*type TDmabufHeapPropertySpecification = "required" | "preferred" | "optional" | "forbidden";*/
+/*type TDmabufHeapSpecification = {
+  physicalMemory: {
+    contiguous: TDmabufHeapPropertySpecification;
+  },
+  cachable: TDmabufHeapPropertySpecification;
+  protected: TDmabufHeapPropertySpecification;
+};*/
+
+const wellKnownHeapPropertiesByName/*: { [key: string]: TDmabufHeapInfo["properties"] }*/ = {
+  // eslint-disable-next-line quote-props
+  "system": {
+    physicalMemory: {
+      contiguous: false
+    },
+    cachable: true,
+    protected: false
+  },
+  // eslint-disable-next-line quote-props
+  "default_cma_region": {
+    physicalMemory: {
+      contiguous: true
+    },
+    cachable: true,
+    protected: false
+  }
+};
+
+const heapInfoByName = ({ name }/*: { name: string }*/)/*: TDmabufHeapInfo*/ => {
+  const wellKnownProperties = wellKnownHeapPropertiesByName[name];
+  if (wellKnownProperties === undefined) {
+    return {
+      name,
+      properties: {
+        physicalMemory: {
+          contiguous: undefined
+        },
+        cachable: undefined,
+        protected: undefined
+      }
+    };
+  }
+
+  return {
+    name,
+    properties: wellKnownProperties
+  };
+};
+
+const createDmabufHeapManager = ({
+  dmabufHeapDevFolder,
+  kernelInterface
+}/*: {
+  dmabufHeapDevFolder: string,
+  kernelInterface: TDmabufHeapKernelInterface
+}*/) => {
+
+  const heapFactory = createDmabufHeapFactory({ kernelInterface });
+
+  const findAvailableDmabufHeapInfos = ()/*: TDmabufHeapInfo[]*/ => {
+    const { errno, entries } = kernelInterface.readdir({ path: dmabufHeapDevFolder });
+    if (errno !== undefined) {
+      throw Error(`failed to read dmabuf heap dev folder ${dmabufHeapDevFolder}, errno ${errno}`);
+    }
+
+    const infos = entries.map((entryName) => {
+      return heapInfoByName({ name: entryName });
+    });
+
+    return infos;
+  };
+
+  try {
+    findAvailableDmabufHeapInfos();
+  } catch (ex) {
+    throw Error("valid dmabuf heap dev folder required to create dmabuf heap manager, look before you leap", { cause: ex });
+  }
+
+  const findDmabufHeapInfosBySpecification = ({
+    specification
+  }/*: {
+    specification: TDmabufHeapSpecification
+  }*/) => {
+    const availableHeaps = findAvailableDmabufHeapInfos();
+
+    // eslint-disable-next-line complexity, max-statements
+    const matchingHeaps = availableHeaps.filter((heapInfo) => {
+      const props = heapInfo.properties;
+
+      // physicalMemory.contiguous
+      const contiguousSpec = specification.physicalMemory.contiguous;
+      if (contiguousSpec === "required" && props.physicalMemory.contiguous !== true) {
+        return false;
+      }
+      if (contiguousSpec === "forbidden" && props.physicalMemory.contiguous === true) {
+        return false;
+      }
+
+      // cachable
+      const cachableSpec = specification.cachable;
+      if (cachableSpec === "required" && props.cachable !== true) {
+        return false;
+      }
+      if (cachableSpec === "forbidden" && props.cachable === true) {
+        return false;
+      }
+
+      // protected
+      const protectedSpec = specification.protected;
+      if (protectedSpec === "required" && props.protected !== true) {
+        return false;
+      }
+      if (protectedSpec === "forbidden" && props.protected === true) {
+        return false;
+      }
+
+      return true;
+    });
+
+    return matchingHeaps;
+  };
+
+  /*type TOpenByNameResult = {
+    error: Error,
+    dmabufHeap: undefined
+  } | {
+    error: undefined,
+    dmabufHeap: TDmabufHeap
+  };*/
+
+  const O_RDWR = 0x02;
+  const O_CLOEXEC = 0x80000;
+
+  const ENOENT = 2;
+  const EACCES = 13;
+
+  const createOpenErrorByErrno = ({ errno, dmabufHeapPath }/*: { errno: number, dmabufHeapPath: string }*/)/*: Error*/ => {
+
+    if (errno === ENOENT) {
+      return Error(`dmabuf heap at "${dmabufHeapPath}" does not exist`);
+    }
+
+    if (errno === EACCES) {
+      return Error(`permission denied opening dmabuf heap at "${dmabufHeapPath}", your process may lack required privileges`);
+    }
+
+    return Error(`open dmabuf heap at "${dmabufHeapPath}" failed, errno ${errno}`);
+  };
+
+  const openDmabufHeapByName = ({ name }/*: { name: string }*/)/*: TOpenByNameResult*/ => {
+
+    const dmabufHeapPath = `${dmabufHeapDevFolder}/${name}`;
+
+    const { errno: openErrno, fd: dmabufHeapFd } = kernelInterface.open({
+      path: dmabufHeapPath,
+      flags: O_RDWR | O_CLOEXEC
+    });
+
+    if (openErrno !== undefined) {
+      return {
+        error: createOpenErrorByErrno({ errno: openErrno, dmabufHeapPath }),
+        dmabufHeap: undefined
+      };
+    }
+
+    try {
+      const dmabufHeap = heapFactory.openDmabufHeapAllocatorByDuppingFd({
+        dmabufHeapFd
+      });
+
+      return {
+        error: undefined,
+        dmabufHeap
+      };
+    } finally {
+      kernelInterface.close({ fd: dmabufHeapFd });
+    }
+
+  };
+
+  return {
+    findAvailableDmabufHeapInfos,
+    findDmabufHeapInfosBySpecification,
+    openDmabufHeapByName
+  };
+};
+
+/*type TDmabufHeapManager = ReturnType<typeof createDmabufHeapManager>;*/
+
+export {
+  findDefaultDmabufHeapDevFolder,
+  createDmabufHeapManager
+};
+
+/*export type {
+  TDmabufHeapManager,
+};*/

package/dist/lib/dmabuf-heap/dmabuf-heap.d.ts

@@ -0,0 +1,15 @@
+import type { TDmabufAllocator } from "../dmabuf-allocator-interface.js";
+import type { TDmabufHeapAllocatorKernelInterface } from "../kernel-interface.js";
+type TDmabufHeap = TDmabufAllocator & {
+    dupHeapFd: () => number;
+    close: () => void;
+};
+declare const createDmabufHeapFactory: ({ kernelInterface }: {
+    kernelInterface: TDmabufHeapAllocatorKernelInterface;
+}) => {
+    openDmabufHeapAllocatorByDuppingFd: ({ dmabufHeapFd: providedDmabufHeapFd }: {
+        dmabufHeapFd: number;
+    }) => TDmabufHeap;
+};
+export { createDmabufHeapFactory };
+export type { TDmabufHeap };

package/dist/lib/dmabuf-heap/dmabuf-heap.js

@@ -0,0 +1,84 @@
+/*import type { TDmabufAllocator } from "../dmabuf-allocator-interface.ts";*/
+import { createDefaultAllocationSizeDeterminer } from "../allocation-size.js";
+import { createDmabufHeapIoctls } from "./dmabuf-heap-ioctl.js";
+/*import type { TDmabufHeapAllocatorKernelInterface } from "../kernel-interface.ts";*/
+// import nodeFs from "node:fs";
+
+/*type TDmabufHeap = TDmabufAllocator & {
+  dupHeapFd: () => number;
+  close: () => void;
+};*/
+
+const O_RDWR = BigInt(0x02);
+const O_CLOEXEC = BigInt(0x80000);
+
+const createDmabufHeapFactory = ({ kernelInterface }/*: { kernelInterface: TDmabufHeapAllocatorKernelInterface }*/) => {
+  const openDmabufHeapAllocatorByDuppingFd = ({
+    dmabufHeapFd: providedDmabufHeapFd
+  }/*: {
+    dmabufHeapFd: number
+  }*/)/*: TDmabufHeap*/ => {
+
+    const dmabufHeapFd = kernelInterface.dup({ fd: providedDmabufHeapFd });
+    const pageSize = kernelInterface.determinePageSize();
+
+    const allocationSizeDeterminer = createDefaultAllocationSizeDeterminer({ pageSize });
+
+    const { dmabufHeapIoctlAllocate } = createDmabufHeapIoctls({ kernelIoctlInterface: kernelInterface });
+
+    const determineOptimalAllocationSize/*: TDmabufHeap["determineOptimalAllocationSize"]*/ = ({ minimumSize }) => {
+      return allocationSizeDeterminer.determineOptimalAllocationSize({ minimumSize });
+    };
+
+    const allocate/*: TDmabufHeap["allocate"]*/ = ({ size }) => {
+
+      const { errno: allocateErrno, dmabufFd } = dmabufHeapIoctlAllocate({
+        dmabufHeapFd,
+        fdFlags: O_RDWR | O_CLOEXEC,
+        heapFlags: BigInt(0),
+        size
+      });
+
+      if (allocateErrno !== undefined) {
+        return {
+          // TODO: better
+          error: Error(`dmabuf heap allocation failed with errno ${allocateErrno}`),
+          handle: undefined
+        };
+      }
+
+      return {
+        error: undefined,
+        dmabufFd
+      };
+    };
+
+    const dupHeapFd/*: TDmabufHeap["dupHeapFd"]*/ = () => {
+      return kernelInterface.dup({ fd: dmabufHeapFd });
+    };
+
+    const close = () => {
+      kernelInterface.close({ fd: dmabufHeapFd });
+    };
+
+    return {
+      allocate,
+      pageSize,
+      determineOptimalAllocationSize,
+      dupHeapFd,
+      close
+    };
+  };
+
+  return {
+    openDmabufHeapAllocatorByDuppingFd
+  };
+};
+
+export {
+  createDmabufHeapFactory
+};
+
+/*export type {
+  TDmabufHeap
+};*/

package/dist/lib/dmabuf-heap/index.d.ts

@@ -0,0 +1,3 @@
+import { type TDmabufHeapManager } from "./dmabuf-heap-manager.js";
+declare const createDefaultDmabufHeapManager: () => TDmabufHeapManager;
+export { createDefaultDmabufHeapManager, };

package/dist/lib/dmabuf-heap/index.js

@@ -0,0 +1,19 @@
+import { createDmabufHeapManager, findDefaultDmabufHeapDevFolder, /*type TDmabufHeapManager */} from "./dmabuf-heap-manager.js";
+import { createDefaultDmabufHeapAllocatorLinuxInterface } from "../kernel-interface-impl-linux.js";
+
+const createDefaultDmabufHeapManager = ()/*: TDmabufHeapManager*/ => {
+  const dmabufHeapDevFolder = findDefaultDmabufHeapDevFolder();
+  const kernelInterface = createDefaultDmabufHeapAllocatorLinuxInterface();
+
+
+  const dmabufHeapManager = createDmabufHeapManager({
+    dmabufHeapDevFolder,
+    kernelInterface
+  });
+
+  return dmabufHeapManager;
+};
+
+export {
+  createDefaultDmabufHeapManager,
+};

package/dist/lib/endian-buffer.d.ts

@@ -0,0 +1,54 @@
+type TEndianness = "LE" | "BE";
+declare const endianBufferViewFor: ({ buffer, endianness }: {
+    buffer: Uint8Array;
+    endianness: TEndianness;
+}) => {
+    readU16: ({ offset }: {
+        offset: number;
+    }) => any;
+    readU32: ({ offset }: {
+        offset: number;
+    }) => any;
+    readU64: ({ offset }: {
+        offset: number;
+    }) => any;
+    writeU16: ({ offset, value }: {
+        offset: number;
+        value: number;
+    }) => void;
+    writeU32: ({ offset, value }: {
+        offset: number;
+        value: number;
+    }) => void;
+    writeU64: ({ offset, value }: {
+        offset: number;
+        value: bigint;
+    }) => void;
+};
+declare const hostEndianBufferViewFor: ({ buffer }: {
+    buffer: Uint8Array;
+}) => {
+    readU16: ({ offset }: {
+        offset: number;
+    }) => any;
+    readU32: ({ offset }: {
+        offset: number;
+    }) => any;
+    readU64: ({ offset }: {
+        offset: number;
+    }) => any;
+    writeU16: ({ offset, value }: {
+        offset: number;
+        value: number;
+    }) => void;
+    writeU32: ({ offset, value }: {
+        offset: number;
+        value: number;
+    }) => void;
+    writeU64: ({ offset, value }: {
+        offset: number;
+        value: bigint;
+    }) => void;
+};
+export { endianBufferViewFor, hostEndianBufferViewFor };
+export type { TEndianness };

package/dist/lib/endian-buffer.js

@@ -0,0 +1,59 @@
+import nodeOs from "node:os";
+
+/*type TEndianness = "LE" | "BE";*/
+
+const endianBufferViewFor = ({ buffer, endianness }/*: { buffer: Uint8Array, endianness: TEndianness }*/) => {
+  const dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+
+  const isLittleEndian = endianness === "LE";
+
+  const readU16 = ({ offset }/*: { offset: number }*/) => {
+    return dataView.getUint16(offset, isLittleEndian);
+  };
+
+  const readU32 = ({ offset }/*: { offset: number }*/) => {
+    return dataView.getUint32(offset, isLittleEndian);
+  };
+
+  const readU64 = ({ offset }/*: { offset: number }*/) => {
+    return dataView.getBigUint64(offset, isLittleEndian);
+  };
+
+  const writeU16 = ({ offset, value }/*: { offset: number, value: number }*/) => {
+    dataView.setUint16(offset, value, isLittleEndian);
+  };
+
+  const writeU32 = ({ offset, value }/*: { offset: number, value: number }*/) => {
+    dataView.setUint32(offset, value, isLittleEndian);
+  };
+
+  const writeU64 = ({ offset, value }/*: { offset: number, value: bigint }*/) => {
+    dataView.setBigUint64(offset, value, isLittleEndian);
+  };
+
+  return {
+    readU16,
+    readU32,
+    readU64,
+    writeU16,
+    writeU32,
+    writeU64
+  };
+};
+
+const determineSystemEndianness = ()/*: TEndianness*/ => {
+  return nodeOs.endianness();
+};
+
+const hostEndianBufferViewFor = ({ buffer }/*: { buffer: Uint8Array }*/) => {
+  return endianBufferViewFor({ buffer, endianness: determineSystemEndianness() });
+};
+
+export {
+  endianBufferViewFor,
+  hostEndianBufferViewFor
+};
+
+/*export type {
+  TEndianness
+};*/

package/dist/lib/index.d.ts

@@ -0,0 +1,2 @@
+import { createDefaultDmabufHeapManager } from "./dmabuf-heap/index.js";
+export { createDefaultDmabufHeapManager };

package/dist/lib/index.js

@@ -0,0 +1,5 @@
+import { createDefaultDmabufHeapManager } from "./dmabuf-heap/index.js";
+
+export {
+  createDefaultDmabufHeapManager
+};

package/dist/lib/kernel-interface-impl-linux.d.ts

@@ -0,0 +1,3 @@
+import type { TDmabufHeapKernelInterface } from "./kernel-interface.js";
+declare const createDefaultDmabufHeapAllocatorLinuxInterface: () => TDmabufHeapKernelInterface;
+export { createDefaultDmabufHeapAllocatorLinuxInterface };

package/dist/lib/kernel-interface-impl-linux.js

@@ -0,0 +1,75 @@
+/*import type { TDmabufHeapKernelInterface } from "./kernel-interface.ts";*/
+import { ioctl as nativeIoctl } from "@k13engineering/po6-ioctl";
+import nodeFs from "node:fs";
+import nodeOs from "node:os";
+import { syscall, syscallNumbers } from "syscall-napi";
+
+const createDefaultDmabufHeapAllocatorLinuxInterface = ()/*: TDmabufHeapKernelInterface*/ => {
+
+  /*type C = TDmabufHeapKernelInterface;*/
+
+  const endianness = nodeOs.endianness();
+
+  const determinePageSize/*: C["determinePageSize"]*/ = () => {
+    // TODO: get from system
+    return 4096;
+  };
+
+  const ioctl/*: C["ioctl"]*/ = ({ fd, request, arg }) => {
+    const { errno } = nativeIoctl({ fd, request, arg });
+    return { errno };
+  };
+
+  const dup = ({ fd }/*: { fd: number }*/)/*: number*/ => {
+    const { errno, ret: newFd } = syscall({
+      syscallNumber: syscallNumbers.dup,
+      args: [
+        BigInt(fd)
+      ]
+    });
+
+    if (errno !== undefined) {
+      throw Error(`dup failed with errno ${errno}`);
+    }
+
+    return Number(newFd);
+  };
+
+  const readdir/*: C["readdir"]*/ = ({ path }) => {
+    try {
+      const entries = nodeFs.readdirSync(path);
+      return { errno: undefined, entries };
+    } catch (ex) {
+      const err = ex /*as NodeJS.ErrnoException*/;
+      return { errno: -err.errno/*!*/, entries: undefined };
+    }
+  };
+
+  const open/*: C["open"]*/ = ({ path, flags }) => {
+    try {
+      const fd = nodeFs.openSync(path, flags);
+      return { errno: undefined, fd };
+    } catch (ex) {
+      const err = ex /*as NodeJS.ErrnoException*/;
+      return { errno: -err.errno/*!*/, fd: undefined };
+    }
+  };
+
+  const close/*: C["close"]*/ = ({ fd }) => {
+    nodeFs.closeSync(fd);
+  };
+
+  return {
+    endianness,
+    determinePageSize,
+    ioctl,
+    dup,
+    readdir,
+    open,
+    close
+  };
+};
+
+export {
+  createDefaultDmabufHeapAllocatorLinuxInterface
+};

package/dist/lib/kernel-interface.d.ts

@@ -0,0 +1,39 @@
+type TDmabufHeapKernelInterface = {
+    endianness: "LE" | "BE";
+    determinePageSize: () => number;
+    ioctl: (args: {
+        fd: number;
+        request: bigint;
+        arg: Uint8Array;
+    }) => {
+        errno: undefined | number;
+    };
+    dup: (args: {
+        fd: number;
+    }) => number;
+    close: (args: {
+        fd: number;
+    }) => void;
+    readdir: ({ path }: {
+        path: string;
+    }) => {
+        errno: undefined;
+        entries: string[];
+    } | {
+        errno: number;
+        entries: undefined;
+    };
+    open: (args: {
+        path: string;
+        flags: number;
+    }) => {
+        errno: undefined;
+        fd: number;
+    } | {
+        errno: number;
+        fd: undefined;
+    };
+};
+type TDmabufHeapAllocatorKernelInterface = Pick<TDmabufHeapKernelInterface, "endianness" | "determinePageSize" | "ioctl" | "dup" | "close">;
+type TDmabufHeapIoctlKernelInterface = Pick<TDmabufHeapKernelInterface, "endianness" | "ioctl">;
+export type { TDmabufHeapKernelInterface, TDmabufHeapAllocatorKernelInterface, TDmabufHeapIoctlKernelInterface };

package/dist/lib/kernel-interface.js

@@ -0,0 +1,32 @@
+/* c8 ignore start */
+/*type TDmabufHeapKernelInterface = {
+  endianness: "LE" | "BE";
+  determinePageSize: () => number;
+  ioctl: (args: { fd: number; request: bigint, arg: Uint8Array }) => { errno: undefined | number };
+  dup: (args: { fd: number }) => number;
+  close: (args: { fd: number }) => void;
+
+  // dmabuf heap listing
+  readdir: ({ path }: { path: string }) => { errno: undefined, entries: string[] } | { errno: number, entries: undefined };
+  open: (args: { path: string, flags: number }) => { errno: undefined, fd: number } | { errno: number, fd: undefined };
+};*/
+
+/*type TDmabufHeapAllocatorKernelInterface = Pick<TDmabufHeapKernelInterface,
+  "endianness" |
+  "determinePageSize" |
+  "ioctl" |
+  "dup" |
+  "close"
+>;*/
+
+/*type TDmabufHeapIoctlKernelInterface = Pick<TDmabufHeapKernelInterface,
+  "endianness" |
+  "ioctl"
+>;*/
+
+/*export type {
+  TDmabufHeapKernelInterface,
+  TDmabufHeapAllocatorKernelInterface,
+  TDmabufHeapIoctlKernelInterface
+};*/
+/* c8 ignore stop */

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.1",
+  "version": "0.0.3",
   "name": "@k13engineering/linux-dmabuf-allocator",
   "type": "module",
   "description": "Linux dmabuf allocator module",