The OpenNET Project / Index page

[ новости /+++ | форум | wiki | теги | ]

Интерактивная система просмотра системных руководств (man-ов)

 [Cписок руководств | Печать]

_lwp_create (2)
  • >> _lwp_create (2) ( Solaris man: Системные вызовы )
         _lwp_create - create a new light-weight process
         #include <sys/lwp.h>
         int _lwp_create(ucontext_t *contextp, unsigned  long  flags,
         lwpid_t *new_lwp);
         The _lwp_create() function adds a lightweight process  (LWP)
         to  the current process. The contextp argument specifies the
         initial signal mask, stack, and machine  context  (including
         the  program counter and stack pointer) for the new LWP. The
         new LWP inherits the scheduling class and  priority  of  the
         If _lwp_create() is successful and  new_lwp is not null, the
         ID  of  the  new LWP is stored in the location pointed to by
         The flags argument specifies additional attributes  for  the
         new  LWP.  The  value in flags is constructed by the bitwise
         inclusive OR operation of the following values:
               The LWP is created detached.
               The LWP is created suspended.
               The LWP created is  the  ASLWP  (Asynchronous  Signals
               LWP)  (see signal(3HEAD)).  The ASLWP should always be
               created with all signals blocked.  If  __LWP_ASLWP  is
               specified, then the LWP created is the special, desig-
               nated LWP that handles signals sent to a multithreaded
               process   (ASLWP).  There  can be only one ASLWP  in a
               multithreaded process,  so  the  creation  of  another
               ASLWP  will return EINVAL. It should never exit by way
               of   _lwp_exit(2) or exit(2).  This is a reserved flag
               and  should  not  be  used  by any user program. It is
               documented here for the sake of completion and not for
               use by an application.
         If LWP_DETACHED is specified, then the LWP is created in the
         detached  state.  Otherwise  the LWP is created in the unde-
         tached state.  The ID (and system resources) associated with
         a  detached  LWP can be automatically reclaimed when the LWP
         exits. The ID of an undetached LWP cannot be reclaimed until
         it exits and another LWP has reported its termination by way
         of _lwp_wait(2). This allows the waiting  LWP  to  determine
         that  the  waited  for LWP has terminated and to reclaim any
         process resources that it was using.
         If LWP_SUSPENDED is specified, then the LWP is created in  a
         suspended state. This allows the creator to change the LWP's
         inherited  attributes  before  it  starts  to  execute.  The
         suspended    LWP   can   only   be   resumed   by   way   of
         _lwp_continue(2). If LWP_SUSPENDED is not specified the  LWP
         can begin to run immediately after it has been created.
         Upon successful completion, 0 is returned. A non-zero  value
         indicates an error.
         If  any  of   the   following   conditions   are   detected,
         _lwp_create() fails and returns the corresponding value:
               Either the context parameter or the new_lwp  parameter
               point to invalid addresses.
               A system limit is exceeded, (for example, too many LWP
               were created for this real user ID).
               The __LWP_ASLWP flag was used to create more than  one
               ASLWP  in  the  process.  There can be only one  ASLWP
               within a process.
         Example 1: How a stack is allocated to a new LWP.
         This example shows how a stack is allocated to  a  new  LWP.
         The  _lwp_makecontext()  function is used to set up the con-
         text parameter so that the new LWP begins executing a  func-
         contextp = (ucontext_t *)malloc(sizeof(ucontext_t));
         stackbase = malloc(stacksize);
         sigprocmask(SIGSETMASK, NULL, &contextp->uc_sigmask);
         _lwp_makecontext(contextp, func, arg, private, stackbase, stacksize);
         error = _lwp_create(contextp, NULL, &new_lwp);
         _lwp_cond_timedwait(2),   _lwp_continue(2),    _lwp_exit(2),
         _lwp_makecontext(2),    _lwp_wait(2),   alarm(2),   exit(2),
         poll(2),   sleep(3C),    thr_create(3THR),    signal(3HEAD),
         Applications  should  use  bound  threads  rather  than  the
         _lwp_*()  functions  (see   thr_create(3THR)).  Using   LWPs
         directly is not advised because libraries are only  safe  to
         use with threads, not LWPs.
         In Solaris releases 2.5 through 7, the  signal   SIGALRM  is
         defined to be per-process. This does not affect the behavior
         of single-threaded or multithreaded  applications.   If  the
         application  was  using   LWPs  directly, and was relying on
         alarm(2) or
          sleep(3C),  then  the  application's  behavior   might   be
          The calling LWP will not necessarily be  the  recipient  of
         the   SIGARLM  signal  when  SIGALRM is sent to the process.
         You might  have  to  use  a  substitute  like   poll(2),  or
         _lwp_cond_timedwait(2)  to simulate the old per-LWP semantic
         of  SIGALRM.

    Поиск по тексту MAN-ов: 

    Inferno Solutions
    Hosting by

    Закладки на сайте
    Проследить за страницей
    Created 1996-2021 by Maxim Chirkov
    Добавить, Поддержать, Вебмастеру