Quelle est la différence entre l'utilisation de _exit() & exit() dans une classique de Linux fourche-exec?

J'ai été à essayer de comprendre comment la fourche-exec mécanisme est utilisé à l'intérieur de Linux. Tout se passait selon le plan jusqu'à ce que certaines pages web commencé à me confondre.

Il est dit qu'un processus enfant doit utiliser rigoureusement _exit() au lieu d'un simple exit() ou une rémunération normale de main().

Que je sais, shell Linux fourche-execs de chacune des commandes externes; en supposant que ce que j'ai dit ci-dessus est vraie, la conclusion est qu'aucune de ces commandes externes, ni aucun autre d'exécution passe à l'intérieur de la shell Linux peut faire de retour!

Wikipedia & certains autres pages web que nous avons eu à utiliser _exit() juste pour empêcher un enfant de processus provoquant la suppression des parents des fichiers temporaires pendant une probable double rinçage de stdio tampons peuvent se produire. si je comprends l'ancien, je n'ai pas d'indices de la façon dont un double rinçage de tampons pourraient être nocifs, pour un système Linux.

J'ai passé toute ma journée sur ce...
Merci pour tout éclaircissement.

Double de stackoverflow.com/questions/2329640/... . Également liées: stackoverflow.com/questions/3657667/exit-functions-in-c

InformationsquelleAutor ned1986zha | 2011-03-24

43

Vous devez utiliser _exit (ou son synonyme _Exit) pour annuler le programme enfant lorsque le exec échoue, parce que dans cette situation, le processus de l'enfant peuvent interférer avec le processus parent externe de données (fichiers) par l'appel de sa atexit gestionnaires, en appelant ses gestionnaires de signaux et/ou le vidage des tampons.

Pour la même raison, vous devez également utiliser _exit dans tout processus enfant qui ne prend pas en faire un exec, mais que ceux qui sont rares.

Dans tous les autres cas, il suffit d'utiliser exit. Comme vous avez en partie remarqué toi, chaque processus dans Unix/Linux (sauf un, init) est l'enfant d'un autre processus, afin de l'utiliser _exit dans chaque processus enfant signifierait que exit est inutile en dehors de init.
```
switch (fork()) {
  case 0:
    //we're the child
    execlp("some", "program", NULL);
    _exit(1);  //<-- HERE
  case -1:
    //error, no fork done ...
  default:
    //we're the parent ...
}
```
- des TONNES de Grâce. Je me sens beaucoup mieux maintenant; bien qu'encore deux fois le rinçage d'un tampon d'être problématique, n'a pas de sens pour moi.
- Au moment de la fork(), il peut y avoir des données de la stdio tampons. Si à la fois le parent et l'enfant rincer les tampons, les données apparaîtra deux fois dans la production. Le problème n'existe pas si exec() réussit, parce que dans ce cas, le nouveau exec avais processus commence avec les frais stdio tampons.
- OK, maintenant, il fait sens pour moi. ici, la conclusion est que la mise en mémoire tampon interne est un langage C mécanisme, plutôt que d'être une installation de système d'exploitation fourni. jusqu'à présent, je ont cru qu'un simple fichier peut avoir une mémoire tampon partagée pour tous les processus! Je vous remercie beaucoup;
- Oui - le stdio tampon est une bibliothèque C mécanisme. Il peut y avoir des OS-condition de mise en mémoire tampon ainsi - mais qui n'a pas d'importance, parce que le fork() de ne pas faire double emploi.
- pourquoi pas dupliqué de sortie lors de l'utilisation _exit ? Bien que _exit ne pas rincer tampon d'e/S, mais quand l'enfant processus s'est terminé par un noyau devez vider toutes les données dans la mémoire tampon et à proximité de l'I/O standard de flux, à l'arrêt de processus...
- Comme les commentaires ci-dessus dire, _exit() assure que le C-bibliothèque-niveau (userspace stdio) tampons ne sont pas vidées - parce que ces tampons obtenir dupliqué par fork() (car ils sont l'espace utilisateur, le noyau n'est pas au courant d'entre eux). Tout au niveau du noyau tampons serait toujours obtenir vidées, mais c'est OK, parce que au niveau du noyau, les tampons ne sont pas reproduites par fork().
- Obtenu votre point, j'ai juste écrit un petit extrait de code pour démontrer ce que vous avez dit: printf("abc") sans caractère de nouvelle ligne dans un délai de (à assurez-vous que les personnages vont être mis en mémoire tampon), puis le suivant _exit(0), le résultat a montré que rien ne se rincer.
- Il y a toujours un petit détail pas très clair pour moi, quand nous appelons _exit() pour terminer le processus, disons qu'il y a un tampon existent dans stdout, il ne seront pas vidés par _exit()... après le processus de résiliation stdout être fermé ? si oui, ne sera pas le flux d'e/s opération de fermeture de vider la mémoire tampon ? ( autant que je sache, fclose() fera bouffées de chaleur ), merci!
- Lorsque le processus est terminé par le noyau, les descripteurs de fichier fermé, mais la stdio tampons ne sont pas vidées - parce que le noyau ne sait rien au sujet de ces tampons, ils sont entièrement une création de l'utilisateur C de la bibliothèque.
- IMPORTANT: vous ne DEVEZ PAS utiliser exit dans le gestionnaire de signal, vous pouvez utiliser abort, _exit ou _Exit. stackoverflow.com/questions/8833394/...
- fork() sans exec*() sont très utiles pour le multithreading, si vous voulez éviter des conditions de course, au moins il ne sont pas rares dans la me à des programmes.
InformationsquelleAutor Fred Foo
16

exit() bouffées de chaleur io tampons et fait quelques autres choses comme l'exécution des fonctions enregistrées par atexit(). exit() appelle _end( )

_exit() juste se termine le processus sans le faire. Vous appelez _exit() du processus parent lors de la création d'un démon par exemple.

Jamais remarqué que main() est une fonction? Jamais demandé ce qui l'a appelé en premier lieu?
Lorsqu'un programme c exécute le shell exécute en fournit le chemin de l'exécutable à 'exec' appel système et le contrôle est passé à noyau qui à son tour appelle la fonction de démarrage de tous les fichiers exécutables _start(), les appels de votre main(), quand main() retourne il appelle ensuite _end() Certaines implémentations de C utiliser des noms légèrement différents pour _end() & _start() ...

exit() et _exit() invoquer _end()

Normalement - pour chaque main() il devrait y avoir un & un seul exit() appel. (ou de retour à la fin de main() )
- Pas bien, d'être un peu voleur n'est pas bon. Respect pour quelqu'un d'autre effort -> #3 réponse est là -> unix.com/programming/116721-difference-between-exit-_exit.html
InformationsquelleAutor Nandan Bharadwaj
2

exit() est sur le haut de _exit(), utilisant des méthodes conventionnelles de la bibliothèque C.

Il y a des différences:
1. _exit() n'est pas vide le stdio tampon lors de la sortie() vide le stdio tampon avant la sortie de l'.
2. _exit() ne peut pas effectuer le processus de nettoyage, tandis que exit() peut être enregistré avec une certaine fonction ( j'.e on_exit ou at_exit) pour effectuer certains processus de nettoyage si
  tout est requise avant existants du programme.
de sortie(statut) passe tout simplement le statut de sortie de _exit(statut). Il est recommandé que chaque fois que pour effectuer fork(), l'un d'eux entre enfant et parent, une utilisation _exit() et une autre d'utiliser exit().

InformationsquelleAutor Sandeep_black
0

Dans l'enfant d'une branche de fork(), il est incorrect d'utiliser
exit(), parce que cela peut conduire à des stdio tampons d'être vidée deux fois,
et les fichiers temporaires être supprimés de manière inattendue.

Extrait du http://www.unixguide.net/unix/programming/1.1.3.shtml

InformationsquelleAutor snr

Vous devez vous connecter pour publier un commentaire.