ओवरलेइंग प्रोसेस इमेज

मान लें कि हम एक कार्यक्रम चला रहे हैं और हम वर्तमान कार्यक्रम से एक और कार्यक्रम चलाना चाहते हैं। क्या यह संभव है? क्यों नहीं, अगर हम प्रक्रिया छवि को ओवरले करने की अवधारणा को लागू करते हैं। यह ठीक है लेकिन वर्तमान में चल रहे कार्यक्रम के बारे में क्या कहा जा सकता है। यह कैसे संभव है, क्योंकि हम नए कार्यक्रम के साथ वर्तमान कार्यक्रम को समाप्त कर देते हैं। मुझे क्या करना चाहिए, अगर मैं वर्तमान में चल रहे कार्यक्रम को खोए बिना दो कार्यक्रम चलाना चाहता हूं, क्या यह संभव है? हाँ यह संभव है।

एक बच्चे की प्रक्रिया बनाएं, ताकि हमारे पास एक माता-पिता की प्रक्रिया और एक नई बनाई गई बच्चे की प्रक्रिया हो। पहले से ही हम मूल कार्यक्रम में वर्तमान कार्यक्रम चला रहे हैं, इसलिए बच्चे में नई बनाई गई प्रक्रिया को चलाएं। इस तरह, हम वर्तमान कार्यक्रम से एक और कार्यक्रम चला सकते हैं। न केवल एक कार्यक्रम बल्कि हम वर्तमान कार्यक्रम से किसी भी संख्या में कई कार्यक्रम चला सकते हैं जो कि कई बाल प्रक्रियाएं हैं।

आइए हम निम्नलिखित कार्यक्रम को एक उदाहरण के रूप में मानते हैं।

/ * फ़ाइल नाम: helloworld.c * /

#include<stdio.h>

void main() {
   printf("Hello World\n");
   return;
}

/ * फ़ाइल नाम: execl_test.c * /

#include<stdio.h>
#include<unistd.h>

void main() {
   execl("./helloworld", "./helloworld", (char *)0);
   printf("This wouldn't print\n");
   return;
}

उपर्युक्त कार्यक्रम हेलोवर्ल्ड के साथ एक्ज़्लॉट_टैस्ट की प्रक्रिया छवि को ओवरले करेगा। यही कारण है कि, execl_test (printf ()) की प्रक्रिया छवि कोड निष्पादित नहीं है।

संकलन और निष्पादन कदम

Hello World

अब, हम एक प्रोग्राम से दो प्रोग्राम चलाएंगे, यानी, execl_run_two_prgms.c।

• हैलो वर्ल्ड प्रोग्राम (helloworld.c)

• जबकि लूप प्रोग्राम 1 से 10 तक प्रिंट होता है (जबकि__लोप। C।)

/ * फ़ाइल नाम: जबकि_loop.c * /

/* Prints numbers from 1 to 10 using while loop */
#include<stdio.h>

void main() {
   int value = 1;
   while (value <= 10) {
      printf("%d\t", value);
      value++;
   }
   printf("\n");
   return;
}

निम्नलिखित दो कार्यक्रम चलाने के लिए कार्यक्रम (बच्चे से एक कार्यक्रम और माता-पिता से एक और कार्यक्रम) है।

/ * फ़ाइल नाम: execl_run_two_prgms.c * /

#include<stdio.h>
#include<unistd.h>

void main() {
   int pid;
   pid = fork();
   
   /* Child process */
   if (pid == 0) {
      printf("Child process: Running Hello World Program\n");
      execl("./helloworld", "./helloworld", (char *)0);
      printf("This wouldn't print\n");
   } else { /* Parent process */
      sleep(3);
      printf("Parent process: Running While loop Program\n");
      execl("./while_loop", "./while_loop", (char *)0);
      printf("Won't reach here\n");
   }
   return;
}

Note बच्चे और माता-पिता की प्रक्रिया क्रमिक रूप से चले (परिणाम ओवरलैप न करें) सुनिश्चित करने के लिए नींद () कॉल प्लेस करें।

संकलन और निष्पादन कदम

Child process: Running Hello World Program
This wouldn't print
Parent process: Running While loop Program
Won't reach here

अब हम एक प्रोग्राम से दो प्रोग्राम चलाएंगे, जैसे कि execl_run_two_prgms.c, उपरोक्त प्रोग्राम, लेकिन कमांड लाइन आर्ग्युमेंट के साथ। इसलिए, हम चाइल्ड प्रोसेस में दो प्रोग्राम्स क्रमशः Helloworld.c और पेरेंट प्रोसेस में__लोप.है, जबकि प्रोग्राम चला रहे हैं। यह इस प्रकार है -

• हैलो वर्ल्ड प्रोग्राम (helloworld.c)

• जबकि लूप प्रोग्राम 1 से प्रिंट करने के लिए कमांड लाइन तर्क के अनुसार num_times_str (जबकि_loop.c)

यह कार्यक्रम मोटे तौर पर निम्नलिखित क्रियाएं करता है -

• बाल प्रक्रिया बनाता है

• बाल प्रक्रिया Helloworld.c प्रोग्राम को निष्पादित करती है

• पैरेंट प्रक्रिया, प्रोग्राम के तर्क के रूप में कमांड लाइन तर्क मान को पास करते हुए_loop.c प्रोग्राम निष्पादित करती है। यदि कमांड लाइन के तर्क पारित नहीं होते हैं, तो डिफ़ॉल्ट को 10 के रूप में लिया जाता है। अन्यथा, यह दिए गए तर्क मान लेता है। तर्क मूल्य संख्यात्मक होना चाहिए; यदि वर्णमाला में दिया गया है तो कोड मान्य नहीं होगा।

/ * फ़ाइल नाम: execl_run_two_prgms.c * /

#include<stdio.h>
#include<string.h>
#include<unistd.h>

void main(int argc, char *argv[0]) {
   int pid;
   int err;
   int num_times;
   char num_times_str[5];
   
   /* In no command line arguments are passed, then loop maximum count taken as 10 */
   if (argc == 1) {
      printf("Taken loop maximum as 10\n");
      num_times = 10;
      sprintf(num_times_str, "%d", num_times);
   } else {
      strcpy(num_times_str, argv[1]);
      printf("num_times_str is %s\n", num_times_str);
      pid = fork();
   }
   
   /* Child process */
   if (pid == 0) {
      printf("Child process: Running Hello World Program\n");
      err = execl("./helloworld", "./helloworld", (char *)0);
      printf("Error %d\n", err);
      perror("Execl error: ");
      printf("This wouldn't print\n");
   } else { /* Parent process */
      sleep(3);
      printf("Parent process: Running While loop Program\n");
      execl("./while_loop", "./while_loop", (char *)num_times_str, (char *)0);
      printf("Won't reach here\n");
   }
   return;
}

इस कार्यक्रम की बाल प्रक्रिया से पुकारे जाने वाले हेलोवर्ल्ड.सी प्रोग्राम को निष्पादित किया जा रहा है, execl_run_two_prgms.c।

/ * फ़ाइल नाम: helloworld.c * /

#include<stdio.h>

void main() {
   printf("Hello World\n");
   return;
}

कार्यक्रम की मूल प्रक्रिया से पुछे जाने के समय_लोप ..c का पालन किया जाता है, execl_run_two_prgms.c। इस प्रोग्राम का तर्क उस प्रोग्राम से पास किया जाता है जो इसे चलाता है, यानी, execl_run_two_prgms.c।

/ * फ़ाइल नाम: जबकि_loop.c * /

#include<stdio.h>

void main(int argc, char *argv[]) {
   int start_value = 1;
   int end_value;
   if (argc == 1)
   end_value = 10;
   else
   end_value = atoi(argv[1]);
   printf("Argv[1] is %s\n", argv[1]);
   while (start_value <= end_value) {
      printf("%d\t", start_value);
      start_value++;
   }
   printf("\n");
   return;
}

संकलन और निष्पादन कदम

Taken loop maximum as 10
num_times_str is 10
Child process: Running Hello World Program
Hello World
Parent process: Running While loop Program
Argv[1] is 10
1 2 3 4 5 6 7 8 9 10
Taken loop maximum as 15
num_times_str is 15
Child process: Running Hello World Program
Hello World
Parent process: Running While loop Program
Argv[1] is 15
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

आइए अब ओवरलेइंग इमेज संबंधित लाइब्रेरी फ़ंक्शंस देखें।

#include<unistd.h>

int execl(const char *path, const char *arg, ...);

यह फ़ंक्शन नई प्रक्रिया के साथ वर्तमान रनिंग प्रोसेस इमेज को ओवरले करेगा, जैसा कि तर्कों, पथ और आर्ग में वर्णित है। यदि किसी तर्क को एक नई प्रक्रिया छवि को पारित करने की आवश्यकता होती है, तो उसे "arg" तर्कों के माध्यम से भेजा जाएगा और अंतिम तर्क NULL होना चाहिए।

यह फ़ंक्शन त्रुटि के मामले में केवल एक मान लौटाएगा। छवि संबंधी कॉल ओवरले करने की प्रक्रिया नीचे बताई गई है -

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, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]);

ये कॉल पासिंग कमांड लाइन तर्क (argv []], पर्यावरण चर (envp []) और अन्य मापदंडों को संबोधित करेंगे।