Processes and Signals

     Definisi proses: Ruang alamat; utas (program) yang berjalan di dalam ruang itu); diperlukan sumber daya sistem untuk utas tersebut.

Isi proses: kode program, data, variabel dalam memori sistem, file terbuka (deskriptor file), dan ruang lingkungan yang diisi dengan variabel lingkungan, dan penghitung programnya sendiri untuk melacak pernyataan yang dijalankan di setiap utasnya. (Linux sebenarnya membagikan satu salinan kode yang digunakan oleh lebih dari satu proses - seperti windows DLL.)

gambar dari https://courses.cs.washington.edu/courses/cse451/04wi/section/ab/notes/fork/

Sistem operasi menangani banyak proses yang tampaknya berjalan pada saat yang sama. ( banyak pengguna, banyak pekerjaan dari setiap pengguna, banyak proses sistem - semuanya sekaligus)

Lihat proses saya: (melihat tabel proses Linux)

PEPPER> ps –f (gunakan ps - ef untuk melihat semua proses sistem)

UID	PID	PPID	C	STIME	TTY	WAKTU	CMD
LADA	17154	17153	0	12:04	Poin / 1	00:00:00	-pesta
LADA	17277	17154	0	12:19	Poin / 1	00:00:00	ps –f

·          PID adalah pengidentifikasi proses

·          PPID adalah ID proses induk. (Lihat bagaimana bash saya meluncurkan ps saya)

·          C adalah persentase pemanfaatan CPU.

·          CMD adalah perintah yang digunakan untuk memulai proses

Hai    Lihat nilai proses dengan cd / proc / <id proses Anda>

  PEPPER> ps -ax | egrep ' PEPPER | PID | init '

PID	TTY	STAT	WAKTU	PERINTAH
1	?	Ss	0:04	/ sbin / init
17153	?	S	0:00	sshd : PEPPER @ pts / 1
17411	Poin / 1	S +	0:00	egrep PEPPER | PID

init - proses startup, induk dari semua yang lain

KODE STATUS PROSES

       Berikut adalah nilai yang berbeda yang akan ditampilkan oleh penspesifikasi s, stat dan status (tajuk "STAT" atau "S") untuk menggambarkan keadaan proses: dari http://askubuntu.com/questions/360252/what-do -the-stat-kolom-nilai-dalam-ps-rata

·          D     tidur tanpa gangguan (biasanya IO)

·          R     running atau runnable (on run antrian)

·          S     tidur interruptible (menunggu acara selesai)

·          T     berhenti, baik oleh sinyal kontrol pekerjaan atau karena sedang dilacak.

·          W     paging (tidak valid sejak kernel 2.6.xx)

·          X     mati (tidak boleh dilihat)

·          Z     mati ("zombie") proses, dihentikan tetapi tidak menuai oleh orang tuanya.

·          <     prioritas tinggi (tidak baik untuk pengguna lain)

·          N     prioritas rendah (baik untuk pengguna lain)

·          L.     memiliki halaman terkunci ke dalam memori (untuk real-time dan custom IO)

·          s     adalah pemimpin sesi

·          l     multi-threaded (menggunakan CLONE_THREAD, seperti NPTL pthreads do)

·          +     berada di grup proses latar depan.

Bagaimana Linux memutuskan siapa yang mendapatkan kutu waktu berapa lama?

·          Memiliki ukuran kebaikan. Lihat dengan ps –l

·          Program berperilaku baik yang tidak mem-cog cpu bagus, seperti yang kadang-kadang menunggu beberapa input.

·          Linux menyesuaikan nilai yang bagus, menunggu hadiah untuk input. Anda juga dapat secara paksa menetapkan nilai bagus untuk meningkatkan prioritas Anda.  

·          Semakin rendah angkanya, semakin tinggi prioritas.

Bagaimana Linux memulai login Anda:

·          fork - id proses baru

·          exec - ganti proses yang ada dengan program baru

·          gambar dari https://www.washington.edu/R870/img/fork-exec.gif

Memulai proses baru   dengan sistem - luncurkan proses shell yang meluncurkan proses lain

Gunakan sistem untuk Meluncurkan satu program dari dalam yang lain dan menunggu jawabannya. Pertama-tama membuat shell anak dan kemudian menjalankan program dari shell itu

gunakan sistem dari dalam stdlib.h

sistem int ( const char * string);

respon: 127 = shell tidak dapat dimulai untuk proses baru; -1 = kesalahan lainnya; kode lain: kode keluar dari perintah yang disebut.

Buat tidak menunggu dengan mengirimkan proses ke latar belakang.   

Contoh: wget http://home.adelphi.edu/~pe16132/csc271/note/scripts/fileio/process1.c

·          #termasuk < stdlib.h >

·          #termasuk < stdio.h >

·          int main ()

·          {

·          printf ("menjalankan ps dengan sistem \ n");

·          sistem (" ps ax &"); // kapan & mengirim ke latar belakang, selesai mencetak terlebih dahulu,

·                                         // hapus & untuk membuat cetakan terakhir

·          printf ("Selesai. \ n");

·          keluar (0);

·          }

Mengganti Gambar Proses dengan keluarga exec

Rangkaian perintah exec akan memberikan eksekusi dari satu program ke program lainnya. Ruang program peluncuran digantikan oleh program baru, menjaga deskriptor file terbuka dan beberapa pengaturan proses lainnya.

lebih efisien daripada perintah sistem

di dalam unistd.h

·          execl , exclp , execl3 - mengambil sejumlah variabel argumen yang diakhiri dengan pointer nol.

·          execv , execvp , execve - mengambil argumen kedua sebagai array dari string.

·          ending e- juga mengirimkan variabel lingkungan

·          ending p - cukup berikan file dan itu akan mencari jalan Anda

·          nilai kembali : hanya kembali dengan kesalahan karena proses sedang diganti. -1 adalah kesalahan.

Hai    Contoh panggilan: wget http://home.adelphi.edu/~pe16132/csc271/note/scripts/fileio/process2.c

§   #termasuk < unistd.h >

§   int main ( int argc , char * argv [])

§   {

§   // atur lingkungan yang akan digunakan untuk meneruskan ke perintah yang diakhiri dengan e

§   char * const ps_env [] = {"PATH = / bin: / usr / bin" "TERM = console", NULL};

§   execl ("/ bin / ps ", " ps ", " ax", NULL );

§   execlp (" ps ", " ps ", " ax", NULL );

§   mengeksekusi ("/ bin / ps ", " ps ", " ax", NULL , ps_env );

§   // asumsikan program disebut dengan parms " ps ", "ax", 0

§   execv ("/ bin / ps ", argv );

§   execvp (" ps ", argv );

§   mengeksekusi ("/ bin / ps ", argv , ps_env );

§   }

Gandakan Proses dari dalam Proses menggunakan garpu - dapat menunggu respons

Perintah fork akan menciptakan proses baru yang hampir identik dengan proses induk, mengeksekusi kode yang sama, tetapi dengan ruang data, lingkungan, dan deskriptor file sendiri.

prototipe fungsi : garpu pid_t (tidak valid)

kembali : ke orang tua itu mengembalikan proses id anak jika baik dan -1 jika kesalahan; untuk anak itu mengembalikan 0 (sehingga program Anda dapat menguji kode pengembalian garpu untuk menentukan apakah itu berjalan sebagai anak atau orang tua)

·          pid = fork ();

·          jika ( pid <= 0)

·          {    printf ("Kode anak sedang berjalan dengan respons fork dari% d \ n", pid );

·          }

·          lain

·          {    printf ("Kode induk berjalan dengan respons fork dari% d \ n", pid );

·          }

·          wget http://home.adelphi.edu/~pe16132/csc271/note/scripts/fileio/fork1.c

Orang tua dapat menunggu sampai anak bercabangnya selesai. Kemudian, ia juga dapat memeriksa status keluar anak.  

termasuk <sys / wait.h >

pid_t wait ( int * stat_loc ) - untuk setiap anak

pid_t waitpid ( pid_t pid , int * stat_loc , opsi int ) - untuk anak tertentu

kemungkinan tes nilai status memeriksa stat_val (hanya bilangan bulat):   dikreditkan ke http://www.unix.org/version2/sample/wait.html

WIFEXITED ( stat_val )

Mengevaluasi ke nilai bukan nol jika status dikembalikan untuk proses anak yang diakhiri secara normal.

WEXITSTATUS ( stat_val )

Jika nilai WIFEXITED ( stat_val ) adalah tidak nol, makro ini mengevaluasi ke 8 bit orde rendah dari argumen status bahwa proses anak dilewatkan ke _exit () atau keluar () , atau nilai proses anak yang dikembalikan dari main () .

WIFSIGNALED ( stat_val )

Mengevaluasi ke nilai bukan nol jika status dikembalikan untuk proses anak yang diakhiri karena penerimaan sinyal yang tidak ditangkap (lihat < signal.h > ).

WTERMSIG ( stat_val )

Jika nilai WIFSIGNALED ( stat_val ) adalah non-nol, makro ini mengevaluasi jumlah sinyal yang menyebabkan penghentian proses anak.

WIFSTOPPED ( stat_val )

Mengevaluasi ke nilai bukan nol jika status dikembalikan untuk proses anak yang saat ini dihentikan.

WSTOPSIG ( stat_val )

Jika nilai WIFSTOPPED ( stat_val ) adalah non-nol, makro ini mengevaluasi jumlah sinyal yang menyebabkan proses anak berhenti.

WIFCONTINUED ( stat_val )

Contoh: wget http://home.adelphi.edu/~pe16132/csc271/note/scripts/fileio/fork1a.c

·          #termasuk <sys / types.h >

·          #termasuk < unistd.h >

·          #termasuk < stdio.h >

·          #termasuk < stdlib.h >

·          #termasuk <sys / wait.h >

·          int main ()

·          {

·          int stat_val ;

·          pid_t   pid ;

·          pid_t finished_pid ;

·          pesan char *;

·          int n;

·          printf ("program garpu dimulai \ n");

·          pid = fork ();

·          if ( pid > 0 || pid == -1) // induk

·          {

·          finished_pid = tunggu (& stat_val );

·          printf ("Kode induk berjalan dengan respons fork dari% d \ n", pid );

·          printf (" Pid anak% d selesai sekarang \ n", finished_pid );

·          if (WIFEXITED ( stat_val ))

·          { printf ("child keluar dengan kode% d \ n", WEXITSTATUS ( stat_val ));

·          sistem (" ps -u PEPPER");

·          }

·          }

·          lain // anak

·          {    printf ("Kode anak sedang berjalan dengan respons fork dari% d \ n", pid );

·          tidur (15);

·          sistem (" ps -u PEPPER");

·          keluar (37);

·          }

·          keluar (0);

·          }

Hasil Program di:

·          program garpu dimulai

·          Kode anak dijalankan dengan respons fork 0

·          Hasil PS dengan kedua proses

·          Kode induk berjalan dengan respons fork 17962

·          Anak pid 17962 selesai sekarang

·          anak keluar dengan kode 37

·          hasil ps tanpa 17962

dari http://www.cs.duke.edu/courses/spring01/cps110/slides/proc-ux/sld012.htm

Proses Zombie

Anak bercabang yang sudah selesai tetapi menunggu orang tua untuk keluar. Itu membuat entri dalam tabel proses dengan kode kembali jika orangtua ingin memanggil tunggu.   ps menunjukkan anak yang lengkap dengan <defunct> a

·          Akhiri orang tua

·          Panggilan tunggu

Menangani sinyal yang diterima proses Anda menggunakan sinyal

Nama sinyal didefinisikan di dalam signal.h

beberapa di antaranya: dari http://unixhelp.ed.ac.uk/CGI/man-cgi?signal+7

         Sinyal         Nilai        Tindakan      Komentar 

         -------------------------------------------------- ----------------------- 

         PENJUALAN            1          Istilah       Hangup terdeteksi pada terminal kontrol 

                                atau kematian proses pengendalian 

         SIGINT            2          Istilah       Ganggu dari keyboard 

         SIGQUIT           3          Inti       Keluar dari keyboard 

         SIGILL            4          Inti       Instruksi Ilegal 

         SIGABRT           6          Inti       Batalkan sinyal dari batalkan ( 3) 

         SIGFPE            8          Inti       Pengecualian titik apung 

         SIGKILL           9          Istilah       Bunuh sinyalnya 

         SIGSEGV          11          Inti       Referensi memori tidak valid 

         SIGPIPE          13          Istilah       Pipa rusak: tulis ke pipa tanpa pembaca 

         SIGALRM          14          Istilah       Sinyal pengatur waktu dari alarm ( 2) 

         SIGTERM          15          Istilah       Sinyal terminasi 

         SIGUSR1      30 , 10,16       Istilah       Sinyal yang ditentukan pengguna 1 

         SIGUSR2      31 , 12,17       Istilah       Sinyal yang ditentukan pengguna 2 

         SIGCHLD      20 , 17,18       Ign        Anak berhenti atau dihentikan 

         SIGCONT      19 , 18,25       Lanj       Lanjutkan jika berhenti 

         SIGSTOP      17 , 19,23       Berhenti       Hentikan proses 

         SIGTSTP      18 , 20,24       Berhenti       Berhenti mengetik di tty 

         SIGTTIN      21 , 21,26       Berhenti       masukan tty untuk proses latar belakang 

         SIGTTOU      22 , 22,27       Berhenti       tty output untuk proses latar belakang 

         Itu     sinyal SIGKILL dan SIGSTOP tidak dapat ditangkap, diblokir, atau diabaikan. 

  Jika suatu proses menerima sinyal tanpa mengatur untuk menangkapnya, itu akan mati dengan dump inti. 

  SIGCHLD diabaikan secara default 

   CTRL C mengirimkan SIGINT ke proses foreground. 

  Untuk membunuh proses lain : kill –HUP 999 (akan mengirim SIGHUP ke proses itu 999) 

  Program yang menangani sinyal menggunakan perintah sinyal: 

  void (* signal ( int sig, void (* func ) ( int ))) ( int ); 

  Catatan : program lama menggunakan ini, tetapi sigaction lebih baik. 

  ·             sinyal membutuhkan 2 parm , sig dan func . 

  ·             sinyal untuk ditangkap adalah tanda 

  ·             berfungsi untuk memanggil ketika sinyal diterima berfungsi 

  ·             func harus menerima satu argumen int , yang merupakan sinyal dan tidak mengembalikan apa pun. 

  ·             Contoh: wget http://home.adelphi.edu/~pe16132/csc271/note/scripts/fileio/ctrlc1.c 

  Hai      #termasuk < signal.h > 

  Hai      #termasuk < stdio.h > 

  Hai      #termasuk < unistd.h > 

  Hai    

  Hai      batal aduh ( int sig) 

  Hai      { 

  Hai          printf ( "OUCH! - Saya mendapat sinyal% d \ n", sig); 

  Hai          sinyal (kosong) (SIGINT, SIG_DFL);  // kembalikan standar 

  Hai      } 

  Hai    

  Hai      / *     Fungsi utama harus mencegat sinyal SIGINT yang dihasilkan ketika kita mengetik Ctrl-C. 

  Hai          Untuk sisa waktu, itu hanya duduk dalam satu lingkaran tak terbatas, 

  Hai          mencetak pesan satu detik sekali.     * / 

  Hai    

  Hai      int main () 

  Hai      { 

  Hai          sinyal (kosong) (SIGINT, aduh);  // mengatur fungsi penangkap sinyal 

  Hai    

  Hai          sementara (1) { 

  Hai              printf ("Hello World! \ n"); 

  Hai              tidur (1); 

  Hai          } 

  Hai      } 

  Mengirim Sinyal: 

  Untuk mengirim sinyal ke suatu proses: int kill ( pid_ t     pid , int sig);  (tetapi tidak harus dibunuh) 

  Untuk mengirim alarm secara berkala ke proses Anda sendiri: alarm int unsigned ( unsigned int seconds); 

   Untuk menunggu sinyal diterima: int pause ( void); 

    Contoh: wget http://home.adelphi.edu/~pe16132/csc271/note/scripts/fileio/alarm.c 

  / *     Di alarm.c , fungsi pertama, ding, mensimulasikan jam alarm.     * / 

  #termasuk < signal.h > 

  #termasuk < stdio.h > 

  #termasuk < unistd.h > 

  #termasuk < stdlib.h > 

  static int alarm_fired = 0; 

  membatalkan ding ( int sig) 

  { 

      alarm_fired = 1; 

  } 

  / *     Secara utama, kami memberi tahu proses anak untuk menunggu selama lima detik 

      sebelum mengirim sinyal SIGALRM ke induknya.     * / 

  int main () 

  { 

      pid_t pid ; 

      printf ( "aplikasi alarm dimulai \ n"); 

      pid = fork (); 

      beralih ( pid ) { 

      kasus -1: 

        / * Kegagalan * / 

        perror ( "garpu gagal"); 

        keluar ( 1); 

      case 0: 

        / * anak * / 

          tidur ( 5); 

          bunuh ( getppid (), SIGALRM); 

          keluar ( 0); 

      } 

  / *     Proses induk mengatur untuk menangkap SIGALRM dengan panggilan ke sinyal 

      dan kemudian menunggu yang tak terhindarkan.     * / 

      printf ( "menunggu alarm mati \ n"); 

      ( tidak berlaku ) sinyal (SIGALRM, ding); 

      jeda ( ); 

      jika ( alarm_fired ) 

          printf ( "Ding! \ n"); 

      printf ( "selesai \ n"); 

      keluar ( 0); 

  } 

  Menangani Sinyal menggunakan sigaction fungsi yang lebih kuat: 

  perintah sigaction mengisi struktur sigaction : 

  int sigaction ( int sig, sigaction const struct * act, sigaction struct * oact ); 

  ·             mengandung: 

  ·             sa_handler - fungsi untuk menangani sinyal atau SIG_DFL (default) atau SIG_IGN (abaikan) 

  ·             sa_mask - sinyal untuk diblokir di sa_handler 

  ·             sa_flags - pengubah aksi sinyal 

  Pengembalian: 

  ·             0 jika berhasil 

  ·             -1 jika tidak berhasil 

        Contoh (program kontrol c yang sama tetapi menggunakan sigaction )   

  wget http://home.adelphi.edu/~pe16132/csc271/note/scripts/fileio/ctrlc2.c 

  ·             #termasuk < signal.h > 

  ·             #termasuk < stdio.h > 

  ·             #termasuk < unistd.h > 

  ·             batal aduh ( int sig) 

  ·             { 

  ·             printf ( "OUCH! - Saya mendapat sinyal% d \ n", sig); 

  ·             } 

  ·             int main () 

  ·             { 

  ·             tindakan sigaction struct ; 

  ·             act.sa_handler = aduh; 

  ·             sigemptyset (& act.sa_mask ); 

  ·             act.sa_flags = 0; 

  ·             sigaction (SIGINT, & act, 0); 

  ·             sementara (1) { 

  ·             printf ("Hello World! \ n"); 

  ·             tidur (1); 

  ·             } 

  ·             }  

Terimakasih sudah membaca:)