NAME

       thr_new — create new thread of execution

LIBRARY

       Standard C Library (libc, -lc)

SYNOPSIS

       #include <sys/thr.h>

       int
       thr_new(struct thr_param *param, int param_size);

DESCRIPTION

       This  function is intended for implementing threading.  Normal applications should call pthread_create(3)
       instead.

       The thr_new() system call creates a new kernel-scheduled thread  of  execution  in  the  context  of  the
       current process.  The newly created thread shares all attributes of the process with the existing kernel-
       scheduled threads in the process, but has private processor execution state.  The machine context for the
       new  thread  is  copied  from  the creating thread's context, including coprocessor state.  FPU state and
       specific machine registers are excluded from the copy.  These are set according to ABI  requirements  and
       syscall parameters.  The FPU state for the new thread is reinitialized to clean.

       The  param  structure supplies parameters affecting the thread creation.  The structure is defined in the
       <sys/thr.h> header as follows

       struct thr_param {
           void          (*start_func)(void *);
           void          *arg;
           char          *stack_base;
           size_t        stack_size;
           char          *tls_base;
           size_t        tls_size;
           long          *child_tid;
           long          *parent_tid;
           int           flags;
           struct rtprio *rtp;
       };
       and contains the following fields:

       start_func  Pointer to the thread entry function.  The kernel  arranges  for  the  new  thread  to  start
                   executing the function upon the first return to userspace.

       arg         Opaque argument supplied to the entry function.

       stack_base  Stack  base  address.  The stack must be allocated by the caller.  On some architectures, the
                   ABI might require that the system put information  on  the  stack  to  ensure  the  execution
                   environment for start_func.

       stack_size  Stack size.

       tls_base    TLS  base  address.  The value of TLS base is loaded into the ABI-defined machine register in
                   the new thread context.

       tls_size    TLS size.

       child_tid   Address to store the new thread identifier, for the child's use.

       parent_tid  Address to store the new thread identifier, for the parent's use.

                   Both child_tid and parent_tid are provided, with the intent that child_tid is used by the new
                   thread to get its thread identifier without issuing the thr_self(2) syscall, while parent_tid
                   is used by the thread creator.  The latter is separate from child_tid because the new  thread
                   might  exit  and free its thread data before the parent has a chance to execute far enough to
                   access it.

       flags       Thread creation flags.  The flags member may specify the following flags:

                   THR_SUSPENDED     Create the new thread in the suspended state.  The flag  is  not  currently
                                     implemented.

                   THR_SYSTEM_SCOPE  Create the system scope thread.  The flag is not currently implemented.

       rtp         Real-time  scheduling  priority for the new thread.  May be NULL to inherit the priority from
                   the creating thread.

       The param_size argument should be set to the size of the param structure.

       After the first successful creation of an additional thread, the process  is  marked  by  the  kernel  as
       multi-threaded.  In particular, the P_HADTHREADS flag is set in the process' p_flag (visible in the ps(1)
       output),  and several operations are executed in multi-threaded mode.  For instance, the execve(2) system
       call terminates all threads but the calling one on successful execution.

RETURN VALUES

       If successful, thr_new() will return zero, otherwise -1 is returned, and errno is  set  to  indicate  the
       error.

ERRORS

       The thr_new() operation returns the following errors:

       [EFAULT]           The memory pointed to by the param argument is not valid.

       [EFAULT]           The memory pointed to by the param structure child_tid, parent_tid or rtp arguments is
                          not valid.

       [EFAULT]           The  specified stack base is invalid, or the kernel was unable to put required initial
                          data on the stack.

       [EINVAL]           The param_size argument specifies a negative value, or the value is greater  than  the
                          largest struct param size the kernel can interpret.

       [EINVAL]           The rtp member is not NULL and specifies invalid scheduling parameters.

       [EINVAL]           The specified TLS base is invalid.

       [EPERM]            The  caller  does  not  have permission to set the scheduling parameters or scheduling
                          policy.

       [EPROCLIM]         Creation of the new thread would exceed the RACCT_NTHR limit, see racct(2).

       [EPROCLIM]         Creation  of  the  new  thread  would  exceed  the   kern.threads.max_threads_per_proc
                          sysctl(2) limit.

       [ENOMEM]           There was not enough kernel memory to allocate the new thread structures.

SEE ALSO

       ps(1),   execve(2),  racct(2),  thr_exit(2),  thr_kill(2),  thr_kill2(2),  thr_self(2),  thr_set_name(2),
       _umtx_op(2), pthread_create(3)

STANDARDS

       The thr_new() system call is non-standard and is used by the 1:1 Threading  Library  (libthr,  -lthr)  to
       implement IEEE Std 1003.1-2001 (“POSIX.1”) pthread(3) functionality.

Debian                                            June 2, 2016                                        THR_NEW(2)