Panggilan sistem exec digunakan untuk melaksanakan file yang berada dalam proses aktif. Apabila exec disebut, fail yang boleh dilaksanakan sebelumnya diganti dan fail baru dijalankan.
Lebih tepat lagi, kita dapat mengatakan bahawa menggunakan panggilan sistem exec akan menggantikan fail atau program lama dari proses tersebut dengan fail atau program baru. Keseluruhan kandungan proses diganti dengan program baru.
Segmen data pengguna yang melaksanakan panggilan sistem exec () diganti dengan fail data yang namanya diberikan dalam argumen ketika memanggil exec ().
Program baru dimuat ke ruang proses yang sama. Proses semasa hanya diubah menjadi proses baru dan oleh itu id proses PID tidak diubah, ini kerana kita tidak membuat proses baru kita hanya mengganti proses dengan proses lain di exec.
Sekiranya proses yang sedang berjalan mengandungi lebih dari satu utas maka semua utas akan dihentikan dan gambar proses baru akan dimuat dan kemudian dijalankan. Tidak ada fungsi pemusnah yang menamatkan utas proses semasa.
PID proses tidak diubah tetapi data, kod, timbunan, timbunan, dan lain-lain proses diubah dan diganti dengan proses yang baru dimuat. Proses baru dijalankan dari titik masuk.
Panggilan sistem Exec adalah kumpulan fungsi dan dalam bahasa pengaturcaraan C, nama standard untuk fungsi ini adalah seperti berikut:
- eksekl
- melaksanakan
- ekseklp
- execv
- melaksanakan
- eksekusi
Perlu dinyatakan di sini bahawa fungsi ini mempunyai asas yang sama exec diikuti dengan satu atau lebih huruf. Ini dijelaskan di bawah:
Dan: Ini adalah pelbagai petunjuk yang menunjukkan pemboleh ubah persekitaran dan diteruskan secara eksplisit ke proses yang baru dimuat.
yang: l adalah untuk argumen baris perintah menyampaikan senarai ke fungsi
p: p adalah pemboleh ubah persekitaran jalan yang membantu mencari fail yang dilalui sebagai argumen untuk dimuat ke dalam proses.
v: v adalah untuk argumen baris perintah. Ini diserahkan sebagai pelbagai petunjuk fungsi.
Mengapa exec digunakan?
exec digunakan ketika pengguna ingin melancarkan fail atau program baru dalam proses yang sama.
Kerja dalaman exec
Pertimbangkan perkara berikut untuk memahami cara kerja eksekutif:
- Imej proses semasa ditimpa dengan gambar proses baru.
- Imej proses baru adalah gambar yang anda lalui sebagai hujah exec
- Proses yang sedang berjalan berakhir
- Imej proses baru mempunyai ID proses yang sama, persekitaran yang sama, dan deskriptor fail yang sama (kerana proses tidak diganti gambar proses diganti)
- Stat CPU dan memori maya terjejas. Pemetaan memori maya gambar proses semasa digantikan oleh memori maya gambar proses baru.
Sintaks fungsi keluarga exec:
Berikut adalah sintaks untuk setiap fungsi exec:
int execl (const char * path, const char * arg,…)int execlp (const const * file, const char * arg,…)
int execle (const char * path, const char * arg,…, char * const envp [])
int execv (const char * path, const char * argv [])
int execvp (const char * file, const char * argv [])
int execvpe (const const * file, const char * argv [], char * const envp [])
Penerangan:
Jenis pengembalian fungsi ini adalah Int. Apabila gambar proses berjaya diganti tidak ada yang dikembalikan ke fungsi panggilan kerana proses yang memanggilnya tidak lagi berjalan. Tetapi jika ada kesalahan -1 akan dikembalikan. Sekiranya terdapat kesilapan, a errno ditetapkan.
Dalam sintaks:
- jalan digunakan untuk menentukan nama jalan penuh fail yang akan dilaksanakan.
- marah adakah hujah yang dilalui. Ini sebenarnya adalah nama fail yang akan dijalankan dalam prosesnya. Selalunya nilai arg dan jalan sama.
- const char * arg dalam fungsi execl (), execlp () dan execle () dianggap sebagai arg0, arg1, arg2,…, argn. Ini pada dasarnya adalah senarai petunjuk untuk rentetan yang dihentikan. Di sini argumen pertama menunjukkan nama fail yang akan dijalankan seperti yang dijelaskan pada titik 2.
- envp adalah tatasusunan yang mengandungi penunjuk yang menunjuk ke pemboleh ubah persekitaran.
- fail digunakan untuk menentukan nama jalan yang akan mengenal pasti laluan fail gambar proses baru.
- Fungsi panggilan exec yang berakhir dengan Dan digunakan untuk mengubah persekitaran untuk proses gambar baru. Fungsi-fungsi ini melepasi senarai tetapan persekitaran dengan menggunakan argumen envp . Argumen ini adalah susunan watak yang menunjukkan String yang ditamatkan nol dan menentukan pemboleh ubah persekitaran.
Untuk menggunakan fungsi keluarga exec, anda perlu memasukkan fail tajuk berikut dalam program C anda:
#sertakanContoh 1: Menggunakan panggilan sistem exec dalam program C
Pertimbangkan contoh berikut di mana kita telah menggunakan panggilan sistem exec dalam pengaturcaraan C di Linux, Ubuntu: Kami mempunyai dua fail c di sini example.c dan hello.c:
contoh.c
KOD:
#sertakan#sertakan
#sertakan
intutama(intberhujah, char *berhujah[])
{
printf ('PID contoh.c =% d n',getpid());
char *berhujah[] = {'Helo', 'C', 'Pengaturcaraan',BULAN};
execv('./halo',berhujah);
printf ('Kembali ke contoh.c');
kembali 0;
}
hello.c
KOD:
#sertakan#sertakan
#sertakan
intutama(intberhujah, char *berhujah[])
{
printf ('Kami berada di Hello.c n');
printf ('PID hello.c =% d n',getpid());
kembali 0;
}
PENGELUARAN:
PID contoh.c = 4733Kami berada di Hello.c
PID hello.c = 4733
Dalam contoh di atas kita mempunyai fail example.c dan hello.c. Dalam contoh fail .c pertama-tama kita telah mencetak ID proses semasa (contoh file.c sedang berjalan dalam proses semasa). Kemudian pada baris seterusnya kami telah membuat pelbagai petunjuk watak. Elemen terakhir bagi susunan ini harus NULL sebagai titik penamat.
Kemudian kita telah menggunakan fungsi execv () yang mengambil nama fail dan array penunjuk watak sebagai argumennya. Perlu diingatkan di sini bahawa kita telah menggunakan ./ dengan nama file, ini menentukan jalan file. Oleh kerana fail tersebut berada di folder di mana example.c berada, maka tidak perlu menentukan jalan penuh.
Apabila fungsi execv () dipanggil, gambar proses kita akan diganti sekarang file example.c tidak dalam proses tetapi file hello.c sedang dalam proses. Ini dapat dilihat bahawa ID proses adalah sama ada hello.c adalah gambar proses atau contoh.c adalah gambar proses kerana prosesnya sama dan proses gambar hanya diganti.
Kemudian kita ada perkara lain yang perlu diperhatikan di sini iaitu pernyataan printf () setelah execv () tidak dilaksanakan. Ini kerana kawalan tidak akan dikembalikan ke gambar proses lama setelah gambar proses baru menggantikannya. Alat kawalan hanya kembali ke fungsi panggilan apabila penggantian gambar proses tidak berjaya. (Nilai pulangan adalah -1 dalam kes ini).
Perbezaan antara panggilan sistem fork () dan exec ():
Panggilan sistem garpu () digunakan untuk membuat salinan tepat dari proses yang sedang berjalan dan salinan yang dibuat adalah proses anak dan proses berjalan adalah proses induk. Manakala, panggilan sistem exec () digunakan untuk menggantikan gambar proses dengan gambar proses baru. Oleh itu tidak ada konsep proses ibu bapa dan anak dalam sistem panggilan exec ().
Dalam sistem garpu () panggilan ibu bapa dan proses anak dijalankan pada masa yang sama. Tetapi dalam panggilan sistem exec (), jika penggantian gambar proses berjaya, kawalan tidak kembali ke tempat fungsi exec dipanggil sebaliknya ia akan menjalankan proses baru. Kawalan hanya akan dipindahkan kembali sekiranya terdapat ralat.
Contoh 2: Menggabungkan panggilan sistem fork () dan exec ()
Pertimbangkan contoh berikut di mana kita telah menggunakan panggilan sistem fork () dan exec () dalam program yang sama:
contoh.c
KOD:
#sertakan#sertakan
#sertakan
intutama(intberhujah, char *berhujah[])
{
printf ('PID contoh.c =% d n',getpid());
pid_t hlm;
hlm=garpu();
sekiranya(hlm== -1)
{
printf ('Terdapat ralat semasa memanggil garpu ()');
}
sekiranya(hlm==0)
{
printf ('Kami sedang dalam proses kanak-kanak n');
printf ('Memanggil hello.c dari proses anak n');
char *berhujah[] = {'Helo', 'C', 'Pengaturcaraan',BULAN};
execv('./halo',berhujah);
}
yang lain
{
printf ('Kami dalam proses ibu bapa');
}
kembali 0;
}
hello.c:
KOD:
#sertakan#sertakan
#sertakan
intutama(intberhujah, char *berhujah[])
{
printf ('Kami berada di Hello.c n');
printf ('PID hello.c =% d n',getpid());
kembali 0;
}
PENGELUARAN:
PID contoh.c = 4790Kami dalam Proses Ibu Bapa
Kami dalam Proses Anak
Memanggil hello.c dari proses anak
Kami berada di hello.c
PID hello.c = 4791
Dalam contoh ini, kami telah menggunakan sistem panggilan fork (). Semasa proses anak dibuat 0 akan ditugaskan untuk p dan kemudian kita akan beralih ke proses anak. Sekarang blok penyataan dengan (p == 0) akan dilaksanakan. Mesej dipaparkan dan kami telah menggunakan panggilan sistem execv () dan gambar proses anak semasa yang contoh.c akan diganti dengan hello.c. Sebelum proses execv () memanggil anak dan ibu bapa adalah sama.
Dapat dilihat bahawa PID contoh.c dan hello.c kini berbeza. Ini kerana example.c adalah gambar proses ibu bapa dan hello.c adalah gambar proses anak.