makecontext(3)             Library Functions Manual             makecontext(3)

NUME
       makecontext, swapcontext - manipuleaza contextul utilizatorului

BIBLIOTECA
       Biblioteca C standard (libc, -lc)

SINOPSIS
       #include <ucontext.h>

       void makecontext(ucontext_t *ucp, typeof(void (int arg0, ...)) *func,
                        int argc, ...);
       int swapcontext(ucontext_t *restrict oucp,
                        const ucontext_t *restrict ucp);

DESCRIERE
       Intr-un mediu de tip System V, exista tipul ucontext_t (definit in
       <ucontext.h> <?>i descris in getcontext(3)) <?>i cele patru func<?>ii
       getcontext(3), setcontext(3), makecontext() <?>i swapcontext() care
       permit comutarea contextului la nivel de utilizator intre mai multe
       fire de control in cadrul unui proces.

       Func<?>ia makecontext() modifica contextul indicat de ucp (care a fost
       ob<?>inut in urma unui apel la getcontext(3)).  Inainte de a invoca
       makecontext(), apelantul trebuie sa aloce o noua stiva pentru acest
       context <?>i sa ii atribuie adresa lui ucp->uc_stack, precum <?>i sa
       defineasca un context succesor <?>i sa ii atribuie adresa lui
       ucp->uc_link.

       Atunci cand acest context este activat ulterior (utilizand
       setcontext(3) sau swapcontext()), func<?>ia func este apelata <?>i i se
       transmite seria de argumente intregi (int) care urmeaza dupa argc;
       apelantul trebuie sa specifice numarul acestor argumente in argc.
       Atunci cand aceasta func<?>ie returneaza, contextul succesor este
       activat.  Daca indicatorul contextului succesor este NULL, firul de
       execu<?>ie iese.

       Func<?>ia swapcontext() salveaza contextul curent in structura indicata
       de oucp, iar apoi activeaza contextul indicat de ucp.

VALOAREA RETURNATA
       Atunci cand reu<?>e<?>te, swapcontext() nu returneaza. (Dar am putea
       reveni mai tarziu, in cazul in care oucp este activat, caz in care se
       pare ca swapcontext() returneaza 0.) In caz de eroare, swapcontext()
       returneaza -1 <?>i configureaza errno pentru a indica eroarea.

ERORI-IE<?>IRE
       ENOMEM Spa<?>iu ramas in stiva insuficient.

ATRIBUTE
       Pentru o explica<?>ie a termenilor folosi<?>i in aceasta sec<?>iune, a
       se vedea attributes(7).

       +--------------+---------------------+---------------------------------+
       |Interfa<?>a   | Atribut             | Valoare                         |
       +--------------+---------------------+---------------------------------+
       |makecontext() | Siguran<?>a firelor | MT-Safe race:ucp                |
       +--------------+---------------------+---------------------------------+
       |swapcontext() | Siguran<?>a firelor | MT-Safe race:oucp race:ucp      |
       +--------------+---------------------+---------------------------------+
STANDARDE
       Niciunul.

ISTORIC
       glibc 2.1.  SUSv2, POSIX.1-2001. Eliminata in POSIX.1-2008, citand
       probleme de portabilitate <?>i recomandand ca aplica<?>iile sa fie
       rescrise pentru a utiliza in schimb fire POSIX.

NOTE
       Interpretarea ucp->uc_stack este la fel ca in sigaltstack(2), <?>i
       anume, aceasta structura con<?>ine inceputul <?>i lungimea unei zone de
       memorie care urmeaza sa fie utilizata ca stiva, indiferent de
       direc<?>ia de cre<?>tere a stivei. Astfel, nu este necesar ca programul
       utilizatorului sa se preocupe de aceasta direc<?>ie.

       Pe arhitecturile in care tipurile int <?>i indicatorul sunt de
       aceea<?>i dimensiune (de exemplu, x86-32, unde ambele tipuri sunt de 32
       de bi<?>i), este posibil sa pute<?>i scapa pasand indicatorii ca
       argumente la makecontext() dupa argc. Cu toate acestea, acest lucru nu
       este garantat a fi portabil, nu este definit in conformitate cu
       standardele <?>i nu va func<?>iona pe arhitecturile in care indicatorii
       sunt mai mari decat int-urile.  Cu toate acestea, incepand cu glibc
       2.8, glibc face unele modificari la makecontext(), pentru a permite
       acest lucru pe unele arhitecturi pe 64 de bi<?>i (de exemplu, x86-64).

EXEMPLE
       Programul de exemplu de mai jos demonstreaza utilizarea getcontext(3),
       makecontext() <?>i swapcontext(). Rularea programului produce
       urmatoarea ie<?>ire:

           $ ./a.out
           main: swapcontext(&uctx_main, &uctx_func2)
           func2: ini<?>iata
           func2: swapcontext(&uctx_func2, &uctx_func1)
           func1: ini<?>iata
           func1: swapcontext(&uctx_func1, &uctx_func2)
           func2: returnand
           func1: returnand
           main: se iese

   Sursa programului
       #include <stdio.h>
       #include <stdlib.h>
       #include <ucontext.h>

       static ucontext_t uctx_main, uctx_func1, uctx_func2;

       #define handle_error(msg) \
           do { perror(msg); exit(EXIT_FAILURE); } while (0)

       static void
       func1(void)
       {
           printf("%s: ini<?>iata\n", __func__);
           printf("%s: swapcontext(&uctx_func1, &uctx_func2)\n", __func__);
           if (swapcontext(&uctx_func1, &uctx_func2) == -1)
               handle_error("swapcontext");
           printf("%s: returnand\n", __func__);
       }

       static void
       func2(void)
       {
           printf("%s: ini<?>iata\n", __func__);
           printf("%s: swapcontext(&uctx_func2, &uctx_func1)\n", __func__);
           if (swapcontext(&uctx_func2, &uctx_func1) == -1)
               handle_error("swapcontext");
           printf("%s: returnand\n", __func__);
       }

       int
       main(int argc, char *argv[])
       {
           char func1_stack[16384];
           char func2_stack[16384];

           if (getcontext(&uctx_func1) == -1)
               handle_error("getcontext");
           uctx_func1.uc_stack.ss_sp = func1_stack;
           uctx_func1.uc_stack.ss_size = sizeof(func1_stack);
           uctx_func1.uc_link = &uctx_main;
           makecontext(&uctx_func1, func1, 0);

           if (getcontext(&uctx_func2) == -1)
               handle_error("getcontext");
           uctx_func2.uc_stack.ss_sp = func2_stack;
           uctx_func2.uc_stack.ss_size = sizeof(func2_stack);
           /* Contextul succesor este f1(), cu excep<?>ia cazului in care argc > 1 */
           uctx_func2.uc_link = (argc > 1) ? NULL : &uctx_func1;
           makecontext(&uctx_func2, func2, 0);

           printf("%s: swapcontext(&uctx_main, &uctx_func2)\n", __func__);
           if (swapcontext(&uctx_main, &uctx_func2) == -1)
               handle_error("swapcontext");

           printf("%s: se iese\n", __func__);
           exit(EXIT_SUCCESS);
       }

CONSULTA<?>I <?>I
       sigaction(2), sigaltstack(2), sigprocmask(2), getcontext(3),
       sigsetjmp(3)

TRADUCERE
       Traducerea in limba romana a acestui manual a fost facuta de Remus-
       Gabriel Chelu <remusgabriel.chelu@disroot.org>

       Aceasta traducere este documenta<?>ie gratuita; citi<?>i Licen<?>a
       publica generala GNU Versiunea 3
       <https://www.gnu.org/licenses/gpl-3.0.html> sau o versiune ulterioara
       cu privire la condi<?>ii privind drepturile de autor.  NU se asuma
       NICIO RESPONSABILITATE.

       Daca gasi<?>i erori in traducerea acestui manual, va rugam sa
       trimite<?>i un e-mail la <translation-team-ro@lists.sourceforge.net>.

Pagini de manual de Linux 6.12 13 decembrie 2024                makecontext(3)