Auteur | Code d'écriture pour un ballon de basket fou

Zebian | Guo Rui

le temps d'apprentissage Linux, est sûr de rencontrer toutes sortes de serrures et aux connaissances, apprendre un peu et parfois leur propre, le sentiment qu'ils ont un demi-seau d'eau peut Huashan Mountain, et soudainement émerger un nouveau point de connaissance, j'ai vu le nouveau point de savoir, quand il est temps de regarder la force ignorante. Elle a commencé à écrire à l'Université du microcontrôleur en cours d'exécution serrure nu code métallique comprendre le système d'exploitation qui est ce que l'enfer, du microcontrôleur embarqué Linux, il existe un système multi-tâches, les élèves ne comprennent pas la suggestion Baidu voir.

Quelle est la race et la concurrence?

Au début du noyau Linux, les sources concurrentes est relativement faible. Le noyau ne prend pas en charge le système multiprocesseur (SMP) symétrique, la seule cause du problème est compliqué par interruption.

Comme de plus en plus le processeur du processeur, ce qui nécessite le système pour répondre rapidement à des événements. Afin de répondre aux besoins de matériel moderne et des applications, le noyau Linux a été développé au point où vous pouvez faire plus de choses en même temps. Cette évolution a apporté une plus grande évolutivité. Mais elle a aussi complique grandement la tâche de la programmation du noyau. Les programmeurs pilote de périphérique maintenant examiner la concurrence dès le début les installer, et ils ont besoin d'une compréhension profonde des problèmes de concurrence, et utiliser les outils fournis par le noyau pour faire face à ces problèmes.

Tirez sur pour arriver au sommet. Fait référence à une pluralité de tâches simultanément exécutées simultanément, est exécuté en parallèle, littéralement course est l'unité d'exécution compétitive, en même temps à une ressource partagée (les variables globales des ressources logicielles et matérielles, les variables statiques) est des conditions de course facilement accessibles.

Par exemple, un caractère de défaut de l'appareil: un caractère pour un pilote de périphérique virtuel, en supposant une unité d'exécution A 300 en écrivant un caractère « a », et l'autre unité d'exécution B 300 en écrivant un caractère « b », troisième unité d'exécution lit tous les caractères. Si A, B puis C est l'ordre d'exécution en série lu n'est pas mal, mais si A, B en même temps, il est le résultat de notre penserez pas.

situation de course se produit

• pluralité de CPU de multi-processeur symétrique (SMP) est: SMP est étroitement couplé, la mémoire partagée du modèle de système, qui est caractérisé par une pluralité de CPU au moyen d'un bus commun, il peut accéder à une mémoire commune et des périphériques.
• Un processus CPU unique et saisir son processus: Linux 2.6 supports du noyau préemptif, un processus probablement un autre processus prioritaire interrompu lorsque l'exécution du noyau.
• Interrupt (interruption logicielle dur d'interruption, tasklet, moitié inférieure) et entre les processus: d'interruption peut interrompre le processus de réalisation, le traitement entre les applications et le processus a été interrompu par l'interruption peut également se produire course.

conditions de course Solution

Façon de résoudre le problème de la course est d'assurer un accès mutuellement exclusif aux ressources partagées. L'accès à la zone des ressources partagées est appelé le code section critique La zone critique pour protéger le mécanisme d'exclusion mutuelle. mécanismes d'exclusion mutuelle de pilote de périphérique Linux commun de la manière suivante: masque d'interruption, opération atomique, les serrures de spin et sémaphores.

La plupart des lecteurs seraient d'accord que ce scénario est préférable d'éviter.

Par conséquent, la règle de base applicable à spinlocks est que tout code

doit, tout en maintenant un spinlock, être atomic.It ne peut pas dormir, en fait, il ne peut pas abandonner le processeur pour une raison quelconque, sauf nservice

les interruptions (et parfois même pas alors).

Deadlock sur la compréhension ci-dessus ne sont pas assez profond, vous pourrez déguster une évaluation minutieuse de ce anglais.

impasse

problème de Deadlock est le développement d'une petite négligence peut rencontrer dans un système SMP qui, en cas de blocage de la CPU, d'autres CPU peut continuer à fonctionner, comme une voiture avec une roue de pneu à plat, en théorie, peut encore fonctionner, il est malheureux d'ouvrir, ou ils ouvriraient bientôt forcé facile à accrocher.

plomb de planification multi-processus de blocage

Les quatre conditions suivantes produiront une impasse:

• Mutuellement exclusif. Un fil ou d'un processus jamais partager des ressources partagées, comme la ressource exclusive.
• Circulaire d'attente. Procédé d'attente tel que le traitement B, le procédé B est en attente pour le procédé C, et C et dans le processus d'attente pour le procédé A.
• Une partie de l'allocation. L'allocation des ressources fait partie, par exemple, les procédés A et B besoin d'accéder à un fichier, une imprimante en même temps besoin d'utiliser le processus pour obtenir cette ressource fichier A, le processus B a été les ressources de l'imprimante, mais les deux processus ne peut pas obtenir toutes les ressources.
• Le manque de priorité. Un processus pour obtenir les ressources, mais n'a pas libéré les ressources, même si le processus est dans l'état de blocage.

Utilisez des scènes spécifiques seront plus compliquées, selon l'analyse réelle des besoins, condamnation.

plomb monothread à une impasse

fil unique conduit à une impasse parce que le processus est généralement causée par des appels bloqués une fonction, comme (copy_from_user (), copy_to_ser (), et kmalloc) (), après le blocage du système d'ordonnancement, la planification, il pourrait bien recevoir un appel avant fonction de verrouillage, cela conduira inévitablement à une impasse.

Il y a aussi une fonction de spin-lock n'est pas libéré appliquer immédiatement la serrure avec un verrou de rotation, une telle question stupide mais aussi conduire à spin-serrure.

Mutex et serrures de spin, la différence de sémaphores?

Mutex et rien mutex différent dans ma compréhension, les différents noms.

En termes généraux la valeur de tout le mécanisme de synchronisation peut réaliser la fonction d'exclusion mutuelle. Dans un sens étroit se réfère à ce mécanisme binaire particulier de mutex. Le rôle de mutex est mutuellement exclusive, exclusive mutuelle, est utilisé pour protéger la région critique (section critique) de. Le soi-disant section critique est une section de code, si deux threads effectuer simultanément il peut y avoir un problème, il est donc nécessaire de protéger le mutex.

Sémaphore (sémaphore)  Est un mécanisme de synchronisation plus avancé, mutex (mutex)  On peut dire sémaphore (sémaphore)  Dans le cas particulier de valeur que 0/1 du temps. Sémaphore valeur peut avoir plus d'espace pour obtenir une synchronisation plus complexe, non seulement entre les fils sont mutuellement exclusifs.

spinlocks  Il est mutex  La mise en uvre de celui-ci, par rapport à l'mutex général abandonnera en attendant cpu, Verrou tournant (verrou tournant)  Il est un cycle continu et tester l'état verrouillé, de sorte que a été cpu occupé. Ainsi, par rapport aux serrures de spin et sémaphores, dans la serrure de l'application échoue, le verrou continuera à la requête de spin, tarauder ne va pas dormir, sémaphores et mutex échoue si le fil d'application va dormir, si le verrou d'application il se réveillera fil en sommeil après avoir été libéré.

Genlock  Comme pour dire, vous pouvez être compris rien de spécial pour réaliser la fonction de synchronisation peut être appelée verrouillage de synchronisation, tels que sémaphores. Enfin, ne pas percer ces noms impasse, plus il est important de comprendre les principes derrière ces choses, ce qui était le nom et pas grand-chose à dire. Ces choses ont peut avoir des noms différents dans des langues différentes et des plates-formes, en fait, en substance, c'est tout.

Comment résoudre le problème causé par la race?

Nous avons déjà analysé les causes de la race et des solutions qui se passe produite, laissez une analyse des solutions communes.

Masque Interrompre

Une façon simple d'éviter les conditions de course dans un seul CPU de système de protection est interrompu avant d'entrer dans la section critique. Parce que beaucoup de linux contenu asynchrone E / S, interrompt le processus de planification repose sur, nous devons donc exécuter des sections critiques de code complet le plus tôt possible, autrement dit la section de code critique doit être utilisé avec parcimonie.

noyau Linux fournit les méthodes spécifiques suivantes:

Local_irq_disable (); // masque d'interruption Local_irq_enable (); // ouvrir l'interruption Local_irq_save (drapeaux); // interruptions désactiver et enregistrer les informations cpu bit d'interruption de courant

atomique

Désigne opération atomique est pas de code interrompue pour d'autres opérations en cours d'exécution.

noyau Linux fournit un ensemble de fonctions mises en oeuvre dans le noyau d'opérations atomiques, ces opérations sont divisées en deux catégories, une opération atomique est un nombre entier, et les autres bits sont des opérations atomiques qui dépendent de l'unité centrale sous-jacente obtenir un fonctionnement atomique, de sorte que ces fonctions sont étroitement liées à l'architecture du processeur.

1, nombre entier opération atomique

• La valeur a) fournir des variables atomiques

atomic_t v = ATOMIC_INIT (0); // atomes définis variable v est initialisée à 0 et atomic_set vide (atomic_t * v, int i); // régler la valeur des atomes variables i

• b) l'obtention de la valeur des atomes de variables

atomic_read (atomic_t * v); // la valeur de retour de la variable atome de v

• c) l'addition de variables atomiques, opération de soustraction

atomic_add vide (int i, atomic_t * v); // atomes augmente la variable v i atomic_sub vide (int I, atomic_t * v); // réduire les variables atomiques i v

• d) incrémentation de variable atomique, décrément

atomic_inc void (* atomic_t v); // variable v est incrémenté par un atome atomic_dec vide (atomic_t * v); // atomes cher de la variable v 1

• e) Exploitation et tests

int atomic_inc_and_test (atomic_t * v); int atomic_dec_and_test (atomic_t * v); int atomic_sub_and_test (int i, atomic_t * v); / * La fonction des trois variables v incrément atomiques, de décrémentation et les opérations de soustraction (non ajouté) après le test si elle est 0, renvoie vrai si 0, sinon false * /

• f) le fonctionnement et le rendement

int atomic_add_return (int i, atomic_t * v); int atomic_sub_return (int i, atomic_t * v); int atomic_inc_return (atomic_t * v); int atomic_dec_return (atomic_t * v); / * La fonction de la variable v pour incrément atomique, décrémentation, addition, soustraction, et retourne la nouvelle valeur * /

2, les atomes d'opération

• a) Régler le bit

SET_BIT vide (nr, void * addr); // régler l'adresse addr de bits nr, à savoir 1 est écrit à ce bit.

• b) peu claire

CLEAR_BIT vide (nr, void * addr); // effacer l'adresse addr de bits nr, à savoir, 0 est écrit à ce bit.

• c) modifier le bit

change_bit vide (nr, void * addr); // adresse du premier nr addr niée

• d) site d'essai

int test_bit (nr, void * addr); // adresse de retour addr de bits nr

• e) position de fonctionnement et d'essai

int test_and_set_bit (nr, void * addr); int test_and_clear_bit (nr, void * addr); int test_and_change_bit (nr, void * addr); / * Après avoir effectué la fonction décrite ci-dessus est équivalente à test_bit, puis exécuter des fonctions de xxx_bit * /

spinlocks

verrou de rotation un moyen d'accès exclusif des ressources critiques.

Pour obtenir de verrouillage de rotation, le code en cours d'exécution sur les besoins d'un processeur pour effectuer une opération atomique, le test et le fonctionnement ensemble à une variable de mémoire, car il est une opération atomique, de sorte que cette opération soit terminée avant les autres unités d'exécution ne peuvent pas accéder à la mémoire variable si les résultats des tests montrent que a été ralenti, le programme obtenir le verrou de rotation et continuer, si les résultats des tests indiquent que le verrou est toujours occupé, le programme répétera l'opération « test et ensemble » dans une petite boucle qui est appelée le « spin » qui est populaire dans la « marche en rond. »

noyau Linux lié à l'opération de spin-lock sont:

• 1) spinlock défini

Serrure spinlock_t;

• 2) blocage de rotation initiale

spin_lock_init (verrouillage);

• 3) obtenir des verrous de rotation

spin_lock (verrouillage); // obtenir le verrou de verrouillage de rotation spin_trylock (verrouillage); // essayer d'obtenir serrure si vous ne pouvez pas obtenir la serrure, la valeur de retour fausse, ne pas marcher en rond.

• 4) libère le verrou de rotation

spin_unlock (verrouillage); // libérer le verrou tournant

Pour vous assurer que nous exécutons la section de code critique ne soit pas interrompu et donc l'impact de notre verrou de rotation a donné naissance à une suite.

• 5) spinlock dérivé

spin_lock_irq () = spin_lock () + local_irq_disable () spin_unlock_irq () = spin_unlock () + local_irq_enable () spin_lock_irqsave () = spin_lock () + local_irq_save () spin_unlock_irqrestore () = spin_unlock () + local_irq_restore () spin_lock_bh () = spin_lock () + local_bh_disable () spin_unlock_bh () = spin_unlock () + local_bh_disable ()

Attention:

• Spinlocks essence est serrures occupés et d'autres, de sorte que dans le cas de maintien du temps de verrouillage est très courte, l'utilisation de serrures est raisonnable, sinon il aura une incidence sur les performances du système;
• verrou Spin peut provoquer le système à une impasse;
• Vous ne pouvez pas appeler pendant les verrous de rotation peut provoquer la fonction de planification des processus.

Lecture-écriture des verrous de rotation

Afin de résoudre le spinlock permet pas l'opération de lecture simultanée d'une pluralité d'unités, dérivée d'un verrou de rotation d'écriture, ce qui ne permet pas les opérations d'écriture en même temps, mais permet des opérations de lecture simultanées.

Le verrouillage de la rotation de Linux associé à l'opération d'écriture sont:

• 1) définir et initialiser les verrous d'écriture de spin

rwlock_t my_rwlock = RW_LOCK_UNLOCKED; // initialisation statique rwlock_t my_rwlock; rwlock_init (& my_rwlock); // initialiser la dynamique

• 2) Lire verrouillage

read_lock (); read_lock_irqsave (); read_lock_irq (); read_lock_bh ();

• 3) déverrouillage de lecture

read_unlock (); read_unlock_irqrestore (); read_unlock_irq (); read_unlock_bh ();

• 4) un verrou en écriture

WRITE_LOCK (); write_lock_irqsave (); write_lock_irq (); write_lock_bh (); write_trylock ();

• 5) Ecrire Unlock

write_unlock (); write_unlock_irqrestore (); write_unlock_irq (); write_unlock_bh ();

pour verrouillage

Pour optimize lire et verrou d'écriture est un verrou, si l'ordre de la serrure, unité de lecture d'exécution peut continuer à lire l'unité d'exécution d'écriture est une serrure ressource partagée écriture ordre de protection, sans attendre l'achèvement de l'unité d'exécution à écrire, écrire, l'unité d'exécution lit également l'unité d'exécution sans attendre l'achèvement de l'opération d'écriture est effectuée.

Partagée séquence de protection de verrouillage des ressources ne contient pas de pointeur, car le pointeur d'écriture de telle sorte que l'unité d'exécution peut échouer, mais si l'unité d'exécution lit le pointeur d'accès à ce moment, se traduira par oops.

noyau Linux associé à l'opération de l'ordre de verrouillage sont:

• 1) l'unité d'exécution de verrou d'écriture obtenu séquentiellement

write_seqlock (); write_tryseqlock (); write_seqlock_irqsave (); write_seqlock_irq (); write_seqlock_bh ();

• 2) la séquence d'écriture déverrouillage unité d'exécution

write_sequnlock (); write_sequnlock_irqrestore (); write_sequnlock_irq (); write_sequnlock_bh ();

• 3) l'unité d'exécution pour commencer à lire

read_seqbegin (); read_seqbegin_irqsave (); // local_irq_save + read_seqbegin

• 4) l'unité d'exécution de lecture relecture

read_seqbegin (); read_seqretry (); read_seqretry_irqrestore ();

RCU (lecture - copie - mise à jour)

verrou en lecture-écriture RCU peut être considérée comme la version haute performance, par rapport à des verrous de lecture-écriture, l'avantage est que la télécommande permettant l'accès simultané à une pluralité d'unités d'exécution pour lire des données protégées, mais permet également une pluralité d'unités d'exécution pour lire et écrire une pluralité d'unités d'exécution simultanément l'accès aux données protégées.

RCU ne peut pas remplacer le verrou de lecture-écriture.

noyau Linux lié à l'exploitation de RCU sont:

• 1) Lire verrouillage

rcu_read_lock (); rcu_read_lock_bh ();

• 2) déverrouillage de lecture

rcu_read_unlock (); rcu_read_unlock_bh ();

• 3) RCU Synchronisation

synchronize_rcu (); // écrit par l'unité d'exécution appel RCU synchronize_sched (); // vous assurer que votre gestionnaire d'interruption est traitée, nous ne pouvons pas garantir la fin du traitement d'interruption douce

• 4) rappel Mont

call_rcu (); call_rcu_bh ();

Il y a beaucoup liés à l'exploitation de RCU, vous pouvez vous référer au réseau.

sémaphore

méthode Sémaphore commune pour la protection de la région critique avec blocage de spin est similaire, mais la différence est inférieure à lors de l'acquisition du sémaphore, le processus ne marchera pas en rond, mais passer à l'état d'attente sommeil.

noyau Linux associé aux opérations sur les sémaphores sont:

• 1) la définition du sémaphores

Struct Sémaphore ETM;

• 2) Initialisation sémaphore

vide sema_init (sémaphores struct * ETM, int val); // on crée un val ETM, bien sûr, d'autres macros définies initialisation du système, ne figure pas ici

• 3) obtenir le sémaphore

vide vers le bas (struct sémaphores * ETM); // obtenir le sémaphores ETM, ce qui peut conduire à dormir, ne pas être un signal interrompu int down_interruptible (struct sémaphores * ETM); // va dormir peut être un signal interrompu int down_trylock (struct sémaphores * ETM); // ne dormirai pas

• 4) libération de sémaphore

annuler jusqu'à (* struct sémaphores ETM); // libérer le sémaphores, Wake attente du processus

REMARQUE: Lorsqu'un sémaphores est initialisée à 0, qui peut être utilisé pour la synchronisation.

L'achèvement de la synchronisation

Ce mécanisme de synchronisation sous Linux, l'achèvement de l'opération connexe Linux sont:

• 1) la définition d'achèvement

achèvement struct * my_completion;

• 2) l'initialisation d'achèvement

init_completion vide (achèvement struct * x);

• 3) attendre la fin

wait_for_completion vide (struct achèvement *);

• 4) Achèvement de réveil

complet vide (achèvement struct *); // une suite complete_all vide (struct achèvement *); // réveiller l'achèvement de toutes les unités d'exécution

Ecrire sémaphores

Des relations similaires avec des serrures de spin et de verrous de spin, noyau Linux associé à l'opération de lecture sémaphores sont:

• 1) définir et initialiser les verrous d'écriture de spin

struct rw_semaphore sem; (Et ETM) init_rwsem;

• 2) Inscrivez-vous sémaphores lecture

down_read (); down_read_trylock ();

• 3) Lire le sémaphores publié

up_read ();

• 4) le montant de l'acquisition du signal d'écriture

down_write (); down_write_trylock ();

• 5) sémaphores d'écriture est libéré

 up_write ();

mutex

Utilisé pour réaliser l'exclusion mutuelle, Linux fonctionnement liées mutex sont:

• 1) définir et initialiser mutex

struct verrou mutex; mutex_init (& lock);

• 2) acquérir le mutex

mutex_lock vide (struct mutex * serrure); int mutex_lock_interruptible (struct mutex * serrure); int mutex_lock_killable (struct mutex * serrure);

• 3) libérer le mutex

mutex_unlock vide (struct mutex * serrure);

Auteur: écrire du code pour un fanatique de basket-ball, plus de dix ans d'expérience dans le développement de embarqués, comme le basket-ball aime intégré, depuis le début du microcontrôleur STC51, AVR, STM32 à l'ARM en cours, depuis le début du présent métal nu Linux embarqué et Android système, nous avons fait beaucoup de projets ont également posé le pied sur un grand nombre de fosses à ciel, l'espoir de connaître d'autres amis avec les technologies de communication intégrées pour améliorer conjointement et des progrès.

Avertissement: Cet article de soumission, il appartient à des particuliers. En plus du papier, l'art de couverture, toutes les images sont émises par l'auteur original, RPSC décline donc toute responsabilité.