IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Embarqué Discussion :

Bug fonction read Linux embarqué


Sujet :

Embarqué

  1. #1
    Candidat au Club
    Homme Profil pro
    Ingénieur intégration
    Inscrit en
    Février 2011
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Ingénieur intégration
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2011
    Messages : 8
    Points : 4
    Points
    4
    Par défaut Bug fonction read Linux embarqué
    Bonjour à tous,

    Je rencontre actuellement un bug (que je n'ai jamais eu auparavant).

    Je vous remets dans le texte
    Actuellement, je travaille sur une carte mère qui à un processeur et une flash et une carte fille qui peut embarquer un Compact Flash. Le principe est de pouvoir faire des transferts de fichiers entre la carte mère et la carte fille.

    Nous avons un linux embarqué LynxOs sur la carte mère pour pouvoir gérer la communication entre les 2 cartes. Les drivers et autres applicatifs intégrés au linux ont été développer par une autre personne et je suis là pour résoudre un bug

    Je vous présente la Bête (elle est petite mais la vache, elle est costaud )
    Le bug se situe au niveau de la fonction read (oui oui celle fourni par linux), pour faire simple lors de la lecture (du read donc) le logiciel ne me rend pas la main du tout et reste bloquée dans cette fonction, je n'ai aucun retour de message d'erreur ou autre de la fonction.
    Je suis tout bonnement bloqué comme si le logiciel se trouvait dans une boucle infinie.

    Et la j'avoue que je n'ai absolument pas d'idée sur ce qui pourrai causer un tel bug.

    Si vous avez des idées, je suis preneur.

    Merci à tous

  2. #2
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 185
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 185
    Points : 11 551
    Points
    11 551
    Par défaut
    Salut,
    Tu ne nous donnes pas beaucoup d'informations !

    Tu read quoi ? Parce que je suis sous Debian 7 et si tu fais juste read dans une console, il n'y a pas de timeout et tu n'as plus la main (tant que tu n'entres rien au clavier).
    Je ne suis pas sur que ce soit un bug ou alors c'est un bug dans le programme qui exécute "read". Peut être que le programme lance un read sur quelque chose qui n'existe pas ?
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  3. #3
    Candidat au Club
    Homme Profil pro
    Ingénieur intégration
    Inscrit en
    Février 2011
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Ingénieur intégration
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2011
    Messages : 8
    Points : 4
    Points
    4
    Par défaut
    Salut,

    Désolé pour si peu d'info, J'essaie de pas trop en mettre parce que sinon ce sera un roman

    Ce logiciel est censé nous permettre de copier une image stocker dans la CF de la carte fille sur la flash de la carte mère et inversement.

    Sauf erreur de ma part, dans mon cas le read permet de lire l'ensemble des octets de l'image que je suis censé récupérer.

    S'il te faut plus de détail, dis le moi.

  4. #4
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 185
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 185
    Points : 11 551
    Points
    11 551
    Par défaut
    D'accord.
    Mais ton read justement, va t-il vraiment lire la CF ? Comment es tu sur qu'il ne s'est pas perdu en chemin ?
    Cette CF est elle dans un format lisible par read ?
    read est lancée depuis quelle carte (mère ou fille) ? Si elle est lancée depuis la carte mère alors il peut aussi y avoir des problèmes de hard entre les 2, as tu déjà regardé de ce côté là ?

    Dans ta recherche pour résoudre ce problème, peut être que tu devrais faire un write sur cette CF, si ça se trouve tu vas te rendre compte que tu n'arrives pas non plus a écrire dedans (pas d'accès)

    ps : j'ai du mal a croire que ce soit la commande read de ton Linux qui soit buggée. Je pencherai plutôt vers le programme en lui même.
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  5. #5
    Candidat au Club
    Homme Profil pro
    Ingénieur intégration
    Inscrit en
    Février 2011
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Ingénieur intégration
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2011
    Messages : 8
    Points : 4
    Points
    4
    Par défaut
    Citation Envoyé par Vincent PETIT Voir le message
    Mais ton read justement, va t-il vraiment lire la CF ?
    Oui, mon read va bien lire la CF.

    Citation Envoyé par Vincent PETIT Voir le message
    Comment es tu sur qu'il ne s'est pas perdu en chemin ?
    Effectivement, je ne suis pas sûr, peut être qu'effectivement il s'est perdu en chemin.


    Citation Envoyé par Vincent PETIT Voir le message
    Cette CF est elle dans un format lisible par read ?
    Oui, elle est dans un format lisible par le read


    Citation Envoyé par Vincent PETIT Voir le message
    read est lancée depuis quelle carte (mère ou fille) ? Si elle est lancée depuis la carte mère alors il peut aussi y avoir des problèmes de hard entre les 2, as tu déjà regardé de ce côté là ?
    Le read est lancé depuis la carte mère.
    Pour le hard, je n'ai pas cherché de ce coté. En faite, tout le matériel qui m'a été fourni est du client (soft, pc, carte...) et testé depuis plus d'un an.

    Citation Envoyé par Vincent PETIT Voir le message
    Dans ta recherche pour résoudre ce problème, peut être que tu devrais faire un write sur cette CF, si ça se trouve tu vas te rendre compte que tu n'arrives pas non plus a écrire dedans (pas d'accès)
    J'ai bien un accès en write et je viens bien écrire.

    le logiciel bug de temps en temps, c'est un bug intempestif


    Citation Envoyé par Vincent PETIT Voir le message
    ps : j'ai du mal a croire que ce soit la commande read de ton Linux qui soit buggée. Je pencherai plutôt vers le programme en lui même
    Sur ce point je suis entièrement d'accord avec toi. je ne vois pas comment la fonction read peut buggée et ne pas me rendre la main. Du coups, en lisant ton PS (et qu'il rejoignait mon idée), j'ai demandé les sources du driver et je me suis aperçu que le développeur du logiciel a développé un driver qui est appelé à chaque read et write, ce qui veut dire que le read de linux (donc l'original) est appelé mais il est renvoyé directement vers une fonction du driver écrit par le dev.

    Du coups maintenant, je sais un peu plus ou chercher. Mais ce qui est embêtant c'est que le logiciel fonctionne, il vient lire et écrire mais pour une raison inexpliqué, il reste bloqué dans le driver et cela se produit jamais au même moment. Il peut se bloquer à 2min comme à 5 min. \o/

  6. #6
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 185
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 185
    Points : 11 551
    Points
    11 551
    Par défaut
    Et tu peux poster le programme en question ? Si tu en as le droit bien entendu.

    Ou au pire juste les fonctions qui appellent read ?

    En espérant que c'est dans un langage que je connais.
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  7. #7
    Candidat au Club
    Homme Profil pro
    Ingénieur intégration
    Inscrit en
    Février 2011
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Ingénieur intégration
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2011
    Messages : 8
    Points : 4
    Points
    4
    Par défaut
    Excuse moi, pour la réponse tardive, je n'ai pas eu le temps de me connecter ces derniers jours.

    Effectivement, je ne peux pas tout poster mais je vais te mettre les fonctions appelé par le read

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    /********************************************************************************/
    /* Function :   read_one_sector                       */
    /*                                        */
    /* Description :  Helper function that will read one sector from the device.  */
    /*          This function first issues an ATA command, and then fill the */
    /*          data buffer with the data provided by the device.     */
    /*          The sector number and data buffer are provided by the     */
    /*          bp_entry structure.                     */
    /*          The function also has to combine data as it is provided as  */
    /*          short by the device (16 bits) while the buffer is 32 bits */
    /*                                        */
    /* Inputs :       s     Statics structure               */
    /*            bp    Buffer Entry structure              */
    /*                                        */
    /* Outputs :      bp    Buffer Entry structure              */
    /*                                        */
    /* Return options:    0     Read operation successful           */
    /*            -1    Read operation failed             */
    /********************************************************************************/
    int read_one_sector(struct sii680_statics *s, struct buf_entry *bp){
    
      int i, offset, size_of_block, nb_sectors_to_read;
      UCHAR uchar_temp;
      USHORT ushort_temp;
      ULONG ulong_temp;
      ULONG * buf_addr;
    
      nb_sectors_to_read = 1;
    
      //kkprintf ("Entree dans read_one_sector\n");
    
      /* Issue a PIO Read/Write command to device
       * = this command tells the chip to place data in the Data Register and issue an interrupt */
      issue_ata_command(s, nb_sectors_to_read, bp->b_number, ATA_COMMAND_READ);
    
      /* Wait for an IDE channel interrupt
       * = command completed, data ready */
      if (wait_for_interrupt(s) == -1){
        return -1;
      }
    
      /* Read the device status at bits [31:24] in the IDEx Task File Register 1 register to clear the device interrupt
       * and determine if there was error.*/
      read_register_byte(s->v_base_addr_reg0, TFREG_COMMAND_STATUS_OFFSET, &uchar_temp);
      // if ERR bit (bit 0) is unset, we can proceed
      if ((uchar_temp & 0x01) != 0){
        //kkprintf("Sending READ (0x20) command failed... Aborting.\n");
        return -1;
      }
    
      /* If no error, continue to read IDE data via the IDEx Task File Register 0 register, until the expected number
       * of sectors of data per interrupt are read.*/
      offset = 0;
      size_of_block = BLKSIZE(bp->b_device);
    
      for (i = 0; i < (size_of_block/2); i++){
        read_register_short(s->v_base_addr_reg0, TFREG_DATA_OFFSET, &ushort_temp);
    
        // even numbers : 0, 2, 4... : save the lower short
        if ((i % 2) == 0){
          ulong_temp = (ULONG)ushort_temp;
        }
        // odd numbers : 1, 3, 5... : save the upper short and write the long in buffer
        else {
          ulong_temp = ulong_temp | ((ULONG)(ushort_temp << 16));
          buf_addr = (ULONG *)(bp->memblk + offset);
          *(ULONG *)(buf_addr) = (ULONG)Swap_long(ulong_temp);
          offset += 4;
          ulong_temp = 0;
        }
      }
    
      return 0;
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    /********************************************************************************/
    /* Function :   wait_for_interrupt                      */
    /*                                        */
    /* Description :  Helper function built around swait().           */
    /*          We don't use directly swait because some problems can occur */
    /*          when we plug/unplug the compactflash : doing so generates */
    /*          many interruptions that will signals the semaphore, thus  */
    /*          will disturb the driver's proper working.           */
    /*          With the flag 'next_interrupt_is_valid', we make sure the */
    /*          next received interruption is an expected one.        */
    /*                                        */
    /* Inputs :       s     Statics structure               */
    /*                                        */
    /* Outputs :    None                            */
    /*                                        */
    /* Return options:    0     Interrupt received                */
    /*            -1    Wait aborted                  */
    /********************************************************************************/
    int wait_for_interrupt(struct sii680_statics *s)
    {
      int ret;
    
      s->next_interrupt_is_valid = 1;
    
      //kkprintf("Sleeping : Waiting interrupt... ");
      if (swait(&s->pci_control_sem, SEM_SIGABORT))
      {
        ret = -1;
      }
      else
      {
        ret = 0;
      }
      //kkprintf("Awake !\n");
    
      s->next_interrupt_is_valid = 0;
    
      return ret;
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    /********************************************************************************/
    /* Function :   issue_ata_command                     */
    /*                                        */
    /* Description :  Helper function that will issue the command to the device.  */
    /*          This function addresses Task File registers to configure  */
    /*          and start an operation. After completion of this function,  */
    /*          the device is supposed to start an operation and then set   */
    /*          an interrupt                        */
    /*                                        */
    /* Inputs :       s       Statics structure             */
    /*            nb_sectors  Value to write in TaskFileRegister0[23:16]  */
    /*            sector_id_lba LBA addressing value. This value, to split, */
    /*            is to be written in:                    */
    /*            TaskFileRegister0[31:24]                */
    /*            TaskFileRegister1[07:00]                */
    /*            TaskFileRegister1[15:08]                */
    /*            TaskFileRegister1[19:16]                */
    /*            command   Command ID (eg: 0x20 READ), to write in   */
    /*            TaskFileRegister1[31:24]                */
    /*                                        */
    /* Outputs :      bp      Buffer Entry structure            */
    /*                                        */
    /* Return options:  None                            */
    /********************************************************************************/
    void issue_ata_command(struct sii680_statics *s, int nb_sectors, ULONG sector_id_lba, int command)
    {
      UCHAR lba_27_24, lba_23_16, lba_15_08, lba_07_00, uchar_temp;
      int i;
    
      //read_register_byte(s->v_base_addr_reg0, TFREG_COMMAND_STATUS_OFFSET, &uchar_temp);
      //kkprintf("Status = 0x%08x\n", uchar_temp);
    
      // Split the LBA addressing
      lba_07_00 = (UCHAR)(0xFF & (sector_id_lba));
      lba_15_08 = (UCHAR)(0xFF & (sector_id_lba >> 8));
      lba_23_16 = (UCHAR)(0xFF & (sector_id_lba >> 16));
      lba_27_24 = (UCHAR)(0x0F & (sector_id_lba >> 24));
    
      // Send the command
      write_register_byte(s->v_base_addr_reg0, TFREG_SECTOR_COUNT_OFFSET, nb_sectors);
      write_register_byte(s->v_base_addr_reg0, TFREG_STARTING_SECTOR_NUMBER_OFFSET, lba_07_00);
      write_register_byte(s->v_base_addr_reg0, TFREG_CYLINDER_LOW_OFFSET, lba_15_08);
      write_register_byte(s->v_base_addr_reg0, TFREG_CYLINDER_HIGH_OFFSET, lba_23_16);
      write_register_byte(s->v_base_addr_reg0, TFREG_DEVICE_HEAD_OFFSET, (0x40 | lba_27_24));
      write_register_byte(s->v_base_addr_reg0, TFREG_COMMAND_STATUS_OFFSET, command);
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    int read_register_short (UCHAR * baseaddr, ULONG loffset, USHORT *lValeur){
      ULONG *addr;
    
      // Calculate address
      addr = (ULONG *)(baseaddr + loffset);
    
      // Read data
      *lValeur = (USHORT)Swap_short(*(USHORT *)(addr));
      eieio();
    
      return(0);
    }
    De ce que j'ai pu remarquer dans mes tests, la fonction read_one_sector reste bloqué entre la fonction issue_ata_command et wait_for_interrupt

  8. #8
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 185
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 185
    Points : 11 551
    Points
    11 551
    Par défaut
    Avec si peu de code, ça va pas être simple mais je comprends que tu ne puisses pas en donner plus.
    Est ce que je peux voir la fonction swait ?

    1) Puisque tu as tout le code, tu peux surement me répondre.
    issue_ata_command place des données dans un registre du micro "Data Register" et ça active un flag (ce genre de flag est très courant dans les micro-contrôleurs, tu places des données dans un registre, un flag passe a 1 automatiquement et une fois les données parties ce flag passe a 0 tout seul, par exemple les UART des micros fonctionnent tous comme ça). Puis on fait un wait_for_interrupt(s), probablement qu'on attend que le flag soit dans un état, sous forme de pooling, avant d'aller plus loin. Puisque tu as un Linux embarqué, les interruptions ne sont pas gérées, on joue avec les flags.

    Est ce que ton programme utilise des thread ? Surement que oui. Est ce que struct sii680_statics *s est partagé entre les thread ?
    Je me demande si struct sii680_statics *s n'est pas modifié par un autre thread ?

    Peux tu vérifier ça ?

    2) As tu un moyen de modifier le code ? Recompiler ? Faire des modifs ? As tu les outils de développement ? As tu un moyen de déboguer (genre allumer une LED, ou un afficheur sur l'appareil, ou n'importe quoi d'autre qui te permettrai d'afficher l'état une variable) ?
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  9. #9
    Candidat au Club
    Homme Profil pro
    Ingénieur intégration
    Inscrit en
    Février 2011
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Ingénieur intégration
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2011
    Messages : 8
    Points : 4
    Points
    4
    Par défaut
    Citation Envoyé par Vincent PETIT Voir le message
    Avec si peu de code, ça va pas être simple mais je comprends que tu ne puisses pas en donner plus.
    Même moi avec tout le code, c'est quand même sport, alors j'imagine qu'avec si peu, ce n'est pas simple. dsl

    Citation Envoyé par Vincent PETIT Voir le message
    Est ce que je peux voir la fonction swait ?
    J'avais voulu la voir aussi pour savoir ce qu'elle faisait exactement, mais je ne l'ai pas trouvé. Cependant, elle doit bien être quelque part, du coups je continue de chercher. Des que j'ai mis la main dessus, je te la poste.

    Citation Envoyé par Vincent PETIT Voir le message
    1) Puisque tu as tout le code, tu peux surement me répondre.
    issue_ata_command place des données dans un registre du micro "Data Register" et ça active un flag (ce genre de flag est très courant dans les micro-contrôleurs, tu places des données dans un registre, un flag passe a 1 automatiquement et une fois les données parties ce flag passe a 0 tout seul, par exemple les UART des micros fonctionnent tous comme ça). Puis on fait un wait_for_interrupt(s), probablement qu'on attend que le flag soit dans un état, sous forme de pooling, avant d'aller plus loin. Puisque tu as un Linux embarqué, les interruptions ne sont pas gérées, on joue avec les flags.

    Est ce que ton programme utilise des thread ? Surement que oui. Est ce que struct sii680_statics *s est partagé entre les thread ?
    Je me demande si struct sii680_statics *s n'est pas modifié par un autre thread ?

    Peux tu vérifier ça ?
    Probablement, qu'il doit utiliser des threads, je vais regarder de ce côtés. L'idée me semble pas mal . Merci

    Citation Envoyé par Vincent PETIT Voir le message
    1) 2) As tu un moyen de modifier le code ? Recompiler ? Faire des modifs ? As tu les outils de développement ? As tu un moyen de déboguer (genre allumer une LED, ou un afficheur sur l'appareil, ou n'importe quoi d'autre qui te permettrai d'afficher l'état une variable) ?
    Je peux recompiler le code et faire des modifs mais pas sur tout, j'ai quelques boites noirs dans le code . Sinon, pour tout ce qui est outil de développement, debugger ou autre...c'est le néant.
    Et non, j'aurai bien aimé aussi avoir une LED ou n'importe quoi d'autre qui me permettrait d'afficher l'état d'une variable, mais rien.

  10. #10
    Candidat au Club
    Homme Profil pro
    Ingénieur intégration
    Inscrit en
    Février 2011
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Ingénieur intégration
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2011
    Messages : 8
    Points : 4
    Points
    4
    Par défaut
    J'ai trouvé un peu plus d'info sur cette fonction swait, en faite elle est spécifique au linux embarqué LynxOS, voici ce que ça dit :

    " swait () causes the calling process to wait on a semaphore.

    The prototype for swait() is: int swait (int *s, int flag)

    s is a pointer to a semaphore and flag is an argument that specifies whether or not signals are delivered to the process while it is waiting. swait() cannot be used from within an ISR"

    Par contre je n'ai pas les sources du LynxOS. Je peux que faire une compilation, du coups s'il y a des choses qui ont été modifié, je ne peux pas le voir.

  11. #11
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 185
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 185
    Points : 11 551
    Points
    11 551
    Par défaut
    Ça sent de plus en plus un problème de deadlock. On dirait bien 2 threads qui s'attendent !
    Ça pourrait expliquer ce blocage.
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

Discussions similaires

  1. Pb fonction read sur port série - GCC LINUX
    Par Signal40 dans le forum POSIX
    Réponses: 5
    Dernier message: 02/08/2010, 21h33
  2. Comportement d'un read en embarqué ?
    Par olivier857 dans le forum Administration système
    Réponses: 5
    Dernier message: 10/04/2006, 12h57
  3. Linux Embarqué
    Par nicolaskarp dans le forum Linux
    Réponses: 10
    Dernier message: 19/03/2006, 13h34
  4. Problème avec la fonction read.
    Par Whaouu dans le forum Langage
    Réponses: 10
    Dernier message: 23/09/2005, 11h33
  5. [langage] problème avec fonction read
    Par domidum54 dans le forum Langage
    Réponses: 2
    Dernier message: 30/03/2004, 21h42

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo