Panggilan Sistem Linux Exec

Linux Exec System Call

Panggilan sistem exec digunakan untuk mengeksekusi file yang berada dalam proses aktif. Ketika exec dipanggil, file yang dapat dieksekusi sebelumnya diganti dan file baru dieksekusi.

Lebih tepatnya, kita dapat mengatakan bahwa menggunakan exec system call akan menggantikan file atau program lama dari proses dengan file atau program baru. Seluruh isi proses diganti dengan program baru.



Segmen data pengguna yang mengeksekusi panggilan sistem exec() diganti dengan file data yang namanya diberikan dalam argumen saat memanggil exec().



Program baru dimuat ke dalam ruang proses yang sama. Proses saat ini baru saja berubah menjadi proses baru dan karenanya id proses PID tidak berubah, ini karena kami tidak membuat proses baru, kami hanya mengganti proses dengan proses lain di exec.



Jika proses yang sedang berjalan berisi lebih dari satu utas maka semua utas akan dihentikan dan gambar proses baru akan dimuat dan kemudian dieksekusi. Tidak ada fungsi destruktor yang menghentikan utas proses saat ini.

PID proses tidak diubah tetapi data, kode, tumpukan, tumpukan, dll. dari proses diubah dan diganti dengan proses yang baru dimuat. Proses baru dijalankan dari titik masuk.

Panggilan sistem Exec adalah kumpulan fungsi dan dalam bahasa pemrograman C, nama standar untuk fungsi-fungsi ini adalah sebagai berikut:



  1. execl
  2. pelaksana
  3. eksekusi
  4. eksekutif
  5. eksekutif
  6. execvp


Perlu dicatat di sini bahwa fungsi-fungsi ini memiliki basis yang sama eksekutif diikuti oleh satu huruf atau lebih. Ini dijelaskan di bawah ini:

Dan: Ini adalah array pointer yang menunjuk ke variabel lingkungan dan diteruskan secara eksplisit ke proses yang baru dimuat.

NS: l adalah untuk argumen baris perintah yang meneruskan daftar ke fungsi

P: p adalah variabel lingkungan jalur yang membantu menemukan file yang diteruskan sebagai argumen untuk dimuat ke dalam proses.

v: v adalah untuk argumen baris perintah. Ini dilewatkan sebagai array pointer ke fungsi.

Mengapa exec digunakan?

exec digunakan ketika pengguna ingin meluncurkan file atau program baru dalam proses yang sama.

Kerja dalam dari eksekutif

Pertimbangkan poin-poin berikut untuk memahami cara kerja exec:

  1. Gambar proses saat ini ditimpa dengan gambar proses baru.
  2. Gambar proses baru adalah yang Anda berikan sebagai argumen exec
  3. Proses yang sedang berjalan telah berakhir
  4. Gambar proses baru memiliki ID proses yang sama, lingkungan yang sama, dan deskriptor file yang sama (karena proses tidak diganti gambar proses diganti)
  5. Stat CPU dan memori virtual terpengaruh. Pemetaan memori virtual dari citra proses saat ini digantikan oleh memori virtual dari citra proses baru.

Sintaks fungsi keluarga exec:

Berikut ini 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[])

Keterangan:

Jenis kembalinya fungsi-fungsi ini adalah Int. Ketika gambar proses berhasil diganti, tidak ada yang dikembalikan ke fungsi pemanggilan karena proses yang memanggilnya tidak lagi berjalan. Tetapi jika ada kesalahan -1 akan dikembalikan. Jika terjadi kesalahan dan salah diatur.

Dalam sintaks:

  1. jalur digunakan untuk menentukan nama path lengkap dari file yang akan dieksekusi.
  1. marah adalah argumen berlalu. Ini sebenarnya adalah nama file yang akan dieksekusi dalam proses. Seringkali nilai arg dan path sama.
  1. const char* arg dalam fungsi execl(), execlp() dan execle() dianggap sebagai arg0, arg1, arg2, …, argn. Ini pada dasarnya adalah daftar pointer ke string yang diakhiri null. Di sini argumen pertama menunjuk ke nama file yang akan dieksekusi seperti yang dijelaskan pada poin 2.
  1. envp adalah array yang berisi pointer yang menunjuk ke variabel lingkungan.
  1. mengajukan digunakan untuk menentukan nama jalur yang akan mengidentifikasi jalur file gambar proses baru.
  1. Fungsi panggilan exec yang diakhiri dengan Dan digunakan untuk mengubah lingkungan untuk gambar proses baru. Fungsi-fungsi ini melewati daftar pengaturan lingkungan dengan menggunakan argumen envp . Argumen ini adalah larik karakter yang menunjuk ke String yang diakhiri null dan mendefinisikan variabel lingkungan.

Untuk menggunakan fungsi keluarga exec, Anda perlu menyertakan file header berikut dalam program C Anda:

#termasuk

Contoh 1: Menggunakan panggilan sistem exec dalam program C

Perhatikan contoh berikut di mana kami telah menggunakan panggilan sistem exec dalam pemrograman C di Linux, Ubuntu: Kami memiliki dua file c di sini example.c dan hello.c:

contoh.c

KODE:

#termasuk
#termasuk
#termasuk
ke dalamutama(ke dalamargc, arang *argv[])
{
printf ('PID contoh.c = %d ',getpid());
arang *argumen[] = {'Halo', 'C', 'Pemrograman',BATAL};
eksekutif('./Halo',argumen);
printf ('Kembali ke contoh.c');
kembali 0;
}

halo.c

KODE:

#termasuk
#termasuk
#termasuk
ke dalamutama(ke dalamargc, arang *argv[])
{
printf ('Kami berada di Hello.c ');
printf ('PID halo.c = %d ',getpid());
kembali 0;
}

KELUARAN:

PID dari contoh.c = 4733
Kami berada di Hello.c
PID dari hello.c = 4733

Pada contoh di atas kita memiliki file example.c dan file hello.c. Dalam contoh file .c pertama-tama kita telah mencetak ID dari proses saat ini (file example.c sedang berjalan dalam proses saat ini). Kemudian di baris berikutnya kita telah membuat array pointer karakter. Elemen terakhir dari array ini harus NULL sebagai titik terminasi.

Kemudian kita telah menggunakan fungsi execv() yang mengambil nama file dan array penunjuk karakter sebagai argumennya. Perlu dicatat di sini bahwa kami telah menggunakan ./ dengan nama file, itu menentukan jalur file. Karena file berada di folder tempat example.c berada, jadi tidak perlu menentukan path lengkapnya.

Ketika fungsi execv() dipanggil, gambar proses kita akan diganti sekarang file example.c tidak dalam proses tetapi file hello.c sedang dalam proses. Dapat dilihat bahwa ID proses sama apakah hello.c adalah gambar proses atau example.c adalah gambar proses karena prosesnya sama dan gambar proses hanya diganti.

Kemudian kita memiliki hal lain yang perlu diperhatikan di sini yaitu pernyataan printf() setelah execv() tidak dieksekusi. Ini karena kontrol tidak pernah dikembalikan ke gambar proses lama setelah gambar proses baru menggantikannya. Kontrol hanya kembali ke fungsi panggilan saat mengganti gambar proses tidak berhasil. (Nilai yang dikembalikan adalah -1 dalam kasus ini).

Perbedaan antara panggilan sistem fork() dan exec():

Panggilan sistem fork() digunakan untuk membuat salinan persis dari proses yang sedang berjalan dan salinan yang dibuat adalah proses anak dan proses yang berjalan adalah proses induk. Sedangkan, panggilan sistem exec() digunakan untuk mengganti gambar proses dengan gambar proses baru. Oleh karena itu tidak ada konsep proses induk dan anak dalam panggilan sistem exec().

Dalam panggilan sistem fork(), proses induk dan anak dieksekusi secara bersamaan. Tetapi dalam panggilan sistem exec(), jika penggantian gambar proses berhasil, kontrol tidak kembali ke tempat fungsi exec dipanggil melainkan akan menjalankan proses baru. Kontrol hanya akan ditransfer kembali jika ada kesalahan.

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

KODE:

#termasuk
#termasuk
#termasuk
ke dalamutama(ke dalamargc, arang *argv[])
{
printf ('PID contoh.c = %d ',getpid());
pid_t p;
P=garpu();
jika(P== -1)
{
printf ('Ada kesalahan saat memanggil fork()');
}
jika(P==0)
{
printf ('Kami sedang dalam proses anak ');
printf ('Memanggil hello.c dari proses anak ');
arang *argumen[] = {'Halo', 'C', 'Pemrograman',BATAL};
eksekutif('./Halo',argumen);
}
lain
{
printf ('Kami sedang dalam proses induk');
}
kembali 0;
}

halo.c:

KODE:

#termasuk
#termasuk
#termasuk
ke dalamutama(ke dalamargc, arang *argv[])
{
printf ('Kami berada di Hello.c ');
printf ('PID halo.c = %d ',getpid());
kembali 0;
}

KELUARAN:

PID dari contoh.c = 4790
Kami sedang dalam Proses Induk
Kami sedang dalam Proses Anak
Memanggil hello.c dari proses anak
Kami berada di hello.c
PID dari hello.c = 4791

Dalam contoh ini kita telah menggunakan fork() system call. Ketika proses anak dibuat 0 akan ditugaskan ke p dan kemudian kita akan pindah ke proses anak. Sekarang blok pernyataan dengan if(p==0) akan dieksekusi. Sebuah pesan ditampilkan dan kami telah menggunakan execv() system call dan gambar proses anak saat ini yaitu example.c akan diganti dengan hello.c. Sebelum execv() memanggil proses anak dan orang tua adalah sama.

Terlihat bahwa PID dari example.c dan hello.c sekarang berbeda. Ini karena example.c adalah gambar proses induk dan hello.c adalah gambar proses anak.