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