mirror of
https://github.com/red-prig/fpPS4.git
synced 2024-10-07 19:53:21 +00:00
564 lines
16 KiB
ObjectPascal
564 lines
16 KiB
ObjectPascal
unit ps4_mutex;
|
|
|
|
{$mode objfpc}{$H+}
|
|
|
|
interface
|
|
|
|
uses
|
|
Windows,
|
|
sysutils,
|
|
sys_types;
|
|
|
|
type
|
|
p_pthread_mutex_attr=^pthread_mutex_attr_t;
|
|
pthread_mutex_attr_t=^pthread_mutex_attr;
|
|
pthread_mutex_attr=bitpacked record
|
|
_type:0..7; //3
|
|
_shared:0..1; //1
|
|
_protocol:0..3; //2
|
|
_align:0..67108863; //26
|
|
_prioceiling:Integer; //32
|
|
end;
|
|
|
|
p_pthread_mutex=^pthread_mutex;
|
|
pthread_mutex=^pthread_mutex_t;
|
|
pthread_mutex_t=packed record
|
|
valid:DWORD;
|
|
state:DWORD;
|
|
_type:DWORD;
|
|
rec_lock:DWORD;
|
|
owner:DWORD;
|
|
event:THandle;
|
|
name:array[0..31] of AnsiChar;
|
|
end;
|
|
|
|
ScePthreadMutex=pthread_mutex;
|
|
PScePthreadMutex=p_pthread_mutex;
|
|
|
|
const
|
|
SCE_PTHREAD_MUTEX_ERRORCHECK = 1; // Default POSIX mutex
|
|
SCE_PTHREAD_MUTEX_RECURSIVE = 2; // Recursive mutex
|
|
SCE_PTHREAD_MUTEX_NORMAL = 3; // No error checking
|
|
SCE_PTHREAD_MUTEX_ADAPTIVE = 4; // Adaptive mutex, spins briefly before blocking on lock
|
|
SCE_PTHREAD_MUTEX_DEFAULT = SCE_PTHREAD_MUTEX_ERRORCHECK;
|
|
|
|
PTHREAD_MUTEX_ERRORCHECK = SCE_PTHREAD_MUTEX_ERRORCHECK;
|
|
PTHREAD_MUTEX_RECURSIVE = SCE_PTHREAD_MUTEX_RECURSIVE;
|
|
PTHREAD_MUTEX_NORMAL = SCE_PTHREAD_MUTEX_NORMAL;
|
|
PTHREAD_MUTEX_ADAPTIVE = SCE_PTHREAD_MUTEX_ADAPTIVE;
|
|
PTHREAD_MUTEX_DEFAULT = SCE_PTHREAD_MUTEX_ERRORCHECK;{SCE_PTHREAD_MUTEX_RECURSIVE;}//PTHREAD_MUTEX_ERRORCHECK;
|
|
|
|
PTHREAD_PROCESS_PRIVATE=0;
|
|
PTHREAD_PROCESS_SHARED =1;
|
|
|
|
PTHREAD_PRIO_NONE =0;
|
|
PTHREAD_PRIO_INHERIT =1;
|
|
PTHREAD_PRIO_PROTECT =2;
|
|
|
|
PTHREAD_MUTEX_INITIALIZER =0;
|
|
PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP=1;
|
|
|
|
function ps4_pthread_mutexattr_init(pAttr:p_pthread_mutex_attr):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutexattr_destroy(pAttr:p_pthread_mutex_attr):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutexattr_gettype(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutexattr_settype(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutexattr_getpshared(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutexattr_setpshared(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutexattr_getprotocol(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutexattr_setprotocol(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutexattr_getprioceiling(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutexattr_setprioceiling(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
|
|
function ps4_pthread_mutex_lock(pMutex:p_pthread_mutex):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutex_timedlock(pMutex:p_pthread_mutex;ts:Ptimespec):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutex_trylock(pMutex:p_pthread_mutex):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutex_unlock(pMutex:p_pthread_mutex):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutex_init(pMutex:p_pthread_mutex;pAttr:p_pthread_mutex_attr):Integer; SysV_ABI_CDecl;
|
|
function ps4_pthread_mutex_destroy(pMutex:p_pthread_mutex):Integer; SysV_ABI_CDecl;
|
|
|
|
function ps4_scePthreadMutexattrInit(pAttr:p_pthread_mutex_attr):Integer; SysV_ABI_CDecl;
|
|
function ps4_scePthreadMutexattrDestroy(pAttr:p_pthread_mutex_attr):Integer; SysV_ABI_CDecl;
|
|
function ps4_scePthreadMutexattrGettype(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
function ps4_scePthreadMutexattrSettype(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
function ps4_scePthreadMutexattrGetprotocol(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
function ps4_scePthreadMutexattrSetprotocol(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
function ps4_scePthreadMutexattrGetprioceiling(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
function ps4_scePthreadMutexattrSetprioceiling(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
|
|
function ps4_scePthreadMutexInit(pMutex:PScePthreadMutex;pAttr:p_pthread_mutex_attr;str:PChar):Integer; SysV_ABI_CDecl;
|
|
function ps4_scePthreadMutexLock(pMutex:PScePthreadMutex):Integer; SysV_ABI_CDecl;
|
|
function ps4_scePthreadMutexTimedlock(pMutex:PScePthreadMutex;usec:DWORD):Integer; SysV_ABI_CDecl;
|
|
function ps4_scePthreadMutexTrylock(pMutex:PScePthreadMutex):Integer; SysV_ABI_CDecl;
|
|
function ps4_scePthreadMutexUnlock(pMutex:PScePthreadMutex):Integer; SysV_ABI_CDecl;
|
|
function ps4_scePthreadMutexDestroy(pMutex:PScePthreadMutex):Integer; SysV_ABI_CDecl;
|
|
|
|
//pthread_mutexattr_setkind_np
|
|
|
|
implementation
|
|
|
|
Uses
|
|
atomic,
|
|
sys_kernel,
|
|
sys_signal,
|
|
sys_time,
|
|
ps4_sema,
|
|
ps4_time;
|
|
|
|
function ps4_pthread_mutexattr_init(pAttr:p_pthread_mutex_attr):Integer; SysV_ABI_CDecl;
|
|
var
|
|
attr:pthread_mutex_attr_t;
|
|
begin
|
|
if (pAttr=nil) then Exit(EINVAL);
|
|
attr:=AllocMem(SizeOf(pthread_mutex_attr));
|
|
if (attr=nil) then Exit(ENOMEM);
|
|
attr^:=Default(pthread_mutex_attr);
|
|
attr^._type:=PTHREAD_MUTEX_DEFAULT;
|
|
pAttr^:=attr;
|
|
Result:=0;
|
|
end;
|
|
|
|
function ps4_pthread_mutexattr_destroy(pAttr:p_pthread_mutex_attr):Integer; SysV_ABI_CDecl;
|
|
var
|
|
attr:pthread_mutex_attr_t;
|
|
begin
|
|
if (pAttr=nil) then Exit(EINVAL);
|
|
attr:=pAttr^;
|
|
if (attr=nil) then Exit(EINVAL);
|
|
FreeMem(attr);
|
|
Result:=0;
|
|
end;
|
|
|
|
function ps4_pthread_mutexattr_gettype(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
if (pAttr=nil) or (t=nil) then Exit(EINVAL);
|
|
if (pAttr^=nil) then Exit(EINVAL);
|
|
t^:=pAttr^^._type;
|
|
Result:=0;
|
|
end;
|
|
|
|
function ps4_pthread_mutexattr_settype(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
if (pAttr=nil) then Exit(EINVAL);
|
|
if (pAttr^=nil) then Exit(EINVAL);
|
|
Case t of
|
|
PTHREAD_MUTEX_ERRORCHECK:;
|
|
PTHREAD_MUTEX_RECURSIVE :;
|
|
PTHREAD_MUTEX_NORMAL :;
|
|
PTHREAD_MUTEX_ADAPTIVE :;
|
|
else
|
|
Exit(EINVAL);
|
|
end;
|
|
pAttr^^._type:=t;
|
|
Result:=0;
|
|
end;
|
|
|
|
function ps4_pthread_mutexattr_getpshared(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
if (pAttr=nil) or (t=nil) then Exit(EINVAL);
|
|
if (pAttr^=nil) then Exit(EINVAL);
|
|
t^:=pAttr^^._shared;
|
|
Result:=0;
|
|
end;
|
|
|
|
function ps4_pthread_mutexattr_setpshared(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
if (pAttr=nil) then Exit(EINVAL);
|
|
if (pAttr^=nil) then Exit(EINVAL);
|
|
Case t of
|
|
PTHREAD_PROCESS_PRIVATE:;
|
|
PTHREAD_PROCESS_SHARED :;
|
|
else
|
|
Exit(EINVAL);
|
|
end;
|
|
pAttr^^._shared:=t;
|
|
Result:=0;
|
|
end;
|
|
|
|
function ps4_pthread_mutexattr_getprotocol(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
if (pAttr=nil) or (t=nil) then Exit(EINVAL);
|
|
if (pAttr^=nil) then Exit(EINVAL);
|
|
t^:=pAttr^^._protocol;
|
|
Result:=0;
|
|
end;
|
|
|
|
function ps4_pthread_mutexattr_setprotocol(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
if (pAttr=nil) then Exit(EINVAL);
|
|
if (pAttr^=nil) then Exit(EINVAL);
|
|
Case t of
|
|
PTHREAD_PRIO_NONE :;
|
|
PTHREAD_PRIO_INHERIT:;
|
|
PTHREAD_PRIO_PROTECT:;
|
|
else
|
|
Exit(EINVAL);
|
|
end;
|
|
pAttr^^._protocol:=t;
|
|
Result:=0;
|
|
end;
|
|
|
|
function ps4_pthread_mutexattr_getprioceiling(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
if (pAttr=nil) or (t=nil) then Exit(EINVAL);
|
|
if (pAttr^=nil) then Exit(EINVAL);
|
|
t^:=pAttr^^._prioceiling;
|
|
Result:=0;
|
|
end;
|
|
|
|
function ps4_pthread_mutexattr_setprioceiling(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
if (pAttr=nil) then Exit(EINVAL);
|
|
if (pAttr^=nil) then Exit(EINVAL);
|
|
pAttr^^._prioceiling:=t;
|
|
Result:=0;
|
|
end;
|
|
|
|
///////////////////////////
|
|
|
|
Const
|
|
LIFE_MUTEX=$BAB1F00D;
|
|
DEAD_MUTEX=$DEADBEEF;
|
|
|
|
MS_Unlocked=0;
|
|
MS_Locked =1;
|
|
MS_Waiting =2;
|
|
|
|
const
|
|
PTHREAD_MUTEX_FREE=2;
|
|
|
|
function STATIC_INITIALIZER(m:pthread_mutex):Boolean; inline;
|
|
begin
|
|
Result:=False;
|
|
Case PtrUInt(m) of
|
|
PTHREAD_MUTEX_INITIALIZER,
|
|
PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP:Result:=True;
|
|
end;
|
|
end;
|
|
|
|
function mutex_impl_init(m:p_pthread_mutex;mi:pthread_mutex;_type:Integer):pthread_mutex;
|
|
var
|
|
new_mi:pthread_mutex;
|
|
begin
|
|
new_mi:=SwAllocMem(SizeOf(pthread_mutex_t));
|
|
if (new_mi=nil) then Exit(new_mi);
|
|
|
|
new_mi^.valid:=LIFE_MUTEX;
|
|
new_mi^.state:=MS_Unlocked;
|
|
new_mi^._type:=_type;
|
|
new_mi^.owner:=DWORD(-1);
|
|
|
|
if CAS(m^,mi,new_mi) then
|
|
begin
|
|
Result:=new_mi;
|
|
end else
|
|
begin
|
|
SwFreeMem(new_mi);
|
|
Result:=m^;
|
|
end;
|
|
end;
|
|
|
|
function mutex_impl(m:p_pthread_mutex;var mi:pthread_mutex;default:Integer):Integer;
|
|
begin
|
|
if (m=nil) then Exit(EINVAL);
|
|
mi:=m^;
|
|
Case PtrUInt(mi) of
|
|
PTHREAD_MUTEX_INITIALIZER :mi:=mutex_impl_init(m,mi,default);
|
|
PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP:mi:=mutex_impl_init(m,mi,PTHREAD_MUTEX_ADAPTIVE);
|
|
PTHREAD_MUTEX_FREE :Exit(EINVAL);
|
|
end;
|
|
if (mi=nil) then Exit(ENOMEM);
|
|
if not safe_test(mi^.valid,LIFE_MUTEX) then Exit(EINVAL);
|
|
Result:=0;
|
|
end;
|
|
|
|
function pthread_mutex_lock_intern(m:p_pthread_mutex;pTimeout:PQWORD;default:Integer):Integer;
|
|
var
|
|
mi:pthread_mutex;
|
|
old_state:DWORD;
|
|
ev:THandle;
|
|
begin
|
|
Result:=mutex_impl(m,mi,default);
|
|
if (Result<>0) then Exit;
|
|
|
|
old_state:=XCHG(mi^.state,MS_Locked);
|
|
if (old_state<>MS_Unlocked) then
|
|
begin
|
|
if (mi^._type<>PTHREAD_MUTEX_NORMAL) then
|
|
if (mi^.owner=GetCurrentThreadId) then
|
|
begin
|
|
CAS(mi^.state,MS_Locked,old_state);
|
|
if (mi^._type=PTHREAD_MUTEX_RECURSIVE) then
|
|
begin
|
|
Inc(mi^.rec_lock);
|
|
Exit(0);
|
|
end else
|
|
begin
|
|
Exit(EDEADLK);
|
|
end;
|
|
end;
|
|
|
|
if (mi^.event=0) then
|
|
begin
|
|
ev:=CreateEvent(nil,false,false,nil);
|
|
if (ev=0) then
|
|
Case GetLastError of
|
|
ERROR_ACCESS_DENIED:Exit(EPERM);
|
|
else
|
|
Exit(EPERM);
|
|
end;
|
|
|
|
if not CAS(mi^.event,0,ev) then
|
|
begin
|
|
CloseHandle(ev);
|
|
end;
|
|
end;
|
|
|
|
While (XCHG(mi^.state,MS_Waiting)<>MS_Unlocked) do
|
|
begin
|
|
Result:=do_sema_b_wait_intern(mi^.event,pTimeout);
|
|
if (Result<>0) then Exit;
|
|
end;
|
|
end;
|
|
|
|
if (mi^._type<>PTHREAD_MUTEX_NORMAL) then
|
|
begin
|
|
mi^.owner:=GetCurrentThreadId;
|
|
end;
|
|
|
|
Result:=0;
|
|
end;
|
|
|
|
function ps4_pthread_mutex_lock(pMutex:p_pthread_mutex):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
_sig_lock;
|
|
Result:=pthread_mutex_lock_intern(pMutex,nil,PTHREAD_MUTEX_DEFAULT);
|
|
_sig_unlock;
|
|
end;
|
|
|
|
function ps4_pthread_mutex_timedlock(pMutex:p_pthread_mutex;ts:Ptimespec):Integer; SysV_ABI_CDecl;
|
|
var
|
|
t:QWORD;
|
|
begin
|
|
if (ts=nil) then
|
|
begin
|
|
_sig_lock;
|
|
Result:=pthread_mutex_lock_intern(pMutex,nil,PTHREAD_MUTEX_DEFAULT);
|
|
_sig_unlock;
|
|
end else
|
|
begin
|
|
t:=_pthread_rel_time_in_ns(ts^);
|
|
_sig_lock;
|
|
Result:=pthread_mutex_lock_intern(pMutex,@t,PTHREAD_MUTEX_DEFAULT);
|
|
_sig_unlock;
|
|
end;
|
|
end;
|
|
|
|
function pthread_mutex_unlock(m:p_pthread_mutex;default:Integer):Integer;
|
|
var
|
|
mi:pthread_mutex;
|
|
begin
|
|
Result:=mutex_impl(m,mi,default);
|
|
if (Result<>0) then Exit;
|
|
|
|
if (mi^._type<>PTHREAD_MUTEX_NORMAL) then
|
|
begin
|
|
if (mi^.state=MS_Unlocked) then Exit(EPERM);
|
|
if (mi^.owner<>GetCurrentThreadId) then Exit(EPERM);
|
|
|
|
if (mi^.rec_lock>0) then
|
|
begin
|
|
Dec(mi^.rec_lock);
|
|
Exit(0);
|
|
end;
|
|
mi^.owner:=DWORD(-1);
|
|
end;
|
|
|
|
if XCHG(mi^.state,MS_Unlocked)=MS_Waiting then
|
|
begin
|
|
_sig_lock;
|
|
if not SetEvent(mi^.event) then Result:=EPERM;
|
|
_sig_unlock;
|
|
end;
|
|
|
|
end;
|
|
|
|
function ps4_pthread_mutex_unlock(pMutex:p_pthread_mutex):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=pthread_mutex_unlock(pMutex,PTHREAD_MUTEX_DEFAULT);
|
|
end;
|
|
|
|
function pthread_mutex_trylock(m:p_pthread_mutex;default:Integer):Integer;
|
|
var
|
|
mi:pthread_mutex;
|
|
begin
|
|
Result:=mutex_impl(m,mi,default);
|
|
if (Result<>0) then Exit;
|
|
|
|
if CAS(mi^.state,MS_Unlocked,MS_Locked) then
|
|
begin
|
|
if (mi^._type<>PTHREAD_MUTEX_NORMAL) then
|
|
begin
|
|
mi^.owner:=GetCurrentThreadId;
|
|
end;
|
|
Exit(0);
|
|
end else
|
|
begin
|
|
if (mi^._type=PTHREAD_MUTEX_RECURSIVE) and (mi^.owner=GetCurrentThreadId) then
|
|
begin
|
|
Inc(mi^.rec_lock);
|
|
Exit(0);
|
|
end;
|
|
Exit(EBUSY);
|
|
end;
|
|
end;
|
|
|
|
function ps4_pthread_mutex_trylock(pMutex:p_pthread_mutex):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=pthread_mutex_trylock(pMutex,PTHREAD_MUTEX_DEFAULT);
|
|
end;
|
|
|
|
function pthread_mutex_init(m:p_pthread_mutex;a:p_pthread_mutex_attr;str:PChar;default:Integer):Integer;
|
|
var
|
|
mi:pthread_mutex;
|
|
attr:pthread_mutex_attr_t;
|
|
begin
|
|
if (m=nil) then Exit(EINVAL);
|
|
mi:=m^;
|
|
|
|
attr:=nil;
|
|
if (a<>nil) then
|
|
begin
|
|
attr:=a^;
|
|
end;
|
|
|
|
if (attr<>nil) then
|
|
begin
|
|
mi:=mutex_impl_init(m,mi,attr^._type);
|
|
end else
|
|
begin
|
|
mi:=mutex_impl_init(m,mi,default);
|
|
end;
|
|
if (mi=nil) then Exit(ENOMEM);
|
|
if not safe_test(mi^.valid,LIFE_MUTEX) then Exit(EINVAL);
|
|
|
|
if (str<>nil) then MoveChar0(str^,mi^.name,32);
|
|
|
|
Result:=0;
|
|
end;
|
|
|
|
function ps4_pthread_mutex_init(pMutex:p_pthread_mutex;pAttr:p_pthread_mutex_attr):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=pthread_mutex_init(pMutex,pAttr,nil,PTHREAD_MUTEX_DEFAULT);
|
|
end;
|
|
|
|
function pthread_mutex_destroy(m:p_pthread_mutex):Integer;
|
|
var
|
|
mi:pthread_mutex;
|
|
begin
|
|
if (m=nil) then Exit(EINVAL);
|
|
mi:=m^;
|
|
if not STATIC_INITIALIZER(mi) then
|
|
begin
|
|
mi:=XCHG(m^,Pointer(PTHREAD_MUTEX_FREE));
|
|
if (mi=Pointer(PTHREAD_MUTEX_FREE)) then Exit(EINVAL);
|
|
if STATIC_INITIALIZER(mi) then Exit(0);
|
|
if not CAS(mi^.valid,LIFE_MUTEX,DEAD_MUTEX) then Exit(EINVAL);
|
|
_sig_lock;
|
|
if (mi^.event<>0) then CloseHandle(mi^.event);
|
|
FreeMem(mi);
|
|
_sig_unlock;
|
|
end;
|
|
Result:=0;
|
|
end;
|
|
|
|
function ps4_pthread_mutex_destroy(pMutex:p_pthread_mutex):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=pthread_mutex_destroy(pMutex);
|
|
end;
|
|
|
|
//---------------------------------------------------------
|
|
//sce
|
|
|
|
function ps4_scePthreadMutexattrInit(pAttr:p_pthread_mutex_attr):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=px2sce(ps4_pthread_mutexattr_init(pAttr));
|
|
end;
|
|
|
|
function ps4_scePthreadMutexattrDestroy(pAttr:p_pthread_mutex_attr):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=px2sce(ps4_pthread_mutexattr_destroy(pAttr));
|
|
end;
|
|
|
|
function ps4_scePthreadMutexattrGettype(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=px2sce(ps4_pthread_mutexattr_gettype(pAttr,t));
|
|
end;
|
|
|
|
function ps4_scePthreadMutexattrSettype(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=px2sce(ps4_pthread_mutexattr_settype(pAttr,t));
|
|
end;
|
|
|
|
function ps4_scePthreadMutexattrGetprotocol(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=px2sce(ps4_pthread_mutexattr_getprotocol(pAttr,t));
|
|
end;
|
|
|
|
function ps4_scePthreadMutexattrSetprotocol(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=px2sce(ps4_pthread_mutexattr_setprotocol(pAttr,t));
|
|
end;
|
|
|
|
function ps4_scePthreadMutexattrGetprioceiling(pAttr:p_pthread_mutex_attr;t:PInteger):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=px2sce(ps4_pthread_mutexattr_getprioceiling(pAttr,t));
|
|
|
|
end;
|
|
|
|
function ps4_scePthreadMutexattrSetprioceiling(pAttr:p_pthread_mutex_attr;t:Integer):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=px2sce(ps4_pthread_mutexattr_setprioceiling(pAttr,t));
|
|
end;
|
|
|
|
//////////////
|
|
|
|
function ps4_scePthreadMutexLock(pMutex:p_pthread_mutex):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
_sig_lock;
|
|
Result:=px2sce(pthread_mutex_lock_intern(pMutex,nil,SCE_PTHREAD_MUTEX_DEFAULT));
|
|
_sig_unlock;
|
|
end;
|
|
|
|
function ps4_scePthreadMutexTimedlock(pMutex:PScePthreadMutex;usec:DWORD):Integer; SysV_ABI_CDecl;
|
|
var
|
|
t:QWORD;
|
|
begin
|
|
t:=_usec2nsec(usec);
|
|
_sig_lock;
|
|
Result:=px2sce(pthread_mutex_lock_intern(pMutex,@t,SCE_PTHREAD_MUTEX_DEFAULT));
|
|
_sig_unlock;
|
|
end;
|
|
|
|
function ps4_scePthreadMutexUnlock(pMutex:p_pthread_mutex):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=px2sce(pthread_mutex_unlock(pMutex,SCE_PTHREAD_MUTEX_DEFAULT));
|
|
end;
|
|
|
|
function ps4_scePthreadMutexTrylock(pMutex:p_pthread_mutex):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=px2sce(pthread_mutex_trylock(pMutex,SCE_PTHREAD_MUTEX_DEFAULT));
|
|
end;
|
|
|
|
function ps4_scePthreadMutexInit(pMutex:PScePthreadMutex;pAttr:p_pthread_mutex_attr;str:PChar):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=px2sce(pthread_mutex_init(pMutex,pAttr,str,SCE_PTHREAD_MUTEX_DEFAULT));
|
|
end;
|
|
|
|
function ps4_scePthreadMutexDestroy(pMutex:p_pthread_mutex):Integer; SysV_ABI_CDecl;
|
|
begin
|
|
Result:=px2sce(pthread_mutex_destroy(pMutex));
|
|
end;
|
|
|
|
end.
|
|
|