Panggilan Sistem Exec Linux

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 semasa memanggil exec ().

Program baru dimuat ke ruang proses yang sama. Proses semasa hanya berubah menjadi proses baru dan oleh itu id proses PID tidak berubah, ini kerana kita tidak membuat proses baru kita hanya mengganti proses dengan proses lain dalam 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 menghentikan urutan 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:

  1. eksekl
  2. melaksanakan
  3. ekseklp
  4. execv
  5. melaksanakan
  6. eksekusi


Perlu diingatkan di sini bahawa fungsi ini mempunyai exec dasar yang sama diikuti dengan satu atau lebih huruf. Ini dijelaskan di bawah:

e: Ini adalah susunan penunjuk yang menunjukkan pemboleh ubah persekitaran dan diteruskan secara eksplisit ke proses yang baru dimuat.

l: 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 diteruskan sebagai pelbagai petunjuk ke 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:

  1. Imej proses semasa ditimpa dengan gambar proses baru.
  2. Imej proses baru adalah gambar yang anda lalui sebagai hujah exec
  3. Proses yang sedang berjalan berakhir
  4. Imej proses baru mempunyai ID proses yang sama, persekitaran yang sama, dan deskriptor fail yang sama (kerana proses tidak diganti gambar proses diganti)
  5. 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 char* 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 char* 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, errno ditetapkan.

Dalam sintaks:

  1. path digunakan untuk menentukan nama path penuh fail yang akan dilaksanakan.
  1. arg adalah hujah yang dilalui. Ini sebenarnya adalah nama fail yang akan dijalankan dalam prosesnya. Selalunya nilai arg dan jalan sama.
  1. 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.
  1. envp adalah tatasusunan yang mengandungi penunjuk yang menunjuk ke pemboleh ubah persekitaran.
  1. fail digunakan untuk menentukan nama jalan yang akan mengenal pasti laluan fail gambar proses baru.
  1. Fungsi panggilan exec yang diakhiri dengan e digunakan untuk mengubah persekitaran untuk proses proses baru. Fungsi-fungsi ini melepasi senarai tetapan persekitaran dengan menggunakan argumen envp . Argumen ini adalah pelbagai watak yang menunjukkan String yang dihentikan nol dan menentukan pemboleh ubah persekitaran.

Untuk menggunakan fungsi keluarga exec, anda perlu memasukkan fail tajuk berikut dalam program C anda:

#include

Contoh 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:

#include
#include
#include
int main(int argc, char *argv[])
{
    printf("PID of example.c = %d\n", getpid());
    char *args[] = {"Hello", "C", "Programming", NULL};
    execv("./hello", args);
    printf("Back to example.c");
    return 0;
}

hello.c

KOD:

#include
#include
#include
int main(int argc, char *argv[])
{
    printf("We are in Hello.c\n");
    printf("PID of hello.c = %d\n", getpid());
    return 0;
}

PENGELUARAN:

PID of example.c = 4733
We are in Hello.c
PID of 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 kita telah membuat pelbagai petunjuk watak. Unsur terakhir bagi susunan ini harus NULL sebagai titik penamat.

Kemudian kami 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, ia 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. Dapat dilihat bahawa ID prosesnya sama ada hello.c adalah gambar proses atau contoh.c adalah gambar proses kerana prosesnya sama dan gambar proses 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 kepada 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 () memanggil 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:

#include
#include
#include
int main(int argc, char *argv[])
{
    printf("PID of example.c = %d\n", getpid());
    pid_t p;
    p = fork();
    if(p==-1)
    {
        printf("There is an error while calling fork()");
    }
    if(p==0)
    {
    printf("We are in the child process\n");
    printf("Calling hello.c from child process\n");
    char *args[] = {"Hello", "C", "Programming", NULL};
    execv("./hello", args);
    }
    else
    {
        printf("We are in the parent process");
    }
    return 0;
}

hello.c:

KOD:

#include
#include
#include
int main(int argc, char *argv[])
{
    printf("We are in Hello.c\n");
    printf("PID of hello.c = %d\n", getpid());
    return 0;
}

PENGELUARAN:

PID of example.c = 4790
We are in Parent Process
We are in Child Process
Calling hello.c from child process
We are in hello.c
PID of hello.c = 4791

Dalam contoh ini, kami telah menggunakan sistem panggilan fork (). Apabila proses anak dibuat 0 akan ditugaskan untuk p dan kemudian kita akan beralih ke proses anak. Sekarang blok penyataan dengan jika (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.

Ini 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.