Warum wird in der Bash "Abgebrochen" angezeigt, nachdem ein Prozess beendet wurde?

17

Hier ist das Verhalten, das ich verstehen möchte:

$ ps
  PID TTY           TIME CMD
  392 ttys000    0:00.20 -bash
 4268 ttys000    0:00.00 xargs
$ kill 4268
$ ps
  PID TTY           TIME CMD
  392 ttys000    0:00.20 -bash
[1]+  Terminated: 15          xargs
$ ps
  PID TTY           TIME CMD
  392 ttys000    0:00.21 -bash

Warum wird angezeigt, [1]+ Terminated: 15 xargsnachdem ich einen Prozess beendet habe, anstatt ihn nur nicht anzuzeigen, da er gerade beendet wurde?

Ich verwende Bash unter Mac OS X 10.7.5.

syntagma
quelle

Antworten:

24

Kurze Antwort

In bash(und dash) werden die verschiedenen "Auftragsstatus" -Nachrichten nicht von Signalhandlern angezeigt, sondern erfordern eine explizite Prüfung. Diese Überprüfung wird nur durchgeführt, bevor eine neue Eingabeaufforderung bereitgestellt wird, um den Benutzer wahrscheinlich nicht zu stören, während er einen neuen Befehl eingibt.

Die Meldung wird nicht direkt vor der Eingabeaufforderung killangezeigt, nachdem das angezeigt wird, wahrscheinlich, weil der Prozess noch nicht beendet ist. Dies ist eine besonders wahrscheinliche Bedingung, da killes sich um einen internen Befehl der Shell handelt. Daher ist die Ausführung sehr schnell und erfordert kein Verzweigen.

Wenn Sie dasselbe Experiment mit killallausführen, wird in der Regel sofort die Meldung "kill" ausgegeben. Dies bedeutet , dass die zum Ausführen eines externen Befehls erforderlichen Zeit- / Kontextwechsel / Ereignisse eine Verzögerung verursachen, die lang genug ist, damit der Prozess abgebrochen werden kann, bevor das Steuerelement zur Shell zurückkehrt .

matteo@teokubuntu:~$ dash
$ sleep 60 &
$ ps
  PID TTY          TIME CMD
 4540 pts/3    00:00:00 bash
 4811 pts/3    00:00:00 sh
 4812 pts/3    00:00:00 sleep
 4813 pts/3    00:00:00 ps
$ kill -9 4812
$ 
[1] + Killed                     sleep 60
$ sleep 60 &
$ killall sleep
[1] + Terminated                 sleep 60
$ 

Lange Antwort

dash

Zunächst habe ich mir die dashQuellen angeschaut, da sie dashdas gleiche Verhalten aufweisen und der Code sicherlich einfacher ist als bash.

Wie oben erwähnt, scheint der Punkt zu sein, dass Jobstatusnachrichten nicht von einem Signalhandler ausgegeben werden (was den "normalen" Shell-Steuerungsfluss unterbrechen kann), sondern die Folge einer expliziten Überprüfung (eines showjobs(out2, SHOW_CHANGED)Aufrufs dash) sind, die durchgeführt wird Nur vor dem Anfordern neuer Eingaben vom Benutzer in der REPL-Schleife.

Wenn also die Shell blockiert ist und auf Benutzereingaben wartet, wird keine solche Nachricht ausgegeben.

Warum zeigt die Prüfung, die unmittelbar nach dem Kill durchgeführt wurde, nicht, dass der Prozess tatsächlich beendet wurde? Wie oben erklärt, wahrscheinlich, weil es zu schnell ist. killist ein interner Befehl der Shell, daher ist die Ausführung sehr schnell und es ist kein Verzweigen erforderlich. Wenn killder Prozess unmittelbar nach der Überprüfung noch aktiv ist (oder zumindest noch beendet wird), wird er dennoch ausgeführt.


bash

Wie erwartet bashwar es schwieriger und erforderte etwas gdb-fu , eine viel komplexere Shell zu sein .

Die Rückverfolgung, wann diese Nachricht ausgegeben wird, ist ungefähr so

(gdb) bt
#0  pretty_print_job (job_index=job_index@entry=0, format=format@entry=0, stream=0x7ffff7bd01a0 <_IO_2_1_stderr_>) at jobs.c:1630
#1  0x000000000044030a in notify_of_job_status () at jobs.c:3561
#2  notify_of_job_status () at jobs.c:3461
#3  0x0000000000441e97 in notify_and_cleanup () at jobs.c:2664
#4  0x00000000004205e1 in shell_getc (remove_quoted_newline=1) at /Users/chet/src/bash/src/parse.y:2213
#5  shell_getc (remove_quoted_newline=1) at /Users/chet/src/bash/src/parse.y:2159
#6  0x0000000000423316 in read_token (command=<optimized out>) at /Users/chet/src/bash/src/parse.y:2908
#7  read_token (command=0) at /Users/chet/src/bash/src/parse.y:2859
#8  0x00000000004268e4 in yylex () at /Users/chet/src/bash/src/parse.y:2517
#9  yyparse () at y.tab.c:2014
#10 0x000000000041df6a in parse_command () at eval.c:228
#11 0x000000000041e036 in read_command () at eval.c:272
#12 0x000000000041e27f in reader_loop () at eval.c:137
#13 0x000000000041c6fd in main (argc=1, argv=0x7fffffffdf48, env=0x7fffffffdf58) at shell.c:749

Der Anruf, der nach toten Jobs & Co sucht. ist notify_of_job_status(es ist mehr oder weniger das Äquivalent von showjobs(..., SHOW_CHANGED)in dash); # 0- # 1 hängen mit seiner inneren Arbeit zusammen; 6-8 ist der von yacc generierte Parser-Code. 10-12 ist die REPL-Schleife.

Der interessante Ort ist hier # 4, dh von wo der notify_and_cleanupAnruf kommt. Es sieht so aus bash, als ob im Gegensatz dashzu jedem Zeichen, das von der Kommandozeile gelesen wird, nach beendeten Jobs gesucht werden muss, aber hier ist, was ich gefunden habe:

      /* If the shell is interatctive, but not currently printing a prompt
         (interactive_shell && interactive == 0), we don't want to print
         notifies or cleanup the jobs -- we want to defer it until we do
         print the next prompt. */
      if (interactive_shell == 0 || SHOULD_PROMPT())
    {
#if defined (JOB_CONTROL)
      /* This can cause a problem when reading a command as the result
     of a trap, when the trap is called from flush_child.  This call
     had better not cause jobs to disappear from the job table in
     that case, or we will have big trouble. */
      notify_and_cleanup ();
#else /* !JOB_CONTROL */
      cleanup_dead_jobs ();
#endif /* !JOB_CONTROL */
    }

Im interaktiven Modus ist es daher beabsichtigt , die Prüfung zu verzögern, bis eine neue Eingabeaufforderung angezeigt wird, um den Benutzer bei der Eingabe von Befehlen wahrscheinlich nicht zu stören. Was den Grund angeht, warum die Prüfung den toten Prozess nicht erkennt, wenn die neue Eingabeaufforderung unmittelbar nach dem angezeigt wird kill, gilt die vorherige Erklärung (der Prozess ist noch nicht tot).

Matteo Italia
quelle
5

Um Job-Beendigungsnachrichten (sowohl in der Befehlszeile als auch in der psAusgabe) zu vermeiden, können Sie den zu hinterlegenden Befehl in ein sh -c 'cmd &'Konstrukt einfügen.

{
ps
echo
pid="$(sh -c 'sleep 60 1>&-  & echo ${!}')"
#pid="$(sh -c 'sleep 60 1>/dev/null  & echo ${!}')"
#pid="$(sh -c 'sleep 60 & echo ${!}' | head -1)"
ps
kill $pid
echo
ps
}

Übrigens ist es möglich, bashüber die Shell-Optionen set -bbzw. Benachrichtigungen über die sofortige Beendigung eines Jobs zu erhalten set -o notify.

In diesem Fall " bashempfängt ein SIGCHLDSignal und sein Signalhandler zeigt die Benachrichtigungsnachricht sofort an - auch wenn bashgerade auf den Abschluss eines Vordergrundprozesses gewartet wird" (siehe nächste Referenz unten).

Um einen dritten Modus der Jobsteuerungsbenachrichtigung zwischen set +b(dem Standardmodus) und set -b(damit Sie sofortige Jobbeendigungsbenachrichtigungen erhalten, ohne das zu beschädigen, was Sie bereits in Ihrer aktuellen Befehlszeile eingegeben haben - ähnlich wie ctrl-x ctrl-v), ist ein Patch bashvon Simon Tatham (z Den Patch selbst und weitere Informationen finden Sie unter: Sensible asynchrone Jobbenachrichtigung in bash (1 ).

Wiederholen wir also einfach Matteo Italia's gdb-fu für eine bashShell, die so eingestellt ist, dass sie die Jobbeendigung sofort mit benachrichtigt set -b.

# 2 Terminal.app windows

# terminal window 1
# start Bash compiled with -g flag
~/Downloads/bash-4.2/bash -il
set -bm
echo $$ > bash.pid

# terminal window 2
gdb -n -q
(gdb) set print pretty on
(gdb) set history save on
(gdb) set history filename ~/.gdb_history
(gdb) set step-mode off
(gdb) set verbose on
(gdb) set height 0
(gdb) set width 0
(gdb) set pagination off
(gdb) set follow-fork-mode child
(gdb) thread apply all bt full
(gdb) shell cat bash.pid
(gdb) attach <bash.pid>
(gdb) break pretty_print_job

# terminal window 1
# cut & paste
# (input will be invisible on the command line)
sleep 600 &   

# terminal window 2
(gdb) continue
(gdb) ctrl-c

# terminal window 1
# cut & paste
kill $!

# terminal window 2
(gdb) continue
(gdb) bt

Reading in symbols for input.c...done.
Reading in symbols for readline.c...done.
Reading in symbols for y.tab.c...done.
Reading in symbols for eval.c...done.
Reading in symbols for shell.c...done.
#0  pretty_print_job (job_index=0, format=0, stream=0x7fff70bb9250) at jobs.c:1630
#1  0x0000000100032ae3 in notify_of_job_status () at jobs.c:3561
#2  0x0000000100031e21 in waitchld (wpid=-1, block=0) at jobs.c:3202
#3  0x0000000100031a1a in sigchld_handler (sig=20) at jobs.c:3049
#4  <signal handler called>
#5  0x00007fff85a9f464 in read ()
#6  0x00000001000b39a9 in rl_getc (stream=0x7fff70bb9120) at input.c:471
#7  0x00000001000b3940 in rl_read_key () at input.c:448
#8  0x0000000100097c88 in readline_internal_char () at readline.c:517
#9  0x0000000100097dba in readline_internal_charloop () at readline.c:579
#10 0x0000000100097de6 in readline_internal () at readline.c:593
#11 0x0000000100097842 in readline (prompt=0x100205f80 "noname:~ <yourname>$ ") at readline.c:342
#12 0x0000000100007ab7 in yy_readline_get () at parse.y:1443
#13 0x0000000100007bbe in yy_readline_get () at parse.y:1474
#14 0x00000001000079d1 in yy_getc () at parse.y:1376
#15 0x000000010000888d in shell_getc (remove_quoted_newline=1) at parse.y:2231
#16 0x0000000100009a22 in read_token (command=0) at parse.y:2908
#17 0x00000001000090c1 in yylex () at parse.y:2517
#18 0x000000010000466a in yyparse () at y.tab.c:2014
#19 0x00000001000042fb in parse_command () at eval.c:228
#20 0x00000001000043ef in read_command () at eval.c:272
#21 0x0000000100004088 in reader_loop () at eval.c:137
#22 0x0000000100001e4d in main (argc=2, argv=0x7fff5fbff528, env=0x7fff5fbff540) at shell.c:749

(gdb) detach
(gdb) quit
phron
quelle
cool! aber glaubst du, dass es einen anderen Weg geben könnte? Ich versuche das: pid="$(sh -c 'cat "$fileName" |less & echo ${!}')"aber weniger wird nicht auftauchen
Aquarius Power