Provided by: manpages-fr_3.32d0.2p4-1_all bug

NOM

       spufs - Système de fichiers SPU

DESCRIPTION

       Le  système  de  fichiers  SPU est utilisé sur les machines PowerPC qui
       utilisent  l'architecture  Cell  Broadband  Engine  Architecture   pour
       accéder aux SPU (« Synergistic Processor Units »).

       Le système de fichiers fournit un espace de noms similaire à la mémoire
       partagée ou aux queues de messages POSIX. Les utilisateurs qui  ont  la
       permission  d'écrire  sur  le  système  de  fichiers  peuvent  utiliser
       spu_create(2) pour établir des contextes SPU dans le répertoire  racine
       du spufs.

       Chaque  contexte  SPU est représenté par un répertoire contenant un jeu
       de  fichiers  prédéfinis.  Ces  fichiers  peuvent  être  utilisés  pour
       manipuler  l'état  du SPU logique. Les utilisateurs peuvent changer les
       permissions  des  fichiers,  mais  ne  peuvent  ni  en  ajouter  ni  en
       supprimer.

   Options de montage
       uid=<uid>
              Définit  l'utilisateur  propriétaire du point de montage ; 0 par
              défaut (root).

       gid=<gid>
              Définit le groupe propriétaire  du  point  de  montage ;  0  par
              défaut (root).

       mode=<mode>
              Définir  le mode du répertoire de plus haut niveau du spufs sous
              la forme d'une chaîne de valeur octale. La valeur par défaut est
              0775.

   Fichiers
       Les  fichiers  du spufs se comportent majoritairement de façon standard
       pour les appels système comme  read(2)  ou  write(2),  mais  ne  gèrent
       souvent  qu'une  fraction  des  opérations permises par les systèmes de
       fichiers normaux. Cette liste détaille les  opérations  gérées  et  les
       dérogations  par  rapport  aux comportements standards qui sont décrits
       dans les différentes pages de manuel.

       Tous les fichiers  qui  gèrent  l'opération  read(2)  gèrent  également
       readv(2)  et  tous  les fichiers qui gèrent l'opération write(2) gèrent
       aussi writev(2). Tous les fichiers  gèrent  les  familles  d'opérations
       access(2)  stat(2),  mais pour cette dernière famille, les seuls champs
       de la structure stat renvoyée qui contiennent des informations  fiables
       sont st_mode, st_nlink, st_uid et st_gid.

       Tous   les   fichiers   gèrent  les  opérations  chmod(2)/fchmod(2)  et
       chown(2)/fchown(2), mais ne permettront pas des  autorisations  d'accès
       qui contredisent les opérations possibles pour un fichier (par exemple,
       l'accès en lecture pour un fichier wbox).

       Le jeux actuel de fichiers est :

       /capabilities
              Contient une chaîne représentant les capacités, séparées par des
              virgules, de ce contexte SPU. Les capacités possibles sont :

              sched  Ce contexte peut être ordonnancé.

              step   Ce  contexte  peut  être  exécuté en mode pas-à-pas, pour
                     débogage.

              De nouveaux attributs de capacités pourront être ajoutés dans le
              futur.

       /mem   Le  contenu  de  la mémoire de stockage locale du SPU. On peut y
              accéder comme à un fichier de mémoire  partagé  standard  et  il
              contient   à  la  fois  le  code  et  les  données  de  l'espace
              d'adressage du SPU. Les opérations possibles sur un fichier  mem
              ouvert sont :

              read(2), pread(2), write(2), pwrite(2), lseek(2)
                     Elles  opèrent  normalement,  à  l'exception de lseek(2),
                     write(2) et pwrite(2) qui ne sont pas  gérées  en  dehors
                     des  limites  du  fichier.  La  taille  du fichier est la
                     taille de l'espace de stockage  local  du  SPU,  qui  est
                     normalement de 256 kilooctets.

              mmap(2)
                     La   projection  de  mem  dans  l'espace  d'adressage  du
                     processus donne accès à l'espace de stockage local du SPU
                     depuis  l'espace  d'adressage  du  processus.  Seules les
                     projections MAP_SHARED sont autorisées.

       /regs  Contient la sauvegarde des  registres  à  vocation  générale  du
              contexte SPU. Ce fichier contient les valeurs 128 bits de chaque
              registre, du registre 0 au  registre  127,  dans  l'ordre.  Cela
              permet  de  consulter  le  contenu  de  ces registres à vocation
              générale à des fins de débogage.

              La lecture ou  l'écriture  dans  ce  fichier  nécessite  que  le
              contexte  ne  soit  pas  ordonnancé,  aussi, l'utilisation de ce
              fichier n'est pas recommandé lors de  l'exécution  normale  d'un
              programme.

              Le  fichier  regs  n'existe  pas  pour  les contextes créés avec
              l'attribut SPU_CREATE_NOSCHED.

       /mbox  La première boîte aux lettres pour la communication entre SPU et
              CPU.  Ce fichier est en lecture seule et peut être lu par unités
              de 4 octets. Le fichier peut uniquement être utilisé en mode non
              bloquant  -  même  poll(2)  ne  peut  pas  être utuilisé pour se
              bloquer sur ce fichier.  La  seule  opération  possible  sur  un
              fichier mbox ouvert est :

              read(2)
                     Si count est plus petit que quatre, read(2) renvoie -1 et
                     positionne errno à EINVAL.  S'il  n'y  a  pas  de  donnée
                     disponible  dans la boîte aux lettres (c'est-à-dire si le
                     SPU n'a pas envoyé de message dans la boîte aux lettres),
                     la  valeur  de  retour  est -1 et errno est positionnée à
                     EAGAIN. Quand des  données  ont  été  lues  avec  succès,
                     quatre octets sont placés dans le tampon de données et la
                     valeur renvoyée est quatre.

       /ibox  La deuxième boîte aux lettres pour la communication entre SPU et
              CPU.  Ce  fichier  est similaire au premier fichier de boîte aux
              lettres, mais peut être  lu  en  mode  bloquant,  ainsi  appeler
              read(2)  sur un fichier ibox ouvert bloquera tant que le SPU n'a
              pas écrit dans son canal boîte à lettres (à moins que le fichier
              n'ait  été  ouvert avec O_NONBLOCK, voir ci-dessous). Également,
              poll(2) et des appels système similaires peuvent  être  utilisés
              pour surveiller la présence de données dans la boîte à lettres.

              Les opérations possibles sur un fichier ibox ouvert sont :

              read(2)
                     Si count est plus petit que quatre, read(2) renvoie -1 et
                     positionne errno à EINVAL.  S'il  n'y  a  pas  de  donnée
                     disponible  dans la boîte aux lettres et que le fichier a
                     été ouvert avec O_NONBLOCK, la valeur renvoyée est -1  et
                     errno est positionnée à EAGAIN.

                     S'il  n'y  a  pas  de donnée disponible dans la boîte aux
                     lettres et que le fichier a été  ouvert  sans  l'attribut
                     O_NONBLOCK, l'appel bloquera jusqu'à ce que le SPU écrive
                     dans son canal d'interruption de la  boîte  aux  lettres.
                     Quand des données ont été lues avec succès, quatre octets
                     sont placés dans le tampon de données et la valeur quatre
                     est renvoyée.

              poll(2)
                     L'appel  de poll(2) sur le fichier ibox renvoie (POLLIN |
                     POLLRDNORM)  quand  des  données  sont   disponibles   en
                     lecture.

       /wbox  La  boîte  aux  lettres  pour la communication entre CPU et SPU.
              Elle est en écriture seulement et on peut y écrire  des  données
              de  32 bits. Si la boîte aux lettres est pleine, write(2) bloque
              et poll(2) peut être utilisé pour bloquer jusqu'à ce qu'il  soit
              possible  d'écrire  dans  la  boîte  aux lettres. Les opérations
              possibles sur un fichier wbox ouvert sont :

              write(2)
                     Si count est plus petit que quatre, write(2)  renvoie  -1
                     et  positionne  errno  à  EINVAL. S'il n'y a pas d'espace
                     disponible dans la boîte aux lettres et que le fichier  a
                     été  ouvert avec O_NONBLOCK, la valeur renvoyée est -1 et
                     errno est positionnée à EAGAIN.

                     S'il n'y a pas d'espace  disponible  dans  la  boîte  aux
                     lettres  et  que  le fichier a été ouvert sans l'attribut
                     O_NONBLOCK, l'appel bloque jusqu'à ce  que  le  SPU  lise
                     dans  le  canal  de  sa  boîte  aux  lettres PPE (PowerPC
                     Processing Element). Quand des données  ont  été  écrites
                     avec  succès, l'appel système renvoie 4 comme résultat de
                     la fonction.

              poll(2)
                     Un appel à poll(2) sur le fichier wbox renvoie (POLLOUT |
                     POLLWRNORM) quand de l'espace est disponible en écriture.

       /mbox_stat, /ibox_stat, /wbox_stat
              Ce  sont des fichiers en lecture seule qui contiennent la taille
              des différentes queues des boîtes aux lettres,  c'est-à-dire  le
              nombre de mots qui peuvent être lus dans mbox ou ibox ou peuvent
              être écrits dans wbox sans bloquer. Ces fichiers ne peuvent être
              lus que par blocs de quatre octets et renvoient un nombre entier
              avec  un  codage  grand  boutiste  (« big  endian ».  La   seule
              opération possible sur un fichier *box_stat ouvert est :

              read(2)
                     Si count est plus petit que quatre, read(2) renvoie -1 et
                     positionne errno à EINVAL. Sinon, une  valeur  de  quatre
                     octets est placée dans le tampon de données. Cette valeur
                     est le nombre  d'éléments  qui  peuvent  être  lus  (pour
                     mbox_stat  et  ibox_stat) ou écrits (pour wbox_stat) dans
                     les  boîtes  aux  lettres  respectives  sans  bloquer  ou
                     renvoyer une erreur EAGAIN.

       /npc,  /decr,  /decr_status, /spu_tag_mask, /event_mask, /event_status,
       /srr0, /lslr
              Les registres internes du  SPU.  Ces  fichiers  contiennent  une
              chaîne de caractère ASCII représentant la valeur hexadécimale du
              registre spécifié. Lire et écrire dans ces fichiers (hormis npc,
              voir  ci-dessous)  nécessite  que le contexte du SPU ne soit pas
              ordonnancé, aussi, les accès fréquents à ces  fichiers  ne  sont
              pas recommandés lors de l'exécution normale d'un programme.

              Le contenu des fichiers est :

              npc             Compteur  programme  suivant - Valide uniquement
                              lorsque le SPU est dans un état arrêté.

              decr            Décrémenteur SPU

              decr_status     État du décrémenteur

              spu_tag_mask    Masque de drapeaux MFC pour le DMA SPU

              event_mask      Masque d'événements pour les interruptions SPU

              event_status    Nombre  d'événements  SPU  en  attente  (lecture
                              seule)

              srr0            Registre    contenant    l'adresse   de   retour
                              d'interruption

              lslr            Registre de limite de stokage local

              Les opérations possibles sur ces fichiers sont :

              read(2)
                     Lit la valeur actuelle  du  registre.  Si  la  valeur  du
                     registre  est  plus grande que le tampon passé à read(2),
                     les lectures suivantes continueront à lire  à  partir  du
                     même  tampon  jusqu'à  ce  que  la  fin  du  tampon  soit
                     atteinte.

                     Lorsqu'une  chaîne  complète  a  été  lue,   toutes   les
                     opérations  de lecture suivantes renverront zéro octet et
                     il faudra ouvrir un nouveau descripteur de  fichier  pour
                     lire une nouvelle valeur.

              write(2)
                     Un  appel à write(2) sur le fichier fixe le registre à la
                     valeur fournie dans la chaîne. La chaîne est analysée  du
                     début jusqu'au premier caractère non numérique ou jusqu'à
                     la fin du tampon. Les écritures  suivantes  sur  le  même
                     descripteur   de  fichier  remplaceront  les  précédentes
                     écritures.

                     Excepté pour le fichier npc, ces fichiers n'existent  pas
                     dans     les     contextes    créés    avec    l'attribut
                     SPU_CREATE_NOSCHED.

       /fpcr  Ce fichier donne accès au registre d'état et de contrôle pour la
              virgule  flottante  (Floating Point Status and Control Register,
              fcpr) comme un fichier binaire de quatre octets. Les  opérations
              pour le fichier fpcr sont :

              read(2)
                     Si count est plus petit que quatre, read(2) renvoie -1 et
                     positionne errno à EINVAL. Sinon, une  valeur  de  quatre
                     octets  est  placée  dans le tampon de données ; c'est la
                     valeur actuelle du registre fpcr.

              write(2)
                     Si count est plus petit que quatre, write(2)  renvoie  -1
                     et positionne errno à EINVAL. Sinon, une valeur de quatre
                     octets est copiée depuis le tampon de données, mettant  à
                     jour la valeur du registre fpcr.

       /signal1, /signal2
              Le fichier donne accès aux deux canaux de notification de signal
              d'un SPU. Ce sont  des  fichiers  en  lecture  et  écriture  qui
              utilisent  des  mots  de  quatre  octets.  Écrire dans un de ces
              fichiers déclenche une interruption sur le SPU. La valeur écrite
              dans  le fichier de signalisation peut être lue depuis le SPU au
              travers d'un canal de lecture ou par  l'espace  utilisateur  sur
              l'hôte grâce au fichier. Les opérations possibles sur un fichier
              signal1 ou signal2 ouvert sont :

              read(2)
                     Si count est plus petit que quatre, read(2) renvoie -1 et
                     positionne  errno  à  EINVAL. Sinon, une valeur de quatre
                     octets est placée dans le tampon de  données ;  c'est  la
                     valeur  actuelle  du  registre  de notification du signal
                     spécifié.

              write(2)
                     Si count est plus petit que quatre, write(2)  renvoie  -1
                     et positionne errno à EINVAL. Sinon, une valeur de quatre
                     octets est copiée depuis le tampon de données  et  met  à
                     jour  la  valeur  du  registre  de notification du signal
                     spécifié. Le registre de notification du signal sera soit
                     remplacé par les données fournies en entrée ou sera mis à
                     jour par un OU bit à bit  de  l'ancienne  valeur  et  des
                     données  fournies  en  entrée, en fonction du contenu des
                     fichiers signal1_type ou signal2_type respectivement.

       /signal1_type, /signal2_type
              Ces deux fichiers  changent  le  comportement  des  fichiers  de
              notification  signal1  et  signal2.  Ils  contiennent une chaîne
              ASCII numérique qui est lue comme "1" ou "0". Dans le le mode  0
              (remplacement),  le  matériel  remplace  le  contenu du canal du
              signal avec la  donnée  qu'on  y  écrit.  Dans  le  mode  1  (OU
              logique), le matériel accumule les bits qui y sont écrits au fur
              et  à  mesure.  Les  opérations   possibles   sur   un   fichier
              signal1_type ou signal2_type sont :

              read(2)
                     Quand  le  paramètre  count  fourni à l'appel read(2) est
                     plus petit que la longueur nécessaire pour la  valeur  du
                     chiffre (plus un caractère de fin de ligne), les lectures
                     suivantes sur le même descripteur de fichier compléteront
                     la  chaîne.  Quand  une  chaîne  complète  a été lue, les
                     lectures qui suivent  ne  renvoient  aucun  octet  et  un
                     nouveau descripteur de fichier doit être ouvert pour lire
                     une nouvelle valeur.

              write(2)
                     Un appel à write(2) sur le fichier fixe le registre à  la
                     valeur  fournie dans la chaîne. La chaîne est analysée du
                     début jusqu'au premier caractère non numérique ou jusqu'à
                     la  fin  du  tampon.  Les écritures suivantes sur le même
                     descripteur  de  fichier  remplaceront  les   précédentes
                     écritures.

       /mbox_info, /ibox_info, /wbox_info, /dma_into, /proxydma_info
              Fichiers  en lecture seule qui contiennent l'état sauvegardé des
              boîtes à lettres SPU et des files DMA. Cela  permet  de  pouvoir
              consulter  l'état du SPU, principalement à des fins de débogage.
              Les  fichiers  mbox_info  et  ibox_info  contiennent  chacun  un
              message de 4 octets qui a été écrit par le SPU. Si aucun message
              n'a été écrit dans ces boîtes  à  lettres,  le  contenu  de  ces
              fichiers  est  indéterminé. Les fichiers mbox_stat, ibox_stat et
              wbox_stat contient le nombre de messages disponibles.

              Le fichier wbox_info contient un tableau de messages de 4 octets
              qui  ont  été envoyés à le SPU. Sur les machines CBEA actuelles,
              le tableau a une longueur de 4 éléments,  ainsi,  on  peut  lire
              jusqu'à  4 * 4 = 16 octets.  Si  une  entrée  de file de boîte à
              lettres  est   vide,   les   octets   lus   dans   l'emplacement
              correspondant sont indéterminés.

              Le fichier dma_info contient le contenu de la file DMA du MFC du
              SPU, représenté par la structure suivante :

                  struct spu_dma_info {
                      uint64_t         dma_info_type;
                      uint64_t         dma_info_mask;
                      uint64_t         dma_info_status;
                      uint64_t         dma_info_stall_and_notify;
                      uint64_t         dma_info_atomic_command_status;
                      struct mfc_cq_sr dma_info_command_data[16];
                  };

              Le dernier membre de cette structure de données est la file  DMA
              réelle  contenant 16 entrées. La structure mfc_cq_sr est définie
              ainsi :

                  struct mfc_cq_sr {
                      uint64_t mfc_cq_data0_RW;
                      uint64_t mfc_cq_data1_RW;
                      uint64_t mfc_cq_data2_RW;
                      uint64_t mfc_cq_data3_RW;
                  };

              Le fichier proxydma_info contient  des  informations  similaires
              mais décrit la file DMA proxy (c'est-à-dire, les DMA initiés par
              des  entités  extérieures  au  SPU).  Le  fichier  a  le  format
              suivant :

                  struct spu_proxydma_info {
                      uint64_t         proxydma_info_type;
                      uint64_t         proxydma_info_mask;
                      uint64_t         proxydma_info_status;
                      struct mfc_cq_sr proxydma_info_command_data[8];
                  };

              L'accès à ces fichiers nécessite que le contexte SPU ne soit pas
              ordonnancé ; une utilisation fréquente  serait  inefficace.  Ces
              fichiers  ne  doivent pas être utilisés dans l'exécution normale
              d'un programme.

              Ces fichiers  n'existent  pas  dans  les  contextes  créés  avec
              l'attribut SPU_CREATE_NOSCHED.

       /cntl  Ce   fichier   fournit   un  accès  aux  registres  de  contrôle
              d'exécution et d'état du SPU sous forme d'une chaîne ASCII.  Les
              opérations suivantes sont prises en charge :

              read(2)
                     La  lecture  du  fichier  cntl  renverra une chaîne ASCCI
                     contenant la valeur hexadécimale du  registre  d'état  du
                     SPU.

              write(2)
                     L'écriture  dans  le fichier cntl définira le registre de
                     contrôle d'exécution du contexte du SPU.

       /mfc   Fournit un accès au contrôleur de flux mémoire (MFC) du SPU. Une
              lecture  de  ce fichier renvoie le contenu du registre d'état de
              balise MFC du SPU et une écriture dans le fichier initie un  DMA
              du MFC. Les opérations suivantes sont prises en charge :

              write(2)
                     L'écriture  dans  ce  fichier  nécessite  d'être  dans le
                     format d'une commande DMA du MFC défini ainsi :

                         struct mfc_dma_command {
                             int32_t  pad;    /* réservé */
                             uint32_t lsa;    /* adresse de stockage local */
                             uint64_t ea;     /* adresse effective */
                             uint16_t size;   /* taille de transfert */
                             uint16_t tag;    /* drapeau de commande */
                             uint16_t class;  /* identifiant de la classe */
                             uint16_t cmd;    /* opcode de la commande */
                         };

                     Les  écritures  doivent  avoir  une  taille  d'exactement
                     sizeof(struct  mfc_dma_command) octets.  La commande sera
                     envoyée à  la  file  proxy  MFC  du  SPU  et  le  drapeau
                     enregistré dans le noyau (voir ci-dessous).

              read(2)
                     Lire  le  contenu  du  registre  d'état du drapeau. Si le
                     fichier est ouvert en mode bloquant  (c'est-à-dire,  sans
                     O_NONBLOCK), la lecture bloquera jusqu'à ce qu'une balise
                     DMA (comme effectué par  une  écriture  précédente)  soit
                     achevée.  En  mode  non  bloquant,  le registre d'état du
                     drapeau MFC sera renvoyé sans attente.

              poll(2)
                     Appeler poll(2) sur le fichier mfc  bloquera  jusqu'à  ce
                     qu'un  nouveau  DMA  puisse  être  démarré  (en vérifiant
                     POLLOUT) ou jusqu'à ce qu'un DMA démarré précédemment (en
                     vérifiant POLLIN) se soit achevé.

                     /mss   Fournit   un   accès   à   la   fonctionnalité  de
                     synchronisation multisource (MSS) MFC. En  effectuant  un
                     mmap(2)  sur  ce fichier, les processus peuvent accéder à
                     la zone MSS du SPU.

                     Les opérations suivantes sont gérées :

              mmap(2)
                     La  projection  de  mss  dans  l'espace  d'adressage   du
                     processus  donne  accès  à  la  zone  MSS  du  SPU depuis
                     l'espace d'adressage du processus. Seules les projections
                     MAP_SHARED sont autorisées.

       /psmap Fournit  un  accès  à  l'ensemble  de  la  projection  d'état de
              problèmes du SPU. Les applications peuvent utiliser  cette  zone
              pour  interfacer  le  SPU  plutôt que d'écrire dans les fichiers
              individuels des registres sur le système de fichiers spufs.

              Les opérations suivantes sont gérées :

              mmap(2)
                     La projection  de  psmap  donne  un  accès  direct  à  un
                     processus  vers  la  zone  d'état  des  problèmes du SPU.
                     Seules les projections MAP_SHARED sont autorisées.

       /phys-id
              Fichier en lecture seule contenant le nombre  de  SPU  physiques
              sur  lesquelles s'exécutent le contexte SPU. Lorsque le contexte
              n'est pas en cours d'exécution, ce fichier  contient  la  chaîne
              « -1 ».

              Le  nombre  de  SPU physiques est fourni sous forme d'une chaîne
              ASCII hexadécimale.

       /object-id
              Permet aux applications de stocker (ou récupérer) un idendifiant
              64 bits  dans le contexte. Cet identifiant est utilisé plus tard
              par les outils de profilage pour identifier de manière unique le
              contexte.

              write(2)
                     En   écrivant  une  valeur  hexadécimale  ASCII  dans  ce
                     fichier, les applications peuvent  définir  l'identifiant
                     d'objet  du  contexte  SPU.  Toute  valeur  précédente de
                     l'identifiant d'objet est écrasée.

              read(2)
                     La lecture de ce fichier fournit une chaîne  hexadécimale
                     ASCII  représentant  l'identifiant d'objet de ce contexte
                     SPU.

EXEMPLE

       Entrée /etc/fstab
              none      /spu      spufs     gid=spu   0    0

VOIR AUSSI

       close(2),  spu_create(2),   spu_run(2),   capabilities(7),   The   Cell
       Broadband Engine Architecture (CBEA) specification

COLOPHON

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

TRADUCTION

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

       Julien    Cristau    et   l'équipe   francophone   de   traduction   de
       Debian (2006-2009).

       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> ».