@k13engineering/linux-dmabuf-allocator 0.0.4 → 0.0.5

package/dist/lib/index.d.ts

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

package/dist/lib/index.js

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

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

@@ -16,8 +16,12 @@ const createDefaultDmabufHeapAllocatorLinuxInterface = ()/*: TDmabufHeapKernelIn
   };
 
   const ioctl/*: C["ioctl"]*/ = ({ fd, request, arg }) => {
-    const { errno } = nativeIoctl({ fd, request, arg });
-    return { errno };
+    const { errno, ret } = nativeIoctl({ fd, request, arg });
+    if (errno !== undefined) {
+      return { errno, ret: undefined };
+    }
+
+    return { errno, ret };
   };
 
   const dup = ({ fd }/*: { fd: number }*/)/*: number*/ => {
@@ -55,6 +59,55 @@ const createDefaultDmabufHeapAllocatorLinuxInterface = ()/*: TDmabufHeapKernelIn
     }
   };
 
+  const fcntl/*: C["fcntl"]*/ = ({ fd, cmd, arg }/*: { fd: number; cmd: number; arg: number }*/) => {
+    const { errno } = syscall({
+      syscallNumber: syscallNumbers.fcntl,
+      args: [BigInt(fd), BigInt(cmd), BigInt(arg)]
+    });
+
+    if (errno !== undefined) {
+      return { errno };
+    }
+
+    return { errno: undefined };
+  };
+
+  const textEncoder = new TextEncoder();
+
+  const memfd_create/*: C["memfd_create"]*/ = ({ name, flags }/*: { name: string; flags: number }*/) => {
+
+    const nameAsBuffer = textEncoder.encode(`${name} \0`);
+
+    const { errno, ret } = syscall({
+      syscallNumber: syscallNumbers.memfd_create,
+      args: [
+        nameAsBuffer,
+        BigInt(flags)
+      ]
+    });
+
+    if (errno !== undefined) {
+      return {
+        errno,
+        memfd: undefined
+      };
+    }
+
+    return { errno: undefined, memfd: Number(ret) };
+  };
+
+  const ftruncate/*: C["ftruncate"]*/ = ({ fd, length }/*: { fd: number; length: number }*/) => {
+    try {
+      nodeFs.ftruncateSync(fd, length);
+    } catch (e) {
+      return {
+        error: e /*as Error*/,
+      };
+    }
+
+    return { error: undefined };
+  };
+
   const close/*: C["close"]*/ = ({ fd }) => {
     nodeFs.closeSync(fd);
   };
@@ -66,6 +119,9 @@ const createDefaultDmabufHeapAllocatorLinuxInterface = ()/*: TDmabufHeapKernelIn
     dup,
     readdir,
     open,
+    fcntl,
+    memfd_create,
+    ftruncate,
     close
   };
 };

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

@@ -6,7 +6,11 @@ type TDmabufHeapKernelInterface = {
         request: bigint;
         arg: Uint8Array;
     }) => {
-        errno: undefined | number;
+        errno: undefined;
+        ret: bigint;
+    } | {
+        errno: number;
+        ret: undefined;
     };
     dup: (args: {
         fd: number;
@@ -33,7 +37,35 @@ type TDmabufHeapKernelInterface = {
         errno: number;
         fd: undefined;
     };
+    fcntl: (args: {
+        fd: number;
+        cmd: number;
+        arg: number;
+    }) => {
+        errno: undefined;
+    } | {
+        errno: number;
+    };
+    memfd_create: (args: {
+        name: string;
+        flags: number;
+    }) => {
+        errno: undefined;
+        memfd: number;
+    } | {
+        errno: number;
+        memfd: undefined;
+    };
+    ftruncate: (args: {
+        fd: number;
+        length: number;
+    }) => {
+        error: undefined;
+    } | {
+        error: Error;
+    };
 };
 type TDmabufHeapAllocatorKernelInterface = Pick<TDmabufHeapKernelInterface, "endianness" | "determinePageSize" | "ioctl" | "dup" | "close">;
 type TDmabufHeapIoctlKernelInterface = Pick<TDmabufHeapKernelInterface, "endianness" | "ioctl">;
-export type { TDmabufHeapKernelInterface, TDmabufHeapAllocatorKernelInterface, TDmabufHeapIoctlKernelInterface };
+type TDmabufUdmabufAllocatorKernelInterface = Pick<TDmabufHeapKernelInterface, "endianness" | "determinePageSize" | "fcntl" | "memfd_create" | "ftruncate" | "ioctl" | "close">;
+export type { TDmabufHeapKernelInterface, TDmabufHeapAllocatorKernelInterface, TDmabufHeapIoctlKernelInterface, TDmabufUdmabufAllocatorKernelInterface };

package/dist/lib/kernel-interface.js

@@ -2,13 +2,18 @@
 /*type TDmabufHeapKernelInterface = {
   endianness: "LE" | "BE";
   determinePageSize: () => number;
-  ioctl: (args: { fd: number; request: bigint, arg: Uint8Array }) => { errno: undefined | number };
+  ioctl: (args: { fd: number; request: bigint, arg: Uint8Array }) => { errno: undefined, ret: bigint } | { errno: number, ret: undefined };
   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 };
+
+  // udmabuf allocator
+  fcntl: (args: { fd: number; cmd: number; arg: number }) => { errno: undefined } | { errno: number };
+  memfd_create: (args: { name: string; flags: number }) => { errno: undefined, memfd: number } | { errno: number, memfd: undefined };
+  ftruncate: (args: { fd: number; length: number }) => { error: undefined } | { error: Error };
 };*/
 
 /*type TDmabufHeapAllocatorKernelInterface = Pick<TDmabufHeapKernelInterface,
@@ -24,9 +29,20 @@
   "ioctl"
 >;*/
 
+/*type TDmabufUdmabufAllocatorKernelInterface = Pick<TDmabufHeapKernelInterface,
+  "endianness" |
+  "determinePageSize" |
+  "fcntl" |
+  "memfd_create" |
+  "ftruncate" |
+  "ioctl" |
+  "close"
+>;*/
+
 /*export type {
   TDmabufHeapKernelInterface,
   TDmabufHeapAllocatorKernelInterface,
-  TDmabufHeapIoctlKernelInterface
+  TDmabufHeapIoctlKernelInterface,
+  TDmabufUdmabufAllocatorKernelInterface
 };*/
 /* c8 ignore stop */

package/dist/lib/udmabuf/index.d.ts

@@ -0,0 +1,3 @@
+import { type TDmabufAllocator } from "../dmabuf-allocator-interface.js";
+declare const createDefaultUdmabufAllocator: () => TDmabufAllocator;
+export { createDefaultUdmabufAllocator, };

package/dist/lib/udmabuf/index.js

@@ -0,0 +1,26 @@
+import { /*type TDmabufAllocator */} from "../dmabuf-allocator-interface.js";
+import { createDefaultDmabufHeapAllocatorLinuxInterface } from "../kernel-interface-impl-linux.js";
+import { createUdmabufAllocatorFactory } from "./udmabuf-allocator.js";
+
+const O_RDWR = 0x02;
+const O_CLOEXEC = 0x80000;
+
+const createDefaultUdmabufAllocator = ()/*: TDmabufAllocator*/ => {
+  const kernelInterface = createDefaultDmabufHeapAllocatorLinuxInterface();
+
+  const { errno, fd } = kernelInterface.open({
+    path: "/dev/udmabuf",
+    flags: O_RDWR | O_CLOEXEC
+  });
+
+  if (errno !== undefined) {
+    throw Error(`failed to open /dev/udmabuf, errno ${errno}. Is the udmabuf kernel module loaded?`);
+  }
+
+  const udmabufAllocatorFactory = createUdmabufAllocatorFactory({ kernelInterface });
+  return udmabufAllocatorFactory.createUdmabufAllocator({ udmabufFd: fd });
+};
+
+export {
+  createDefaultUdmabufAllocator,
+};

package/dist/lib/udmabuf/udmabuf-allocator.d.ts

@@ -0,0 +1,10 @@
+import { type TDmabufAllocator } from "../dmabuf-allocator-interface.js";
+import { type TDmabufUdmabufAllocatorKernelInterface } from "../kernel-interface.js";
+declare const createUdmabufAllocatorFactory: ({ kernelInterface }: {
+    kernelInterface: TDmabufUdmabufAllocatorKernelInterface;
+}) => {
+    createUdmabufAllocator: ({ udmabufFd }: {
+        udmabufFd: number;
+    }) => TDmabufAllocator;
+};
+export { createUdmabufAllocatorFactory };

package/dist/lib/udmabuf/udmabuf-allocator.js

@@ -0,0 +1,127 @@
+import { /*type TDmabufAllocator */} from "../dmabuf-allocator-interface.js";
+import { createDefaultAllocationSizeDeterminer } from "../allocation-size.js";
+import { /*type TDmabufHeap */} from "../dmabuf-heap/dmabuf-heap.js";
+import { /*type TDmabufUdmabufAllocatorKernelInterface */} from "../kernel-interface.js";
+
+/*type TUdmabufCreateResult = {
+  errno: number;
+  dmabufFd: undefined;
+} | {
+  errno: undefined;
+  dmabufFd: number;
+};*/
+
+const UDMABUF_FLAGS_CLOEXEC = 1 << 0;
+const UDMABUF_CREATE = 0x40187542n;
+
+const F_ADD_SEALS = 1033;
+const F_SEAL_SHRINK = 0x0002;
+
+const MFD_ALLOW_SEALING = 0x0002;
+
+const createUdmabufAllocatorFactory = ({ kernelInterface }/*: { kernelInterface: TDmabufUdmabufAllocatorKernelInterface }*/) => {
+
+  const udmabufCreate = ({ udmabufFd, memfd, size }/*: { udmabufFd: number, memfd: number; size: number }*/)/*: TUdmabufCreateResult*/ => {
+
+    const flags = UDMABUF_FLAGS_CLOEXEC;
+    const offset = 0n;
+
+    const udmabufCreateStruct = Buffer.alloc(24);
+    udmabufCreateStruct.writeUInt32LE(memfd, 0);
+    udmabufCreateStruct.writeUInt32LE(flags, 4);
+    udmabufCreateStruct.writeBigUInt64LE(offset, 8);
+    udmabufCreateStruct.writeBigUInt64LE(BigInt(size), 16);
+
+    const { errno: ioctlErrno, ret } = kernelInterface.ioctl({ fd: udmabufFd, request: UDMABUF_CREATE, arg: udmabufCreateStruct });
+    if (ioctlErrno !== undefined) {
+      return {
+        errno: ioctlErrno,
+        dmabufFd: undefined
+      };
+    }
+
+    const dmabufFd = Number(ret);
+
+    return {
+      errno: undefined,
+      dmabufFd
+    };
+  };
+
+  const truncateAndSealMemfd = ({ memfd, size }/*: { memfd: number; size: number }*/) => {
+    const { error: ftruncateError } = kernelInterface.ftruncate({ fd: memfd, length: size });
+    if (ftruncateError !== undefined) {
+      throw Error("failed to truncate memfd", { cause: ftruncateError });
+    }
+
+    const { errno: fcntlErrno } = kernelInterface.fcntl({ fd: memfd, cmd: F_ADD_SEALS, arg: F_SEAL_SHRINK });
+    if (fcntlErrno !== undefined) {
+      throw Error(`failed to seal memfd, errno: ${fcntlErrno}`);
+    }
+  };
+
+  const createUdmabufAllocator = ({ udmabufFd }/*: { udmabufFd: number }*/)/*: TDmabufAllocator*/ => {
+
+    const pageSize = kernelInterface.determinePageSize();
+    const allocationSizeDeterminer = createDefaultAllocationSizeDeterminer({ pageSize });
+
+    const determineOptimalAllocationSize/*: TDmabufHeap["determineOptimalAllocationSize"]*/ = ({ minimumSize }) => {
+      return allocationSizeDeterminer.determineOptimalAllocationSize({ minimumSize });
+    };
+
+
+    // eslint-disable-next-line complexity
+    const allocate/*: TDmabufAllocator["allocate"]*/ = ({ size }) => {
+
+      if (size <= 0) {
+        throw Error("size must be > 0");
+      }
+
+      if ((size % pageSize) !== 0) {
+        throw Error(`size must be a multiple of ${pageSize}`);
+      }
+
+      const { errno: memfdCreateErrno, memfd } = kernelInterface.memfd_create({ name: "dmabuf_alloc", flags: MFD_ALLOW_SEALING });
+      if (memfdCreateErrno !== undefined) {
+        return {
+          error: Error(`failed to create memfd, errno: ${memfdCreateErrno}`),
+          dmabufFd: undefined
+        };
+      }
+
+      try {
+        truncateAndSealMemfd({ memfd, size });
+
+        const { errno: createUdmabufErrno, dmabufFd } = udmabufCreate({ udmabufFd, memfd, size });
+
+        if (createUdmabufErrno !== undefined) {
+          return {
+            error: Error(`failed to create udmabuf, errno: ${createUdmabufErrno}`),
+            dmabufFd: undefined
+          };
+        }
+
+        return {
+          error: undefined,
+          dmabufFd
+        };
+      } finally {
+        kernelInterface.close({ fd: memfd });
+      }
+    };
+
+    return {
+      allocate,
+      pageSize,
+      determineOptimalAllocationSize
+    };
+  };
+
+  return {
+    createUdmabufAllocator
+  };
+};
+
+export {
+  createUdmabufAllocatorFactory
+};

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.4",
+  "version": "0.0.5",
   "name": "@k13engineering/linux-dmabuf-allocator",
   "type": "module",
   "description": "Linux dmabuf allocator module",
@@ -11,7 +11,7 @@
   "devDependencies": {},
   "dependencies": {
     "@k13engineering/po6-ioctl": "^0.0.2",
-    "syscall-napi": "^0.1.5"
+    "syscall-napi": "^0.1.6"
   },
   "publishConfig": {
     "access": "public"