हम अपने स्वयं के लिनक्स डेमॉन को स्वचालित रूप से काम को बहाल करने की क्षमता के साथ लिखते हैं

प्रिय हब उपयोगकर्ताओं, मैं आपके साथ सर्वर डेमन लिखने का अनुभव साझा करना चाहूंगा। इस विषय पर रूनेट में बहुत सारे लेख हैं, लेकिन उनमें से अधिकांश ऐसे महत्वपूर्ण सवालों के जवाब नहीं देते हैं:

• ऑटोलैड में डेमन कैसे जोड़ें?
• यदि ऑपरेशन के दौरान कोई त्रुटि हुई और दानव दुर्घटनाग्रस्त हो गया तो क्या करें?
• अपने ऑपरेशन को बाधित किए बिना डेमन कॉन्फ़िगरेशन कैसे अपडेट करें?

इस भाग में, हम निम्नलिखित बातों पर विचार करते हैं:

• दानव का सिद्धांत।
• दानव की स्थिति की निगरानी के विकास की मूल बातें
• लॉग में एक विस्तृत रिपोर्ट के साथ काम पर त्रुटि से निपटने।
• सिस्टम संसाधनों से संबंधित कुछ मुद्दे।

स्पष्टता के लिए, निम्नलिखित भागों का स्रोत कोड दिखाया जाएगा:

• मुख्य कार्यक्रम के लिए टेम्पलेट।
• दानव निगरानी समारोह टेम्पलेट।
• समारोह टेम्पलेट को संभालने में त्रुटि।
• कई सहायक कार्य।

दानव का सिद्धांत।
दानव को देखते हुए, यह पृष्ठभूमि में चलने वाला एक नियमित कार्यक्रम है। लेकिन चूंकि हमारे डेमन init.d से लॉन्च किए जाएंगे, इसलिए इस पर कुछ प्रतिबंध लगाए गए हैं:

• डेमॉन को अपने पीआईडी ​​को एक फ़ाइल में सहेजना होगा ताकि बाद में उसे सही तरीके से रोका जा सके।
• आपको पृष्ठभूमि में आरंभ करने के लिए प्रारंभिक संचालन की एक श्रृंखला को पूरा करना होगा।

हमारे मॉडल में, डेमॉन निम्नलिखित एल्गोरिथम के अनुसार कार्य करेगा:

• नियंत्रण टर्मिनल से अलग और पृष्ठभूमि के लिए संक्रमण।
• माता-पिता (निगरानी) और वंशज (डेमन कार्यक्षमता): दो भागों में अलग होना।
• डेमॉन प्रक्रिया की स्थिति की निगरानी करना।
• कॉन्फिगरेशन अपडेट कमांड को प्रोसेस करना।
• हैंडलिंग में त्रुटि।

कार्यक्रम का खाका।
यह कोड डेमॉन को सफलतापूर्वक लॉन्च करने के लिए आवश्यक सभी कार्यों को पूरा करेगा।

int main( int argc, char ** argv)
{
int status;
int pid;

// ,
if (argc != 2)
{
printf( "Usage: ./my_daemon filename.cfg\n" );
return -1;
}

//
status = LoadConfig(argv[1]);

if (!status) //
{
printf( "Error: Load config failed\n" );
return -1;
}

//
pid = fork();

if (pid == -1) //
{
//
printf( "Error: Start Daemon failed (%s)\n" , strerror(errno));

return -1;
}
else if (!pid) //
{
//
// ,
//
umask(0);

// ,
setsid();

// , , .
//
chdir( "/" );

// //,
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);

//
status = MonitorProc();

return status;
}
else //
{
// , .. ( )
return 0;
}
}

* This source code was highlighted with Source Code Highlighter .

काम का तर्क सरल है और इसे समझने में समस्या नहीं होनी चाहिए। केवल एक चीज जिसे स्पष्ट करने की आवश्यकता है:

• LoadConfig - यह फ़ंक्शन निर्दिष्ट फ़ाइल से कॉन्फ़िगरेशन को लोड करता है, इसका कोड उस कॉन्फ़िगरेशन के प्रारूप पर निर्भर करेगा जो आप उपयोग करते हैं, और इस लेख में विचार नहीं किया जाएगा।
• डिस्क्रिप्टर को बंद करना इस कारण से आवश्यक है कि हम Printf और Scanf और कंसोल I / O के साथ काम करने के अन्य कार्यों का उपयोग नहीं करेंगे। यह क्रिया वैकल्पिक है और संसाधनों को बचाने के लिए उपयोग की जाती है।
• डिस्क की जड़ में जाना आवश्यक है ताकि बाद में डिस्क को अनमाउंट करने से जुड़ी कोई समस्या न हो। यदि डेमॉन का वर्तमान फ़ोल्डर उस डिस्क पर स्थित है जिसे अनमाउंट करने की आवश्यकता है, तो सिस्टम इसे तब तक नहीं देगा जब तक डेमॉन बंद नहीं हो जाता।
• मॉनिटरप्रोक - यह फ़ंक्शन प्रोग्राम की स्थिति की निगरानी से संबंधित बुनियादी कार्यों का प्रदर्शन करेगा।

डेमॉन की स्थिति की निगरानी के विकास की मूल बातें।
निगरानी का मुख्य उद्देश्य डेमन प्रक्रिया की स्थिति की निगरानी करना है। केवल दो बिंदु हमारे लिए महत्वपूर्ण होंगे:

1. डेमॉन प्रक्रिया के पूरा होने की अधिसूचना।
2. डेमन टर्मिनेशन कोड प्राप्त करना।

डेमन की सभी मॉनीटरिंग मॉनिटरपार्क फंक्शन में संलग्न की जाएगी। निगरानी का पूरा बिंदु एक बच्चे की प्रक्रिया शुरू करना और उसकी निगरानी करना है, और इसके पूरा होने के कोड के आधार पर, इसे फिर से शुरू करना या अपना काम पूरा करना है।
मॉनिटरिंग फ़ंक्शन का स्रोत कोड:

int MonitorProc()
{
int pid;
int status;
int need_start = 1;
sigset_t sigset;
siginfo_t siginfo;

//
sigemptyset(&sigset);

//
sigaddset(&sigset, SIGQUIT);

//
sigaddset(&sigset, SIGINT);

//
sigaddset(&sigset, SIGTERM);

//
sigaddset(&sigset, SIGCHLD);

//
sigaddset(&sigset, SIGUSR1);
sigprocmask(SIG_BLOCK, &sigset, NULL);

// PID'
SetPidFile(PID_FILE);

//
for (;;)
{
//
if (need_start)
{
//
pid = fork();
}

need_start = 1;

if (pid == -1) //
{
//
WriteLog( "[MONITOR] Fork failed (%s)\n" , strerror(errno));
}
else if (!pid) //
{
//

//
status = WorkProc();

//
exit(status);
}
else //
{
//

//
sigwaitinfo(&sigset, &siginfo);

//
if (siginfo.si_signo == SIGCHLD)
{
//
wait(&status);

//
status = WEXITSTATUS(status);

// ,
if (status == CHILD_NEED_TERMINATE)
{
//
WriteLog( "[MONITOR] Child stopped\n" );

//
break ;
}
else if (status == CHILD_NEED_WORK) //
{
//
WriteLog( "[MONITOR] Child restart\n" );
}
}
else if (siginfo.si_signo == SIGUSR1) //
{
kill(pid, SIGUSR1); //
need_start = 0; //
}
else // -
{
//
WriteLog( "[MONITOR] Signal %s\n" , strsignal(siginfo.si_signo));

//
kill(pid, SIGTERM);
status = 0;
break ;
}
}
}

// ,
WriteLog( "[MONITOR] Stop\n" );

// PID'
unlink(PID_FILE);

return status;
}

* This source code was highlighted with Source Code Highlighter .

कोड निम्नलिखित को स्पष्ट करना चाहिए:

• PID_FILE - एक स्थिर जो PID'a को बचाने के लिए फ़ाइल नाम को संचित करेगा। हमारे मामले में, यह /var/run/my_daemon.pid है
• WriteLog - एक फ़ंक्शन जो लॉग को लिखता है। इसमें आप अपने दिल की इच्छाओं के साथ आ सकते हैं और कहीं भी एक लॉग लिख सकते हैं, या इसे कहीं भी स्थानांतरित कर सकते हैं
• वर्कप्रोक - एक फ़ंक्शन जो सीधे डेमन कार्यक्षमता को लागू करता है

काम करने के लिए, एक पीआईडी ​​फ़ाइल बनाने के लिए एक सहायक फ़ंक्शन की आवश्यकता होती है।
कोड:

void SetPidFile( char * Filename)
{
FILE* f;

f = fopen(Filename, "w+" );
if (f)
{
fprintf(f, "%u" , getpid());
fclose(f);
}
}

* This source code was highlighted with Source Code Highlighter .

फिलहाल, हमारे डेमॉन पहले से ही अपने वंश को शुरू करने में सक्षम हैं, जो मूल कार्यों को करता है और, यदि आवश्यक हो, तो इसे पुनरारंभ करें या कॉन्फ़िगरेशन बदलने के लिए उसे संकेत भेजें। अगला, वंश कोड टेम्पलेट पर विचार करें:

int WorkProc()
{
struct sigaction sigact;
sigset_t sigset;
int signo;
int status;

//
//
sigact.sa_flags = SA_SIGINFO;
//
sigact.sa_sigaction = signal_error;

sigemptyset(&sigact.sa_mask);

//

sigaction(SIGFPE, &sigact, 0); // FPU
sigaction(SIGILL, &sigact, 0); //
sigaction(SIGSEGV, &sigact, 0); //
sigaction(SIGBUS, &sigact, 0); // ,

sigemptyset(&sigset);

//
//
sigaddset(&sigset, SIGQUIT);

//
sigaddset(&sigset, SIGINT);

//
sigaddset(&sigset, SIGTERM);

//
sigaddset(&sigset, SIGUSR1);
sigprocmask(SIG_BLOCK, &sigset, NULL);

// -
SetFdLimit(FD_LIMIT);

// ,
WriteLog( "[DAEMON] Started\n" );

//
status = InitWorkThread();
if (!status)
{
//
for (;;)
{
//
sigwait(&sigset, &signo);

//
if (signo == SIGUSR1)
{
//
status = ReloadConfig();
if (status == 0)
{
WriteLog( "[DAEMON] Reload config failed\n" );
}
else
{
WriteLog( "[DAEMON] Reload config OK\n" );
}
}
else // - ,
{
break ;
}
}

//
DestroyWorkThread();
}
else
{
WriteLog( "[DAEMON] Create work thread failed\n" );
}

WriteLog( "[DAEMON] Stopped\n" );

//
return CHILD_NEED_TERMINATE;
}

* This source code was highlighted with Source Code Highlighter .

कोड आपको यह कहने की आवश्यकता है:

• InitWorkThread - एक फ़ंक्शन जो सभी डेमन वर्कफ़्लो बनाता है और सभी काम को इनिशियलाइज़ करता है।
• विध्वंस कार्य एक ऐसा कार्य है जो डेमन वर्कर थ्रेड्स को रोकता है और संसाधनों को सही ढंग से मुक्त करता है।
• ReloadConfig - एक फ़ंक्शन जो कॉन्फ़िगरेशन को अपडेट करता है (फ़ाइल को फिर से पढ़ें और अपने काम में आवश्यक बदलाव करें)। फ़ाइल का नाम कमांड लाइन विकल्पों से भी लिया जा सकता है।

ये कार्य पहले से ही डेमॉन के आपके कार्यान्वयन पर निर्भर करते हैं।

ऑपरेशन का सिद्धांत इस प्रकार है: हम अपने हैंडलर को त्रुटि संकेतों के लिए सेट करते हैं, फिर हम सभी कार्यकर्ता थ्रेड शुरू करते हैं और सिग्नल को पूरा करने या कॉन्फ़िगरेशन को अपडेट करने के लिए प्रतीक्षा करते हैं।

लॉग में एक विस्तृत रिपोर्ट के साथ काम पर त्रुटि से निपटने।

बेशक, राक्षसों को पूरी तरह से काम करना चाहिए और किसी भी प्रकार की त्रुटियों का कारण नहीं होना चाहिए, लेकिन हर कोई गलतियां कर सकता है, और कभी-कभी ऐसी त्रुटियां होती हैं जो परीक्षण चरण में पता लगाने में काफी मुश्किल होती हैं। यह विशेष रूप से उन त्रुटियों के लिए सच है जो भारी कार्यभार के साथ होती हैं। इसके लिए, डेमन के विकास में एक महत्वपूर्ण बिंदु त्रुटियों की सही हैंडलिंग है, साथ ही त्रुटि से यथासंभव अधिक जानकारी को निचोड़ना है। इस स्थिति में, हम कॉल स्टैक (बैकट्रेस) को बनाए रखते हुए त्रुटि से निपटने पर विचार करते हैं। यह हमें इस बात की जानकारी देगा कि त्रुटि कहां (किस फंक्शन में) हुई है, और हम यह भी पता लगा सकते हैं कि इस फंक्शन को किसने बुलाया था।

त्रुटि हैंडलर फ़ंक्शन कोड:

static void signal_error( int sig, siginfo_t *si, void *ptr)
{
void * ErrorAddr;
void * Trace[16];
int x;
int TraceSize;
char ** Messages;

//
WriteLog( "[DAEMON] Signal: %s, Addr: 0x%0.16X\n" , strsignal(sig), si->si_addr);


#if __WORDSIZE == 64 // 64
//
ErrorAddr = ( void *)((ucontext_t*)ptr)->uc_mcontext.gregs[REG_RIP];
#else
//
ErrorAddr = ( void *)((ucontext_t*)ptr)->uc_mcontext.gregs[REG_EIP];
#endif

// backtrace
TraceSize = backtrace(Trace, 16);
Trace[1] = ErrorAddr;

//
Messages = backtrace_symbols(Trace, TraceSize);
if (Messages)
{
WriteLog( "== Backtrace ==\n" );

//
for (x = 1; x < TraceSize; x++)
{
WriteLog( "%s\n" , Messages[x]);
}

WriteLog( "== End Backtrace ==\n" );
free(Messages);
}

WriteLog( "[DAEMON] Stopped\n" );

//
DestroyWorkThread();

//
exit(CHILD_NEED_WORK);
}

* This source code was highlighted with Source Code Highlighter .

बैकट्रेस का उपयोग करते समय, आप इस तरह से डेटा प्राप्त कर सकते हैं:
[DAEMON] Signal: Segmentation fault, Addr: 0x0000000000000000
== Backtrace ==
/usr/sbin/my_daemon(GetParamStr+0x34) [0x8049e44]
/usr/sbin/my_daemon(GetParamInt+0x3a) [0x8049efa]
/usr/sbin/my_daemon(main+0x140) [0x804b170]
/lib/tls/i686/cmov/libc.so.6(__libc_start_main+0xe6) [0x126bd6]
/usr/sbin/my_daemon() [0x8049ba1]
== End Backtrace ==

इस डेटा से यह स्पष्ट है कि मुख्य फ़ंक्शन को GetParamInt फ़ंक्शन कहा जाता है। GetParamInt फ़ंक्शन को GetParamStr कहा जाता है। ऑफसेट 0x34 पर GetParamStr फ़ंक्शन में, शून्य पते पर मेमोरी एक्सेस की गई थी।

कॉल स्टैक के अतिरिक्त, आप रजिस्टरों के मूल्य (uc_mcontext.gregs सरणी) को सहेज सकते हैं।
यह ध्यान दिया जाना चाहिए कि बैकट्रेस से सबसे अधिक सूचनात्मक सामग्री केवल डिबगिंग जानकारी को काटने के बिना संकलन करने के साथ-साथ-साथ-विकल्प विकल्प का उपयोग करके प्राप्त की जा सकती है।

जैसा कि आप देख सकते हैं, कोड constants CHILD_NEED_WORK और CHILD_NEED_TERMINATE का उपयोग करता है। आप इन स्थिरांक के मूल्य को स्वयं असाइन कर सकते हैं, मुख्य बात यह है कि वे समान नहीं हैं।

सिस्टम संसाधनों से संबंधित कुछ मुद्दे।

एक महत्वपूर्ण बिंदु अधिकतम विवरणों को सेट करना है। कोई भी खुली फ़ाइल, सॉकेट, पाइप और अन्य विवरणकर्ता खर्च करते हैं, जिसके बाद फ़ाइल को खोलना या सॉकेट बनाना या आने वाले कनेक्शन को स्वीकार करना असंभव होगा। यह डेमॉन के प्रदर्शन को प्रभावित कर सकता है। डिफ़ॉल्ट रूप से, खुले डिस्क्रिप्टर की अधिकतम संख्या 1024 है। अत्यधिक लोड किए गए नेटवर्क डेमन के लिए यह संख्या बहुत कम है। इसलिए, हम अपनी आवश्यकताओं के अनुसार इस मूल्य को अधिक डालेंगे। ऐसा करने के लिए, निम्नलिखित फ़ंक्शन का उपयोग करें:

int SetFdLimit( int MaxFd)
{
struct rlimit lim;
int status;

// -
lim.rlim_cur = MaxFd;
// -
lim.rlim_max = MaxFd;

// -
status = setrlimit(RLIMIT_NOFILE, &lim);

return status;
}

* This source code was highlighted with Source Code Highlighter .

एक निष्कर्ष के बजाय।
इसलिए हमने देखा कि दानव के लिए आधार कैसे बनाया जाए। बेशक, कोड सही होने का दिखावा नहीं करता है, लेकिन यह अपने कार्यों के साथ पूरी तरह से मुकाबला करता है।
अगला लेख एक डेमॉन को स्थापित / अनइंस्टॉल करने, इसे प्रबंधित करने, init.d के लिए स्टार्टअप स्क्रिप्ट लिखने और इसे सीधे स्टार्टअप में जोड़ने से संबंधित मुद्दों पर चर्चा करेगा।

स्रोत कोड लिंक: http://pastebin.com/jdX5wn0E
स्रोत कोड में एक फ़ाइल में उपयोग किए गए सभी फ़ंक्शन शामिल हैं। एक परियोजना का विकास करते समय, उन्हें अपने कार्यात्मक उद्देश्य के अनुसार अलग-अलग फाइलों में बिखेरना उचित है।