Привет! Ты можешь сделать на FreePascal'e юнит syscloneunit, содержащий реализацию системного вызова ядра Clone; TSysClone Наподобие tthread, но напрямую работающий с ядром с этим системным вызовом? И пример его использования. На ассемблере демо выглядит так: ;; Pure assembly, library-free Linux threading demo
bits 64
default rel
global _start

;; sys/syscall.h
%define SYS_write	1
%define SYS_mmap	9
%define SYS_clone	56
%define SYS_exit	60

;; unistd.h
%define STDIN		0
%define STDOUT		1
%define STDERR		2

;; sched.h
%define CLONE_VM	0x00000100
%define CLONE_FS	0x00000200
%define CLONE_FILES	0x00000400
%define CLONE_SIGHAND	0x00000800
%define CLONE_PARENT	0x00008000
%define CLONE_THREAD	0x00010000
%define CLONE_IO	0x80000000

;; sys/mman.h
%define MAP_GROWSDOWN	0x0100
%define MAP_ANONYMOUS	0x0020
%define MAP_PRIVATE	0x0002
%define PROT_READ	0x1
%define PROT_WRITE	0x2
%define PROT_EXEC	0x4

%define THREAD_FLAGS \
 CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_PARENT|CLONE_THREAD|CLONE_IO

%define STACK_SIZE	(4096 * 1024)

%define MAX_LINES	1000000	; number of output lines before exiting

section .data
count:	dq MAX_LINES

section .text
_start:
	; Spawn a few threads
	mov rdi, threadfn
	call thread_create
	mov rdi, threadfn
	call thread_create

.loop:	call check_count
	mov rdi, .hello
	call puts
	mov rdi, 0
	jmp .loop

.hello:	db `Hello from \e[93;1mmain\e[0m!\n\0`

;; void threadfn(void)
threadfn:
	call check_count
	mov rdi, .hello
	call puts
	jmp threadfn
.hello:	db `Hello from \e[91;1mthread\e[0m!\n\0`

;; void check_count(void) -- may not return
check_count:
	mov rax, -1
	lock xadd [count], rax
	jl .exit
	ret
.exit	mov rdi, 0
	mov rax, SYS_exit
	syscall

;; void puts(char *)
puts:
	mov rsi, rdi
	mov rdx, -1
.count:	inc rdx
	cmp byte [rsi + rdx], 0
	jne .count
	mov rdi, STDOUT
	mov rax, SYS_write
	syscall
	ret

;; long thread_create(void (*)(void))
thread_create:
	push rdi
	call stack_create
	lea rsi, [rax + STACK_SIZE - 8]
	pop qword [rsi]
	mov rdi, THREAD_FLAGS
	mov rax, SYS_clone
	syscall
	ret

;; void *stack_create(void)
stack_create:
	mov rdi, 0
	mov rsi, STACK_SIZE
	mov rdx, PROT_WRITE | PROT_READ
	mov r10, MAP_ANONYMOUS | MAP_PRIVATE | MAP_GROWSDOWN
	mov r8, -1
	mov r9, 0
	mov rax, SYS_mmap
	syscall
	ret

Для реализации системного вызова clone на FreePascal и создания юнита syscloneunit, аналогичного TThread, но работающего напрямую с ядром, можно воспользоваться следующим кодом. Этот код будет использовать системный вызов clone для создания потоков и управления ими.
Юнит syscloneunit.pas
pascal
Copy

unit syscloneunit;

{$mode objfpc}{$H+}

interface

uses
  ctypes;

type
  TThreadFunc = function(Arg: Pointer): Pointer;

  TSysClone = class
  private
    FThreadFunc: TThreadFunc;
    FArg: Pointer;
    FThreadID: clong;
    FStack: Pointer;
    FStackSize: csize_t;
    function CreateStack: Boolean;
    procedure FreeStack;
  public
    constructor Create(ThreadFunc: TThreadFunc; Arg: Pointer; StackSize: csize_t = 1024 * 1024);
    destructor Destroy; override;
    function Start: Boolean;
    function Join: Pointer;
  end;

implementation

uses
  syscall, BaseUnix;

const
  CLONE_VM       = $00000100;
  CLONE_FS       = $00000200;
  CLONE_FILES    = $00000400;
  CLONE_SIGHAND  = $00000800;
  CLONE_PARENT   = $00008000;
  CLONE_THREAD   = $00010000;
  CLONE_IO       = $80000000;

  THREAD_FLAGS   = CLONE_VM or CLONE_FS or CLONE_FILES or CLONE_SIGHAND or CLONE_PARENT or CLONE_THREAD or CLONE_IO;

  PROT_READ      = $1;
  PROT_WRITE     = $2;
  PROT_EXEC      = $4;

  MAP_ANONYMOUS  = $20;
  MAP_PRIVATE    = $2;
  MAP_GROWSDOWN  = $100;

function clone(flags: cint; child_stack: Pointer; parent_tid: Pclong; child_tid: Pclong; tls: Pointer): cint; cdecl; external name 'clone';

constructor TSysClone.Create(ThreadFunc: TThreadFunc; Arg: Pointer; StackSize: csize_t);
begin
  inherited Create;
  FThreadFunc := ThreadFunc;
  FArg := Arg;
  FStackSize := StackSize;
  CreateStack;
end;

destructor TSysClone.Destroy;
begin
  FreeStack;
  inherited Destroy;
end;

function TSysClone.CreateStack: Boolean;
begin
  FStack := fpmmap(nil, FStackSize, PROT_READ or PROT_WRITE, MAP_ANONYMOUS or MAP_PRIVATE or MAP_GROWSDOWN, -1, 0);
  Result := FStack <> MAP_FAILED;
end;

procedure TSysClone.FreeStack;
begin
  if FStack <> nil then
    fpmunmap(FStack, FStackSize);
end;

function TSysClone.Start: Boolean;
var
  StackTop: Pointer;
begin
  StackTop := FStack + FStackSize;
  FThreadID := clone(THREAD_FLAGS, StackTop, nil, nil, nil);
  Result := FThreadID <> -1;
end;

function TSysClone.Join: Pointer;
begin
  fpwaitpid(FThreadID, @Result, 0);
end;

end.

Пример использования
pascal
Copy

program SysCloneExample;

uses
  syscloneunit, sysutils;

function ThreadFunc(Arg: Pointer): Pointer;
var
  I: Integer;
begin
  for I := 1 to 10 do
  begin
    WriteLn('Hello from thread!');
    Sleep(100);
  end;
  Result := nil;
end;

var
  Thread: TSysClone;

begin
  Thread := TSysClone.Create(@ThreadFunc, nil);
  try
    if Thread.Start then
    begin
      WriteLn('Thread started');
      Thread.Join;
    end
    else
      WriteLn('Failed to start thread');
  finally
    Thread.Free;
  end;
end.

Описание

    Юнит syscloneunit.pas:

        TSysClone — класс, который инкапсулирует логику создания и управления потоками с использованием системного вызова clone.

        CreateStack — выделяет память для стека потока.

        FreeStack — освобождает память стека.

        Start — запускает поток с использованием clone.

        Join — ожидает завершения потока и возвращает результат.

    Пример использования:

        Создается экземпляр TSysClone, который запускает поток, выполняющий функцию ThreadFunc.

        После запуска потока основной поток ждет его завершения с помощью Join.

Этот код демонстрирует, как можно использовать системный вызов clone для создания потоков в FreePascal, аналогично тому, как это делается на ассемблере.