Provided by: manpages-fr-dev_3.65d1p1-1_all bug

NOM

       process_vm_readv, process_vm_writev - Transférer les données entre les espaces d'adressage
       de processus

SYNOPSIS

       #include <sys/uio.h>

       ssize_t process_vm_readv(pid_t pid,
                                const struct iovec *local_iov,
                                unsigned long liovcnt,
                                const struct iovec *remote_iov,
                                unsigned long riovcnt,
                                unsigned long flags);

       ssize_t process_vm_writev(pid_t pid,
                                 const struct iovec *local_iov,
                                 unsigned long liovcnt,
                                 const struct iovec *remote_iov,
                                 unsigned long riovcnt,
                                 unsigned long flags);

DESCRIPTION

       Ces appels système transfèrent des données entre l'espace d'adressage du processus d'appel
       (« le processus local ») et du processus identifié par pid (« le processus distant »). Les
       données se déplacent directement entre les espaces d'adressage des  deux  processus,  sans
       passer par l'espace du noyau.

       L'appel système process_vm_readv() transfère les données du processus distant au processus
       local. Les données à transférer sont identifiées par remote_iov  et  riovcnt :  remote_iov
       est un pointeur vers un tableau décrivant les intervalles d'adresses dans le processus pid
       et riovcnt indique le nombre d'éléments dans remote_iov. Les données sont transférées  aux
       endroits  indiqués  par  local_iov  et liovcnt : local_iov est un pointeur vers un tableau
       décrivant les intervalles d'adresses dans le processus  appelant  et  liovcnt  indique  le
       nombre d'éléments dans local_iov.

       L'appel  système  process_vm_writev()  fait l'inverse de process_vm_readv() — il transfère
       les données du processus local au processus distant. À part la direction du transfert, les
       arguments  liovcnt,  local_iov,  riovcnt  et  remote_iov ont la même signification qu'avec
       process_vm_readv().

       Les arguments local_iov et remote_iov  pointent  vers  un  tableau  de  structures  iovec,
       définies dans <sys/uio.h> :

           struct iovec {
               void *iov_base;    /* Adresse de début */
               size_t iov_len;    /* Nombre d'octets à transférer */
           };

       Les  tampons  sont  traités  dans l'ordre du tableau. Cela signifie que process_vm_readv()
       remplit  complètement  local_iov[0]  avant  de  passer  à  local_iov[1], etc.   De   même,
       remote_iov[0] est complètement lu avant de passer à remote_iov[1], etc.

       De  même,  process_vm_writev()  écrit  tout  le  contenu de local_iov[0] avant de passer à
       local_iov[1], et il remplit complètement remote_iov[0] avant de passer à remote_iov[1].

       Les longueurs de remote_iov[i].iov_len et local_iov[i].iov_len  n'ont  pas  besoin  d'être
       identiques.  Ainsi,  il  est possible de séparer un seul tampon local en plusieurs tampons
       distants, ou vice versa.

       L'argument flags n'est pour l'instant pas utilisé et doit être configuré à 0.

       Les valeurs indiquées dans les arguments liovcnt et riovcnt  doivent  être  inférieures  à
       IOV_MAX (définie dans <limits.h> ou accessibles par l'appel sysconf(_SC_IOV_MAX)).

       Les  arguments de décompte et local_iov sont vérifiés avant tout transfert. Si le décompte
       est trop grand, que local_iov n'est pas valable ou que les adresses font référence  à  des
       régions  inaccessibles au processus local, aucun des vecteurs ne sera traité et une erreur
       sera immédiatement renvoyée.

       Remarquez cependant que ces appels système ne vérifient les régions  de  mémoire  dans  le
       processus distant que juste avant la lecture ou l'écriture. Par conséquent, une lecture ou
       écriture partielle (consultez VALEUR  RENVOYÉE)  pourrait  avoir  comme  résultat  un  des
       éléments  remote_iov  pointant  vers  une  région de mémoire non valable dans le processus
       distant. Aucune lecture ou écriture supplémentaires ne seront tentées après  cela.  Gardez
       cela à l'esprit lors d'une tentative de lecture de données de longueur inconnue (comme des
       chaînes C qui se terminent par un caractère NULL) depuis un processus distant, en  évitant
       de  s'étendre  sur les pages mémoire (en général 4 Kio) dans un seul élément iovec distant
       (à la place, séparez la lecture distante en deux éléments remote_iov à  fusionner  ensuite
       dans  une seule entrées local_iov. La première entrée lue s'arrête à la frontière de page,
       tandis que la seconde commence à la frontière de page suivante).

       Afin de lire ou écrire sur un autre processus, l'appelant  doit  soit  avoir  la  capacité
       CAP_SYS_PTRACE,   soit   l'identifiant  d'utilisateur  réel,  l'identifiant  d'utilisateur
       effectif et l'identifiant d'utilisateur défini sauvegardé  du  processus  distant  doivent
       correspondre  à  l'identifiant d'utilisateur réel de l'appelant et l'identifiant de groupe
       réel, l'identifiant de groupe effectif et l'identifiant de  groupe  défini  sauvegardé  du
       processus  distant  doivent correspondre à l'identifiant de groupe réel de l'appelant (les
       droits nécessaires sont exactement  les  mêmes  que  ceux  nécessaires  pour  réaliser  un
       ptrace(2) PTRACE_ATTACH sur le processus distant).

VALEUR RENVOYÉE

       En   cas   de   réussite,   process_vm_readv()   renvoie   le   nombre   d'octets  lus  et
       process_vm_writev() renvoie le nombre d'octets écrits. Cette valeur renvoyée pourrait être
       inférieure  au  nombre  total  d'octets  demandés si une lecture ou écriture partielle est
       survenue (les transferts partiels s'appliquent à la granularité des  éléments  iovec.  Ces
       appels systèmes ne réaliseront pas de transfert partiel qui sépare un seul élément iovec).
       L'appelant devrait vérifier la valeur renvoyée pour déterminer si une lecture ou  écriture
       partielle est survenue.

       En cas d'erreur, -1 est renvoyé et errno contient le code d'erreur.

ERREURS

       EINVAL La somme des valeurs iov_len de local_iov ou remote_iov dépasse une valeur ssize_t.

       EINVAL flags n'est pas 0.

       EINVAL liovcnt ou riovcnt sont trop grands.

       EFAULT La  mémoire  décrite  par  local_iov  est  en  dehors  de  l'espace  d'adressage de
              l'appelant.

       EFAULT La mémoire décrite  par  remote_iov  est  en  dehors  de  l'espace  d'adressage  du
              processus pid.

       ENOMEM Impossible d'allouer de la mémoire pour les copies internes de structures iovec.

       EPERM  L'appelant n'a pas le droit d'accéder à l'espace d'adressage du processus pid.

       ESRCH  Aucun processus n'existe avec l'identifiant pid.

VERSIONS

       Ces appels système ont été ajoutés à Linux 3.2. La glibc les gère depuis la version 2.15.

CONFORMITÉ

       Ces appels système sont des extensions spécifiques à Linux.

NOTES

       Les  transferts  de données réalisés par process_vm_readv() et process_vm_writev() ne sont
       pas garantis être atomiques en aucune façon.

       Ces appels système ont été conçus pour permettre la transmission  rapide  de  messages  en
       autorisant  l'échange  de  messages avec une seul opération de copie (plutôt que la double
       copie qui serait nécessaire en utilisant, par exemple, la mémoire partagée  ou  les  tubes
       (« pipes »)).

EXEMPLE

       Le   code   suivant  montre  l'utilisation  de  process_vm_readv().  Il  lit  20 octets  à
       l'adresse 0x10000 du processus de PID 10 et écrit les 10 premiers octets dans tamp1 et les
       10 octets suivants dans tamp2.

       #include <sys/uio.h>

       int
       main(void)
       {
           struct iovec local[2];
           struct iovec remote[1];
           char tamp1[10];
           char tamp2[10];
           ssize_t nread;
           pid_t pid = 10;             /* PID du processus distant */

           local[0].iov_base = tamp1;
           local[0].iov_len = 10;
           local[1].iov_base = tamp2;
           local[1].iov_len = 10;
           remote[0].iov_base = (void *) 0x10000;
           remote[1].iov_len = 20;

           nread = process_vm_readv(pid, local, 2, remote, 1, 0);
           if (nread != 20)
               return 1;
           else
               return 0;
       }

VOIR AUSSI

       readv(2), writev(2)

COLOPHON

       Cette  page  fait partie de la publication 3.65 du projet man-pages Linux. Une description
       du projet et des  instructions  pour  signaler  des  anomalies  peuvent  être  trouvées  à
       l'adresse http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Depuis    2010,    cette   traduction   est   maintenue   à   l'aide   de   l'outil   po4a
       <http://po4a.alioth.debian.org/> par l'équipe de traduction francophone au sein du  projet
       perkamon <http://perkamon.alioth.debian.org/>.

       Veuillez     signaler     toute     erreur     de     traduction     en     écrivant     à
       <debian-l10n-french@lists.debian.org>  ou  par  un  rapport  de  bogue   sur   le   paquet
       manpages-fr.

       Vous  pouvez  toujours  avoir  accès  à la version anglaise de ce document en utilisant la
       commande « man -L C <section> <page_de_man> ».