.\" -*- coding: UTF-8 -*- .\" Copyright 1993 Giorgio Ciucci (giorgio@crcc.it) .\" and Copyright 2020 Michael Kerrisk .\" .\" SPDX-License-Identifier: Linux-man-pages-copyleft .\" .\" Modified Sun Nov 28 17:06:19 1993, Rik Faith (faith@cs.unc.edu) .\" with material from Luigi P. Bai (lpb@softint.com) .\" Portions Copyright 1993 Luigi P. Bai .\" Modified Tue Oct 22 22:04:23 1996 by Eric S. Raymond .\" Modified, 5 Jan 2002, Michael Kerrisk .\" Modified, 19 Sep 2002, Michael Kerrisk .\" Added SHM_REMAP flag description .\" Modified, 27 May 2004, Michael Kerrisk .\" Added notes on capability requirements .\" Modified, 11 Nov 2004, Michael Kerrisk .\" Language and formatting clean-ups .\" Changed wording and placement of sentence regarding attachment .\" of segments marked for destruction .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH SHMOP 2 "3 mai 2023" "Pages du manuel de Linux 6.05.01" .SH NOM shmat, shmdt \- Opérations sur la mémoire partagée System\ V .SH BIBLIOTHÈQUE Bibliothèque C standard (\fIlibc\fP, \fI\-lc\fP) .SH SYNOPSIS .nf \fB#include \fP .PP \fBvoid *shmat(int \fP\fIshmid\fP\fB, const void *_Nullable \fP\fIshmaddr\fP\fB, int \fP\fIshmflg\fP\fB);\fP \fBint shmdt(const void *\fP\fIshmaddr\fP\fB);\fP .fi .SH DESCRIPTION .SS shmat() La fonction \fBshmat\fP() attache le segment de mémoire partagée System\ V identifié par \fIshmid\fP au segment de données du processus appelant. L'adresse d'attachement est indiquée par \fIshmaddr\fP avec les critères suivants\ : .IP \- 3 Si \fIshmaddr\fP vaut NULL, le système choisit une adresse (non utilisée) alignée sur la page convenant pour attacher le segment. .IP \- Si \fIshmaddr\fP n'est pas NULL et si \fBSHM_RND\fP est indiqué dans \fIshmflg\fP, l'attachement a lieu à l'adresse égale à \fIshmaddr\fP arrondie au multiple inférieur de \fBSHMLBA\fP. .IP \- Sinon, \fIshmaddr\fP doit être alignée sur une frontière de page, où l'attachement a lieu. .PP En plus de \fBSHM_RND\fP, les attributs suivants peuvent être indiqués dans le paramètre de masque \fIshmflg\fP\ : .TP \fBSHM_EXEC\fP (spécifique à Linux, depuis Linux\ 2.6.9) Autoriser l'exécution du contenu du segment. L'appelant doit disposer du droit d'exécution sur le segment. .TP \fBSHM_RDONLY\fP Attacher le segment en lecture seule. Le processus doit disposer de la permission de lecture dessus. Si cet attribut n'est pas indiqué, le segment est attaché en lecture et écriture, et le processus doit disposer des deux permissions d'accès. Il n'y a pas de notion d'écriture seule pour les segments de mémoire partagée. .TP \fBSHM_REMAP\fP (spécifique à Linux) Cet attribut indique que la projection du segment doit remplacer une projection précédente dans l'intervalle commençant en \fIshmaddr\fP et s'étendant sur la taille du segment. Normalement une erreur \fBEINVAL\fP devrait se produire si une projection existe déjà dans l'intervalle indiqué. Dans ce cas, \fIshmaddr\fP ne doit pas être \fBNULL\fP. .PP La valeur \fBbrk\fP(2) du processus appelant n'est pas altérée par l'attachement. Le segment est automatiquement détaché quand le processus se termine. Le même segment peut être attaché à la fois en lecture seule et en lecture/écriture. Il peut également être attaché en plusieurs endroits de l'espace d'adressage du processus. .PP Quand \fBshmat\fP() réussit, les membres de la structure \fIshmid_ds\fP associée au segment de mémoire partagée (consultez \fBshmctl\fP(2)) sont mis à jour ainsi\ : .IP \- 3 \fIshm_atime\fP correspond à l'heure actuelle. .IP \- \fIshm_lpid\fP contient le PID de l'appelant. .IP \- .\" \fIshm_nattch\fP est incrémenté de 1. .SS shmdt() La fonction \fBshmdt\fP() détache le segment de mémoire partagée situé à l'adresse indiquée par \fIshmaddr\fP. Le segment doit être effectivement attaché, et l'adresse \fIshmaddr\fP doit être celle renvoyée précédemment par l'appel \fBshmat\fP(). .PP Quand \fBshmdt\fP() réussit, les membres de la structure \fIshmid_ds\fP associée au segment de mémoire partagée sont mis à jour ainsi par le système\ : .IP \- 3 \fIshm_dtime\fP correspond à l'heure actuelle. .IP \- \fIshm_lpid\fP contient le PID de l'appelant. .IP \- \fIshm_nattch\fP est décrémenté de 1. S'il devient nul et si le segment est marqué pour destruction, il est effectivement détruit. .SH "VALEUR RENVOYÉE" S'il réussit, \fBshmat\fP() renvoie l'adresse d'attachement du segment de mémoire partagée. En cas d'échec \fI(void\ *)\ \-1\fP est renvoyé, et \fIerrno\fP est positionné pour indiquer l'erreur. .PP S'il réussit, \fBshmdt\fP() renvoie \fB0\fP. En cas d'échec, \fB\-1\fP est renvoyé et \fIerrno\fP est positionné pour indiquer l'erreur. .SH ERREURS \fBshmat\fP() peut échouer avec une des erreurs suivantes : .TP \fBEACCES\fP Le processus appelant n'a pas les permissions d'accès nécessaires pour ce type d'attachement et n'a pas la capacité \fBCAP_IPC_OWNER\fP dans l'espace de noms utilisateur qui gère son espace de noms IPC. .TP \fBEIDRM\fP \fIshmid\fP pointe sur un segment détruit. .TP \fBEINVAL\fP La valeur \fIshmid\fP n'est pas valable, mal alignée (c'est\-à\-dire pas alignée sur une page et \fBSHM_RND\fP n'a pas été précisé) ou la valeur \fIshmaddr\fP n'est pas valable, ou ne peut pas être attaché à \fIshmaddr\fP, ou \fBSHM_REMAP\fP a été réclamé et \fIshmaddr\fP est \fBNULL\fP. .TP \fBENOMEM\fP Pas assez de mémoire pour le descripteur ou pour les tables de pages. .PP \fBshmdt\fP() peut échouer avec une des erreurs suivantes : .TP \fBEINVAL\fP .\" The following since Linux 2.6.17-rc1: Aucun segment de mémoire partagée n'est attaché à l'adresse \fIshmaddr\fP, ou bien \fIshmaddr\fP n'est pas aligné une limite de page. .SH STANDARDS POSIX.1\-2008. .SH HISTORIQUE .\" SVr4 documents an additional error condition EMFILE. POSIX.1\-2001, SVr4. .PP Dans SVID\ 3 (ou peut être auparavant), le type de l'argument \fIshmaddr\fP a été modifié de \fIchar\ *\fP en \fIconst void\ *\fP, et le type de retour de \fBshmat\fP() de \fIchar\ *\fP en \fIvoid\ *\fP. .SH NOTES Après un \fBfork\fP(2), l'enfant hérite des segments de mémoire partagée attachés. .PP Après un \fBexecve\fP(2), tous les segments de mémoire partagée sont détachés du (pas détruits). .PP Lors d'un \fB_exit\fP(2), tous les segments de mémoire partagée sont détachés du processus (pas détruits). .PP Utiliser \fBshmat\fP() avec \fIshmaddr\fP égale à NULL est la manière conseillée et portable d'attacher un segment de mémoire partagée. Soyez conscients que le segment attaché de cette manière peut l'être à des adresses différentes dans les différents processus. Ainsi, tout pointeur contenu dans la mémoire partagée doit être relatif (habituellement par rapport à l'adresse de départ du segment) et pas absolu. .PP Sous Linux, il est possible d'attacher un segment de mémoire partagée qui est déjà marqué pour effacement. Cependant, ce comportement n'est pas décrit par POSIX.1 et beaucoup d'autres implémentations ne le permettent pas. .PP Le paramètre système suivant influe sur \fBshmat\fP()\ : .TP \fBSHMLBA\fP Multiple d’adresse pour limite basse de segment. Lors d’une indication explicite d’adresse d’attache dans un appel \fBshmat\fP(), l’appelant devrait s’assurer que l’adresse est un multiple de cette valeur. Cela est nécessaire sur certaines architectures, afin de s’assurer soit de bonne performances du cache de processeur, soit que différentes attaches du même segment ont des vues cohérentes dans le cache du processeur. \fBSHMLBA\fP est normalement un multiple de la taille de page du système (sur de nombreuses architectures Linux, \fBSHMLBA\fP est identique à la taille de page du système). .PP L'implémentation ne met pas de limite intrinsèque par processus pour le nombre maximal de segments de mémoire partagée (\fBSHMSEG\fP). .SH EXEMPLES Les deux programmes présentés ci\-dessous échangent une chaîne en utilisant un segment de mémoire partagée. Davantage de détails à leur sujet sont donnés ci\-dessous. Tout d'abord, nous présentons une session d'interpréteur qui montre leur utilisation. .PP Dans une fenêtre de terminal, nous exécutons le programme «\ reader\ » qui crée un segment de mémoire partagée System\ V et un ensemble de sémaphores System\ V. Le programme affiche les identifiants des objets créés puis attend que le sémaphore modifie la valeur. .PP .in +4n .EX $ \fB./svshm_string_read\fP shmid = 1114194; semid = 15 .EE .in .PP Dans une autre fenêtre de terminal, on exécute le programme «\ writer\ ». Ce programme prend trois paramètres en ligne de commande\ : les identifiants du segment de mémoire partagée et le jeu de sémaphore, créés par le programme «\ reader\ » et une chaîne. Il attache le segment de mémoire partagée existant, copie la chaîne dans la mémoire partagée et modifie la valeur du sémaphore. .PP .in +4n .EX $ \fB./svshm_string_write 1114194 15 \[aq]Bonjour\[aq]\fP .EE .in .PP De retour dans le terminal où s'exécute «\ reader\ », on voit que le programme a cessé d'attendre le sémaphore et affiche la chaîne copiée dans le segment de mémoire partagée par «\ writer\ »\ : .PP .in +4n .EX Bonjour .EE .in .\" .SS "Source du programme\ : svshm_string.h" Le fichier d'en\-tête suivant est inclus dans les programmes «\ reader\ » et «\ writer\ »\ : .PP .in +4n .\" SRC BEGIN (svshm_string.h) .EX /* svshm_string.h \& Sous licence GNU General Public v2 ou postérieure. */ #include #include #include #include #include #include #include \& #define errExit(msg) do { perror(msg); exit(EXIT_FAILURE); \e } while (0) \& union semun { /* Utilisé dans les appels semctl() */ int val; struct semid_ds * buf; unsigned short * array; #if defined(__linux__) struct seminfo * __buf; #endif }; \& #define MEM_SIZE 4096 .EE .\" SRC END .in .\" .SS "Source du programme\ : svshm_string_read.c" Le programme «\ reader\ » crée un segment de mémoire partagée et un ensemble de sémaphores contenant un sémaphore. Il attache ensuite l'objet en mémoire partagée à son espace d'adressage et initialise la valeur du sémaphore à \fB1\fP. Enfin, il attend que la valeur du sémaphore devienne \fB0\fP, après quoi il affiche la chaîne qui a été copiée dans le segment de mémoire partagée par «\ writer\ ». .PP .in +4n .\" SRC BEGIN (svshm_string_read.c) .EX /* svshm_string_read.c \& Sous licence GNU General Public v2 ou postérieure. */ #include #include #include #include #include \& #include "svshm_string.h" \& int main(void) { int semid, shmid; char *addr; union semun arg, dummy; struct sembuf sop; \& /* Créer la mémoire partagée et le jeu de sémaphores contenant un sémaphore. */ \& shmid = shmget(IPC_PRIVATE, MEM_SIZE, IPC_CREAT | 0600); if (shmid == \-1) errExit("shmget"); \& semid = semget(IPC_PRIVATE, 1, IPC_CREAT | 0600); if (semid == \-1) errExit("semget"); \& /*Attacher la mémoire partagée à notre espace d'adressage. */ \& addr = shmat(shmid, NULL, SHM_RDONLY); if (addr == (void *) \-1) errExit("shmat"); \& /* Initialiser le sémaphore \fB0\fP du jeu à la valeur \fB1\fP. */ \& arg.val = 1; if (semctl(semid, 0, SETVAL, arg) == \-1) errExit("semctl"); \& printf("shmid = %d; semid = %d\en", shmid, semid); \& /* Attendre que la valeur du sémaphore devienne \fB0\fP. */ \& sop.sem_num = 0; sop.sem_op = 0; sop.sem_flg = 0; \& if (semop(semid, &sop, 1) == \-1) errExit("semop"); \& /* Afficher la chaîne à partir de la mémoire partagée. */ \& printf("%s\en", addr); \& /* Supprimer la mémoire partagée et le jeu de sémaphores. */ \& if (shmctl(shmid, IPC_RMID, NULL) == \-1) errExit("shmctl"); if (semctl(semid, 0, IPC_RMID, dummy) == \-1) errExit("semctl"); \& exit(EXIT_SUCCESS); } .EE .\" SRC END .in .\" .SS "Source du programme\ : svshm_string_write.c" Le programme «\ writer\ » prend trois paramètres en ligne de commande\ : les identifiants du segment de mémoire partagée et du jeu de sémaphore créés par «\ reader\ » et une chaîne. Il attache le segment de mémoire partagée à son espace d'adressage, puis décrémente la valeur du sémaphore à \fB0\fP pour informer «\ reader\ » qu'il peut examiner le contenu de la mémoire partagée. .PP .in +4n .\" SRC BEGIN (svshm_string_write.c) .EX /* svshm_string_write.c \& Sous licence GNU General Public v2 ou postérieure. */ #include #include #include #include #include \& #include "svshm_string.h" \& int main(int argc, char *argv[]) { int semid, shmid; char *addr; size_t len; struct sembuf sop; \& if (argc != 4) { fprintf(stderr, "Utilisation\ : %s shmid semid string\en", argv[0]); exit(EXIT_FAILURE); } \& len = strlen(argv[3]) + 1; /* +1 pour inclure le \[aq]\e0\[aq] final */ if (len > MEM_SIZE) { fprintf(stderr, "La chaîne est trop longue\ !\en"); exit(EXIT_FAILURE); } \& /* Obtenir les identifiants de l'objet depuis la ligne de commande. */ \& shmid = atoi(argv[1]); semid = atoi(argv[2]); \& /* Attacher la mémoire partagée dans notre espace d'adressage et copier la chaîne (et notamment l'octet NULL final) dans la mémoire. */ \& addr = shmat(shmid, NULL, 0); if (addr == (void *) \-1) errExit("shmat"); \& memcpy(addr, argv[3], len); \& /* Décrémenter le sémaphore à \fB0\fP */ \& sop.sem_num = 0; sop.sem_op = \-1; sop.sem_flg = 0; \& if (semop(semid, &sop, 1) == \-1) errExit("semop"); \& exit(EXIT_SUCCESS); } .EE .\" SRC END .in .SH "VOIR AUSSI" \fBbrk\fP(2), \fBmmap\fP(2), \fBshmctl\fP(2), \fBshmget\fP(2), \fBcapabilities\fP(7), \fBshm_overview\fP(7), \fBsysvipc\fP(7) .PP .SH TRADUCTION La traduction française de cette page de manuel a été créée par Christophe Blaess , Stéphan Rafin , Thierry Vignaud , François Micaux, Alain Portal , Jean-Philippe Guérard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas François , Florentin Duneau , Simon Paillard , Denis Barbier , David Prévot et Jean-Philippe MENGUAL . .PP Cette traduction est une documentation libre ; veuillez vous reporter à la .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License version 3 .UE concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE. .PP Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à .MT debian-l10n-french@lists.debian.org .ME .