Linux 进程控制(C语言)

#include

/* Clone the calling process, but without copying the whole address space.

The calling process is suspended until the new process exits or is

replaced by a call to `execve'. Return -1 for errors, 0 to the new process, and the process ID of the new process to the old process. */

extern pid_t vfork (void) __THROW;

/* Clone the calling process, creating an exact copy.

Return -1 for errors, 0 to the new process,

and the process ID of the new process to the old process. */

extern pid_t fork (void) __THROW;

/* Get the process ID of the calling process. */

extern __pid_t getpid (void) __THROW;

/* Get the process ID of the calling process's parent. */

extern __pid_t getppid (void) __THROW;

/* Set the process group ID of the calling process to its own PID.

This is exactly the same as `setpgid (0, 0)'. */

extern int setpgrp (void) __THROW;

/* Get the process group ID of the calling process.

This function is di?erent on old BSD. */

#ifndef __FAVOR_BSD

extern __pid_t getpgrp (void) __THROW;

#else

# ifdef __REDIRECT_NTH

extern __pid_t __REDIRECT_NTH (getpgrp, (__pid_t __pid), __getpgid);

# else

# de?ne getpgrp __getpgid

# endif

#endif

/* Terminate program execution with the low-order 8 bits of STATUS. */ extern void _exit (int __status) __attribute__ ((__noreturn__));

/* Replace the current process, executing PATH with arguments ARGV and

environment ENVP. ARGV and ENVP are terminated by NULL pointers. */ extern int execve (__const char *__path, char *__const __argv[],

char *__const __envp[]) __THROW __nonnull ((1));

/* Execute PATH with arguments ARGV and environment from `environ'. */ extern int execv (__const char *__path, char *__const __argv[])

__THROW __nonnull ((1));

/* Execute PATH with all arguments after PATH until a NULL pointer,

and the argument after that for environment. */

extern int execle (__const char *__path, __const char *__arg, …)

__THROW __nonnull ((1));

/* Execute PATH with all arguments after PATH until

a NULL pointer and environment from `environ'. */

extern int execl (__const char *__path, __const char *__arg, …)

__THROW __nonnull ((1));

/* Execute FILE, searching in the `PATH' environment variable if it contains

no slashes, with arguments ARGV and environment from `environ'. */ extern int execvp (__const char *__?le, char *__const __argv[])

__THROW __nonnull ((1));

/* Execute FILE, searching in the `PATH' environment variable if

it contains no slashes, with all arguments after FILE until a

NULL pointer and environment from `environ'. */

extern int execlp (__const char *__?le, __const char *__arg, …)

__THROW __nonnull ((1));

/* exec

l:the number of params is unclear, the last by NULL

v:a char array pointer point to argv list, mostly like l, use NULL means last p:autocheck the program in environment path

e:a char array pointer for environment Val. restore in envp*/

/* Get the real user ID of the calling process. */

extern __uid_t getuid (void) __THROW;

/* Get the e?ective user ID of the calling process. */

extern __uid_t geteuid (void) __THROW;

/* Get the real group ID of the calling process. */

extern __gid_t getgid (void) __THROW;

/* Get the e?ective group ID of the calling process. */

extern __gid_t getegid (void) __THROW;

/* Set the user ID of the calling process to UID.

If the calling process is the super-user, set the real

and e?ective user IDs, and the saved set-user-ID to UID;

if not, the e?ective user ID is set to UID. */

extern int setuid (__uid_t __uid) __THROW;

#if de?ned __USE_BSD || de?ned __USE_XOPEN_EXTENDED

/* Set the real user ID of the calling process to RUID,

and the e?ective user ID of the calling process to EUID. */ extern int setreuid (__uid_t __ruid, __uid_t __euid) __THROW;

#endif

#if de?ned __USE_BSD || de?ned __USE_XOPEN2K

/* Set the e?ective user ID of the calling process to UID. */

extern int seteuid (__uid_t __uid) __THROW;

#endif /* Use BSD. */

/* Set the group ID of the calling process to GID.

If the calling process is the super-user, set the real

and e?ective group IDs, and the saved set-group-ID to GID;

if not, the e?ective group ID is set to GID. */

extern int setgid (__gid_t __gid) __THROW;

#if de?ned __USE_BSD || de?ned __USE_XOPEN_EXTENDED

/* Set the real group ID of the calling process to RGID,

and the e?ective group ID of the calling process to EGID. */ extern int setregid (__gid_t __rgid, __gid_t __egid) __THROW;

#endif

#if de?ned __USE_BSD || de?ned __USE_XOPEN2K

/* Set the e?ective group ID of the calling process to GID. */ extern int setegid (__gid_t __gid) __THROW;

#endif /* Use BSD. */

/* Add INC to priority of the current process. */

extern int nice (int __inc) __THROW __wur;

#include

/* Wait for a child to die. When one does, put its status in *STAT_LOC and return its process ID. For errors, return (pid_t) -1.

This function is a cancellation point and therefore not marked with

__THROW. */

extern __pid_t wait (__WAIT_STATUS __stat_loc);

/* Wait for a child matching PID to die.

If PID is greater than 0, match any process whose process ID is PID.

If PID is (pid_t) -1, match any process.

If PID is (pid_t) 0, match any process with the

same process group as the current process.

If PID is less than -1, match any process whose

process group is the absolute value of PID.

If the WNOHANG bit is set in OPTIONS, and that child

is not already dead, return (pid_t) 0. If successful,

return PID and store the dead child's status in STAT_LOC.

Return (pid_t) -1 for errors. If the WUNTRACED bit is

set in OPTIONS, return status for stopped children; otherwise don't.

This function is a cancellation point and therefore not marked with

__THROW. */

extern __pid_t waitpid (__pid_t __pid, int *__status, int __options);

/*WIFEXITED(status): normally ?nished, return true

WIFSIGNALED(status): ?nished by signal, return true; by exit, return false

WIFSTOPPED(): waitpid use WUNTRACED, and subprocess returnd, this true

WSTOPSIG(): when WIFSTOPPED() is true, get ?nished SIGNAL

WTERMSIG(): when WIFSIGNALED() is true, get ?nished SIGNAL

WEXITSTATUS(): when WIFEXITED() is true, its usable of returning quit code*/ #include

/* Return the highest priority of any process speci?ed by WHICH and WHO

(see above); if WHO is zero, the current process, process group, or user

(as speci?ed by WHO) is used. A lower priority number means higher

priority. Priorities range from PRIO_MIN to PRIO_MAX (above). */

//which: PRIO_PROCESS, PRIO_PGRP, PRIO_USER

//who: the process

extern int getpriority (__priority_which_t __which, id_t __who) __THROW;

/* Set the priority of all processes speci?ed by WHICH and WHO (see above)

to PRIO. Returns 0 on success, -1 on errors. */

//prio is from -20 to 20

extern int setpriority (__priority_which_t __which, id_t __who, int __prio)

__THROW;

#include

/* Clone current process. */

//?ags:CLONE_VM, _FS, _FILES, _PID, SIGHAND

extern int clone (int (*__fn) (void *__arg), void *__child_stack,

int __?ags, void *__arg, …) __THROW;

#include

/* Call all functions registered with `atexit' and `on_exit',

in the reverse of the order in which they were registered,

perform stdio cleanup, and terminate program execution with STATUS. */ extern void exit (int __status) __THROW __attribute__ ((__noreturn__));

/* Register a function to be called when `exit' is called. */

extern int atexit (void (*__func) (void)) __THROW __nonnull ((1));

/* Register a function to be called with the status

given to `exit' and the given argument. */

extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) __THROW __nonnull ((1));

/* Abort execution and generate a core-dump. */

extern void abort (void) __THROW __attribute__ ((__noreturn__));

/* Set NAME to VALUE in the environment.

If REPLACE is nonzero, overwrite an existing value. */

extern int setenv (__const char *__name, __const char *__value, int __replace) __THROW __nonnull ((2));

/* Remove the variable NAME from the environment. */

extern int unsetenv (__const char *__name) __THROW;

/* Execute the given line as a shell command.

This function is a cancellation point and therefore not marked with

__THROW. */

extern int system (__const char *__command) __wur;

#include

/* void assert (int expression);

If NDEBUG is de?ned, do nothing.

If not, and EXPRESSION is zero, print an error message and abort. */

#include

/* Open FILE and return a new ?le descriptor for it, or -1 on error.

OFLAG determines the type of access used. If O_CREAT is on OFLAG,

the third argument is taken as a `mode_t', the mode of the created ?le.

This function is a cancellation point and therefore not marked with

__THROW. */

#ifndef __USE_FILE_OFFSET64

extern int open (__const char *__?le, int __o?ag, …) __nonnull ((1));

#else

# ifdef __REDIRECT

extern int __REDIRECT (open, (__const char *__?le, int __o?ag, …), open64)

__nonnull ((1));

#include

/* Return a string describing the meaning of the `errno' code in ERRNUM. */ extern char *strerror (int __errnum) __THROW;

#include

/* Set scheduling algorithm and/or parameters for a process. */

extern int sched_setscheduler (__pid_t __pid, int __policy,

__const struct sched_param *__param) __THROW;

/*SCHED_OTHER: default policy

SCHED_FIFO: FIFO means the stack, before _OTHER, after hige policy

SCHED_RR: before _OTHER, but when equal, aftered*/

/* Retrieve scheduling algorithm for a particular purpose. */

extern int sched_getscheduler (__pid_t __pid) __THROW;

#include

/* Create a new thread, starting with execution of START-ROUTINE

getting passed ARG. Creation attributed come from ATTR. The new

handle is stored in *NEWTHREAD. */

extern int pthread_create (pthread_t *__restrict __newthread,

__const pthread_attr_t *__restrict __attr,

void *(*__start_routine) (void *),

void *__restrict __arg) __THROW __nonnull ((1, 3));

/* Terminate calling thread.

The registered cleanup handlers are called via exception handling

so we cannot mark this function with __THROW.*/

extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));

/* Make calling thread wait for termination of the thread TH. The

exit status of the thread is stored in *THREAD_RETURN, if THREAD_RETURN is not NULL.

This function is a cancellation point and therefore not marked with

__THROW. */

extern int pthread_join (pthread_t __th, void **__thread_return);

/* Thread attribute handling. */

/* Initialize thread attribute *ATTR with default attributes

(detachstate is PTHREAD_JOINABLE, scheduling policy is SCHED_OTHER,

no user-provided stack). */

extern int pthread_attr_init (pthread_attr_t *__attr) __THROW __nonnull ((1)); /* Destroy thread attribute *ATTR. */

extern int pthread_attr_destroy (pthread_attr_t *__attr)

__THROW __nonnull ((1));

/* Get detach state attribute. */

//default: PTHREAD_CREATE_JONIABLE - _DETACHED unconnectalbe

extern int pthread_attr_getdetachstate (__const pthread_attr_t *__attr,

int *__detachstate)

__THROW __nonnull ((1, 2));

/* Set detach state attribute. */

extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,

int __detachstate)

__THROW __nonnull ((1));

/* Get the size of the guard area created for stack over?ow protection. */ extern int pthread_attr_getguardsize (__const pthread_attr_t *__attr,

size_t *__guardsize)

/* Set the size of the guard area created for stack over?ow protection. */ extern int pthread_attr_setguardsize (pthread_attr_t *__attr,

size_t __guardsize)

__THROW __nonnull ((1));

/* Return in *PARAM the scheduling parameters of *ATTR. */

extern int pthread_attr_getschedparam (__const pthread_attr_t *__restrict

__attr,

struct sched_param *__restrict __param)

__THROW __nonnull ((1, 2));

/* Set scheduling parameters (priority, etc) in *ATTR according to PARAM. */ extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,

__const struct sched_param *__restrict

__param) __THROW __nonnull ((1, 2));

/* Return in *POLICY the scheduling policy of *ATTR. */

//default: SCHED_OTHER - _RR & _FIFO

extern int pthread_attr_getschedpolicy (__const pthread_attr_t *__restrict

__attr, int *__restrict __policy)

__THROW __nonnull ((1, 2));

/* Set scheduling policy in *ATTR according to POLICY. */

extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)

__THROW __nonnull ((1));

/* Return in *INHERIT the scheduling inheritance mode of *ATTR. */

//default: PTHREAD_EXPLICIT_SCHED : by schedpolicy and params con?g

// PTHREAD_INHERIT_SCHED: inherit its parent

extern int pthread_attr_getinheritsched (__const pthread_attr_t *__restrict

__attr, int *__restrict __inherit)

__THROW __nonnull ((1, 2));

/* Set scheduling inheritance mode in *ATTR according to INHERIT. */ extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,

int __inherit)

__THROW __nonnull ((1));

/* Return in *SCOPE the scheduling contention scope of *ATTR. */

//default: PTHREAD_SCOPE_SYSTEM: every pthread occurpied per system time

//the PTHREAD_SCOPE_PROCESS seemed not usable in Linux~

extern int pthread_attr_getscope (__const pthread_attr_t *__restrict __attr,

int *__restrict __scope)

/* Set scheduling contention scope in *ATTR according to SCOPE. */ extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)

__THROW __nonnull ((1));

/* Return the previously set address for the stack. */

extern int pthread_attr_getstackaddr (__const pthread_attr_t *__restrict

__attr, void **__restrict __stackaddr)

__THROW __nonnull ((1, 2)) __attribute_deprecated__;

/* Set the starting address of the stack of the thread to be created.

Depending on whether the stack grows up or down the value must either be higher or lower than all the address in the memory block. The

minimal size of the block must be PTHREAD_STACK_MIN. */

extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,

void *__stackaddr)

__THROW __nonnull ((1)) __attribute_deprecated__;

/* Return the currently used minimal stack size. */

extern int pthread_attr_getstacksize (__const pthread_attr_t *__restrict

__attr, size_t *__restrict __stacksize)

__THROW __nonnull ((1, 2));

/* Add information about the minimum stack size needed for the thread

to be started. This size must never be less than PTHREAD_STACK_MIN and must also not exceed the system limits. */

extern int pthread_attr_setstacksize (pthread_attr_t *__attr,

size_t __stacksize)

__THROW __nonnull ((1));

#ifdef __USE_XOPEN2K

/* Return the previously set address for the stack. */

extern int pthread_attr_getstack (__const pthread_attr_t *__restrict __attr,

void **__restrict __stackaddr,

size_t *__restrict __stacksize)

__THROW __nonnull ((1, 2, 3));

/* The following two interfaces are intended to replace the last two. They require setting the address as well as the size since only setting the

address will make the implementation on some architectures impossible. */ extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,

size_t __stacksize) __THROW __nonnull ((1));

#endif

#ifdef __USE_GNU

/* Thread created with attribute ATTR will be limited to run only on

the processors represented in CPUSET. */

extern int pthread_attr_seta?nity_np (pthread_attr_t *__attr,

size_t __cpusetsize,

__const cpu_set_t *__cpuset)

__THROW __nonnull ((1, 3));

/* Get bit set in CPUSET representing the processors threads created with

ATTR can run on. */

extern int pthread_attr_geta?nity_np (__const pthread_attr_t *__attr,

size_t __cpusetsize,

cpu_set_t *__cpuset)

__THROW __nonnull ((1, 3));

/* Initialize thread attribute *ATTR with attributes corresponding to the

already running thread TH. It shall be called on uninitialized ATTR

and destroyed with pthread_attr_destroy when no longer needed. */

extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)

__THROW __nonnull ((2));

#endif

/* Functions for scheduling control. */

/* Set the scheduling parameters for TARGET_THREAD according to POLICY

and *PARAM. */

extern int pthread_setschedparam (pthread_t __target_thread, int __policy,

__const struct sched_param *__param)

__THROW __nonnull ((3));

/* Return in *POLICY and *PARAM the scheduling parameters for TARGET_THREAD. */

extern int pthread_getschedparam (pthread_t __target_thread,

int *__restrict __policy,

struct sched_param *__restrict __param)

__THROW __nonnull ((2, 3));

/* Functions for handling conditional variables. */

/* Initialize condition variable COND using attributes ATTR, or use

the default values if later is NULL. */

extern int pthread_cond_init (pthread_cond_t *__restrict __cond,

__const pthread_condattr_t *__restrict

__cond_attr) __THROW __nonnull ((1));

/* Destroy condition variable COND. */

extern int pthread_cond_destroy (pthread_cond_t *__cond)

__THROW __nonnull ((1));

/* Wake up one thread waiting for condition variable COND. */

extern int pthread_cond_signal (pthread_cond_t *__cond)

__THROW __nonnull ((1));

/* Wake up all threads waiting for condition variables COND. */

extern int pthread_cond_broadcast (pthread_cond_t *__cond)

__THROW __nonnull ((1));

/* Wait for condition variable COND to be signaled or broadcast.

MUTEX is assumed to be locked before.

This function is a cancellation point and therefore not marked with

__THROW. */

extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,

pthread_mutex_t *__restrict __mutex)

__nonnull ((1, 2));

/* Wait for condition variable COND to be signaled or broadcast until

ABSTIME. MUTEX is assumed to be locked before. ABSTIME is an

absolute time speci?cation; zero is the beginning of the epoch

(00:00:00 GMT, January 1, 1970).

This function is a cancellation point and therefore not marked with

__THROW. */

extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,

pthread_mutex_t *__restrict __mutex,

__const struct timespec *__restrict

__abstime) __nonnull ((1, 2, 3));

/* Functions for handling cancellation.

Note that these functions are explicitly not marked to not throw an

exception in C++ code. If cancellation is implemented by unwinding

this is necessary to have the compiler generate the unwind information. */

/* Set cancelability state of current thread to STATE, returning old

state in *OLDSTATE if OLDSTATE is not NULL. */

extern int pthread_setcancelstate (int __state, int *__oldstate);

/* Set cancellation state of current thread to TYPE, returning the old

type in *OLDTYPE if OLDTYPE is not NULL. */

extern int pthread_setcanceltype (int __type, int *__oldtype);

/* Cancel THREAD immediately or at the next possibility. */

extern int pthread_cancel (pthread_t __th);

/* Test for pending cancellation for the current thread and terminate

the thread as per pthread_exit(PTHREAD_CANCELED) if it has been

cancelled. */

extern void pthread_testcancel (void);

/* Mutex handling. */

/* Initialize a mutex. */

extern int pthread_mutex_init (pthread_mutex_t *__mutex,

__const pthread_mutexattr_t *__mutexattr)

__THROW __nonnull ((1));

/* Destroy a mutex. */

extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)

__THROW __nonnull ((1));

/* Try locking a mutex. */

extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)

__THROW __nonnull ((1));

/* Lock a mutex. */

extern int pthread_mutex_lock (pthread_mutex_t *__mutex)

__THROW __nonnull ((1));

#ifdef __USE_XOPEN2K

/* Wait until lock becomes available, or speci?ed time passes. */

extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,

__const struct timespec *__restrict

__abstime) __THROW __nonnull ((1, 2)); #endif

/* Unlock a mutex. */

extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)

__THROW __nonnull ((1));

loving Delly

yours, Neo