nortti
/
sortix-mirror
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Split libmaxsi process.o into multiple files.

This commit is contained in:
Jonas 'Sortie' Termansen 2012-09-26 16:11:38 +02:00
parent 838992c3d8
commit fb91fbbc5c
19 changed files with 625 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
libmaxsi/Makefile
View File

@ -115,21 +115,31 @@ dlfcn.o \
dup.o \
env.o \
errorprint.o \
execle.o \
execl.o \
execlp.o \
execve.o \
execv.o \
execvpe.o \
execvp.o \
_exit.o \
exit.o \
_Exit.o \
exit.o \
fchmod.o \
fcloseall.o \
fcntl.o \
fddir-sortix.o \
fdio.o \
fileno.o \
fork.o \
fpipe.o \
fstat.o \
ftruncate.o \
getc.o \
getcwd.o \
getdtablesize.o \
getpid.o \
getppid.o \
gettermmode.o \
init.o \
ioleast.o \
@ -143,7 +153,6 @@ on_exit.o \
open.o \
pipe.o \
print.o \
process.o \
putc.o \
random.o \
readdirents.o \
@ -153,16 +162,23 @@ scanf.o \
setjmp.o \
setlocale.o \
settermmode.o \
sfork.o \
signal.o \
sleep.o \
stat.o \
stdio.o \
tfork.o \
time.o \
truncate.o \
umask.o \
unlink.o \
usleep.o \
vexecle.o \
vexecl.o \
vexeclp.o \
vscanf.o \
wait.o \
waitpid.o \
winsize.o \
write.o \

35
libmaxsi/execl.cpp Normal file
View File

@ -0,0 +1,35 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
execl.cpp
Loads a process image.
*******************************************************************************/
#include <stdarg.h>
#include <unistd.h>
extern "C" int execl(const char* pathname, ...)
{
va_list args;
va_start(args, pathname);
int result = vexecl(pathname, args);
va_end(args);
return result;
}

35
libmaxsi/execle.cpp Normal file
View File

@ -0,0 +1,35 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
execlp.cpp
Loads a process image.
*******************************************************************************/
#include <stdarg.h>
#include <unistd.h>
extern "C" int execle(const char* pathname, ...)
{
va_list args;
va_start(args, pathname);
int result = vexecle(pathname, args);
va_end(args);
return result;
}

35
libmaxsi/execlp.cpp Normal file
View File

@ -0,0 +1,35 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
execlp.cpp
Loads a process image.
*******************************************************************************/
#include <stdarg.h>
#include <unistd.h>
extern "C" int execlp(const char* filename, ...)
{
va_list args;
va_start(args, filename);
int result = vexeclp(filename, args);
va_end(args);
return result;
}

31
libmaxsi/execv.cpp Normal file
View File

@ -0,0 +1,31 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
execv.cpp
Loads a process image.
*******************************************************************************/
#define _WANT_ENVIRON
#include <unistd.h>
extern "C" int execv(const char* pathname, char* const* argv)
{
return execve(pathname, argv, environ);
}

34
libmaxsi/execve.cpp Normal file
View File

@ -0,0 +1,34 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
execve.cpp
Loads a process image.
*******************************************************************************/
#include <sys/syscall.h>
#include <unistd.h>
DEFN_SYSCALL3(int, sys_execve, SYSCALL_EXEC, const char*, char* const*, char* const*);
extern "C" int execve(const char* pathname, char* const* argv,
char* const* envp)
{
return sys_execve(pathname, argv, envp);
}

31
libmaxsi/execvp.cpp Normal file
View File

@ -0,0 +1,31 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
execvp.cpp
Loads a process image.
*******************************************************************************/
#define _WANT_ENVIRON
#include <unistd.h>
extern "C" int execvp(const char* filename, char* const* argv)
{
return execvpe(filename, argv, environ);
}

44
libmaxsi/execvpe.cpp Normal file
View File

@ -0,0 +1,44 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
execvpe.cpp
Loads a process image.
*******************************************************************************/
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
// Note that the only PATH variable in Sortix is the one used here.
extern "C" int execvpe(const char* filename, char* const* argv,
char* const* envp)
{
if ( strchr(filename, '/') )
return execve(filename, argv, envp);
size_t filenamelen = strlen(filename);
const char* PATH = "/bin";
size_t pathlen = strlen(PATH);
char* pathname = (char*) malloc(filenamelen + 1 + pathlen + 1);
if ( !pathname ) { return -1; }
stpcpy(stpcpy(stpcpy(pathname, PATH), "/"), filename);
int result = execve(pathname, argv, envp);
free(pathname);
return result;
}

30
libmaxsi/fork.cpp Normal file
View File

@ -0,0 +1,30 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
fork.cpp
Create a new task inheriting some properties from the current task.
*******************************************************************************/
#include <unistd.h>
extern "C" pid_t fork()
{
return sfork(SFFORK);
}

33
libmaxsi/getpid.cpp Normal file
View File

@ -0,0 +1,33 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
getpid.cpp
Get current process id.
*******************************************************************************/
#include <sys/syscall.h>
#include <unistd.h>
DEFN_SYSCALL0(pid_t, sys_getpid, SYSCALL_GETPID);
extern "C" pid_t getpid()
{
return sys_getpid();
}

33
libmaxsi/getppid.cpp Normal file
View File

@ -0,0 +1,33 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
getpid.cpp
Get parent process id.
*******************************************************************************/
#include <sys/syscall.h>
#include <unistd.h>
DEFN_SYSCALL0(pid_t, sys_getppid, SYSCALL_GETPPID);
extern "C" pid_t getppid()
{
return sys_getppid();
}

199
libmaxsi/process.cpp
View File

@ -1,199 +0,0 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
process.cpp
Exposes system calls for process creation and management.
*******************************************************************************/
#define _WANT_ENVIRON
#include <sys/syscall.h>
#include <stdio.h>
#include <stdarg.h>
#include <dirent.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
namespace Maxsi
{
namespace Process
{
DEFN_SYSCALL3(int, SysExecVE, SYSCALL_EXEC, const char*, char* const*, char* const*);
DEFN_SYSCALL2(pid_t, SysTFork, SYSCALL_TFORK, int, tforkregs_t*);
DEFN_SYSCALL0(pid_t, SysGetPID, SYSCALL_GETPID);
DEFN_SYSCALL0(pid_t, SysGetParentPID, SYSCALL_GETPPID);
DEFN_SYSCALL3(pid_t, SysWait, SYSCALL_WAIT, pid_t, int*, int);
extern "C" int execve(const char* pathname, char* const* argv,
char* const* envp)
{
return SysExecVE(pathname, argv, envp);
}
extern "C" int execv(const char* pathname, char* const* argv)
{
return execve(pathname, argv, environ);
}
// Note that the only PATH variable in Sortix is the one used here.
extern "C" int execvpe(const char* filename, char* const* argv,
char* const* envp)
{
if ( strchr(filename, '/') )
return execve(filename, argv, envp);
size_t filenamelen = strlen(filename);
const char* PATH = "/bin";
size_t pathlen = strlen(PATH);
char* pathname = (char*) malloc(filenamelen + 1 + pathlen + 1);
if ( !pathname ) { return -1; }
stpcpy(stpcpy(stpcpy(pathname, PATH), "/"), filename);
int result = execve(pathname, argv, envp);
free(pathname);
return result;
}
extern "C" int execvp(const char* filename, char* const* argv)
{
return execvpe(filename, argv, environ);
}
extern "C" int vexecl(const char* pathname, va_list args)
{
va_list iter;
va_copy(iter, args);
size_t numargs = 0;
while ( va_arg(iter, const char*) ) { numargs++; }
va_end(iter);
char** argv = (char**) malloc(sizeof(char*) * (numargs+1));
if ( !argv ) { return -1; }
for ( size_t i = 0; i <= numargs; i++ )
{
argv[i] = (char*) va_arg(args, const char*);
}
int result = execv(pathname, argv);
free(argv);
return result;
}
extern "C" int vexeclp(const char* filename, va_list args)
{
va_list iter;
va_copy(iter, args);
size_t numargs = 0;
while ( va_arg(iter, const char*) ) { numargs++; }
va_end(iter);
char** argv = (char**) malloc(sizeof(char*) * (numargs+1));
if ( !argv ) { return -1; }
for ( size_t i = 0; i <= numargs; i++ )
{
argv[i] = (char*) va_arg(args, const char*);
}
int result = execvp(filename, argv);
free(argv);
return result;
}
extern "C" int vexecle(const char* pathname, va_list args)
{
va_list iter;
va_copy(iter, args);
size_t numargs = 0;
while ( va_arg(iter, const char*) ) { numargs++; }
va_end(iter);
numargs--; // envp
char** argv = (char**) malloc(sizeof(char*) * (numargs+1));
if ( !argv ) { return -1; }
for ( size_t i = 0; i < numargs; i++ )
{
argv[i] = (char*) va_arg(args, const char*);
}
argv[numargs] = NULL;
char* const* envp = va_arg(args, char* const*);
int result = execve(pathname, argv, envp);
free(argv);
return result;
}
extern "C" int execl(const char* pathname, ...)
{
va_list args;
va_start(args, pathname);
int result = vexecl(pathname, args);
va_end(args);
return result;
}
extern "C" int execlp(const char* filename, ...)
{
va_list args;
va_start(args, filename);
int result = vexeclp(filename, args);
va_end(args);
return result;
}
extern "C" int execle(const char* pathname, ...)
{
va_list args;
va_start(args, pathname);
int result = vexecle(pathname, args);
va_end(args);
return result;
}
extern "C" pid_t tfork(int flags, tforkregs_t* regs)
{
return SysTFork(flags, regs);
}
extern "C" pid_t __call_tfork_with_regs(int flags);
extern "C" pid_t sfork(int flags)
{
return __call_tfork_with_regs(flags);
}
extern "C" pid_t fork()
{
return sfork(SFFORK);
}
extern "C" pid_t getpid()
{
return SysGetPID();
}
extern "C" pid_t getppid()
{
return SysGetParentPID();
}
extern "C" pid_t waitpid(pid_t pid, int* status, int options)
{
return SysWait(pid, status, options);
}
extern "C" pid_t wait(int* status)
{
return waitpid(-1, status, 0);
}
}
}

32
libmaxsi/sfork.cpp Normal file
View File

@ -0,0 +1,32 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
sfork.cpp
Create a new task inheriting some properties from the current task.
*******************************************************************************/
#include <unistd.h>
extern "C" pid_t __call_tfork_with_regs(int flags);
extern "C" pid_t sfork(int flags)
{
return __call_tfork_with_regs(flags);
}

33
libmaxsi/tfork.cpp Normal file
View File

@ -0,0 +1,33 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
tfork.cpp
Create a new task inheriting some properties from the current task.
*******************************************************************************/
#include <sys/syscall.h>
#include <unistd.h>
DEFN_SYSCALL2(pid_t, sys_tfork, SYSCALL_TFORK, int, tforkregs_t*);
extern "C" pid_t tfork(int flags, tforkregs_t* regs)
{
return sys_tfork(flags, regs);
}

45
libmaxsi/vexecl.cpp Normal file
View File

@ -0,0 +1,45 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
vexecl.cpp
Loads a process image.
*******************************************************************************/
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>
extern "C" int vexecl(const char* pathname, va_list args)
{
va_list iter;
va_copy(iter, args);
size_t numargs = 0;
while ( va_arg(iter, const char*) ) { numargs++; }
va_end(iter);
char** argv = (char**) malloc(sizeof(char*) * (numargs+1));
if ( !argv ) { return -1; }
for ( size_t i = 0; i <= numargs; i++ )
{
argv[i] = (char*) va_arg(args, const char*);
}
int result = execv(pathname, argv);
free(argv);
return result;
}

48
libmaxsi/vexecle.cpp Normal file
View File

@ -0,0 +1,48 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
vexecle.cpp
Loads a process image.
*******************************************************************************/
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>
extern "C" int vexecle(const char* pathname, va_list args)
{
va_list iter;
va_copy(iter, args);
size_t numargs = 0;
while ( va_arg(iter, const char*) ) { numargs++; }
va_end(iter);
numargs--; // envp
char** argv = (char**) malloc(sizeof(char*) * (numargs+1));
if ( !argv ) { return -1; }
for ( size_t i = 0; i < numargs; i++ )
{
argv[i] = (char*) va_arg(args, const char*);
}
argv[numargs] = NULL;
char* const* envp = va_arg(args, char* const*);
int result = execve(pathname, argv, envp);
free(argv);
return result;
}

45
libmaxsi/vexeclp.cpp Normal file
View File

@ -0,0 +1,45 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
vexeclp.cpp
Loads a process image.
*******************************************************************************/
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>
extern "C" int vexeclp(const char* filename, va_list args)
{
va_list iter;
va_copy(iter, args);
size_t numargs = 0;
while ( va_arg(iter, const char*) ) { numargs++; }
va_end(iter);
char** argv = (char**) malloc(sizeof(char*) * (numargs+1));
if ( !argv ) { return -1; }
for ( size_t i = 0; i <= numargs; i++ )
{
argv[i] = (char*) va_arg(args, const char*);
}
int result = execvp(filename, argv);
free(argv);
return result;
}

30
libmaxsi/wait.cpp Normal file
View File

@ -0,0 +1,30 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
waitpid.cpp
Wait for child process.
*******************************************************************************/
#include <sys/wait.h>
extern "C" pid_t wait(int* status)
{
return waitpid(-1, status, 0);
}

33
libmaxsi/waitpid.cpp Normal file
View File

@ -0,0 +1,33 @@
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
waitpid.cpp
Wait for child process.
*******************************************************************************/
#include <sys/syscall.h>
#include <sys/wait.h>
DEFN_SYSCALL3(pid_t, sys_wait, SYSCALL_WAIT, pid_t, int*, int);
extern "C" pid_t waitpid(pid_t pid, int* status, int options)
{
return sys_wait(pid, status, options);
}