इंटरप्ट हैंडलिंग (लिनक्स/सामान्य)

Question

mainbord हम व्यवधान नियंत्रक (आईआरसी) जो उपकरणों के बीच एक बहुसंकेतक जो व्यवधान और सीपीयू को बढ़ा सकते हैं के रूप में कार्य किया है पर:

       |--------| 
      |-----------|  |  | 
-(0)------| IRC _____|______| CPU | 
-(...)----| ____/  |  |  | 
-(15)-----|/   |  |--------| 
      |-----------| 

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

सवाल:

1) मैं एक डिवाइस ड्राइवर लिख सकते हैं और रजिस्टर इसके लिए एक IRQ एक्स हैं। सिस्टम कहां से पता चलता है कि कौन सा डिवाइस संभाला जाना चाहिए? उदाहरण के लिए मैं आईआरक्यू नंबर 10 के साथ request_irq() का उपयोग कर सकता हूं लेकिन सिस्टम कैसे जानता है कि हैंडलर का इस्तेमाल माउस या कीबोर्ड या जो भी मैं ड्राइवर लिखता हूं उसके लिए किया जाना चाहिए?

2) तब इंटरप्ट वेक्टर कैसा दिख रहा है? मेरा मतलब है कि अगर मैं अपने डिवाइस के लिए आईआरक्यू 10 का उपयोग करता हूं तो यह एक मानक हैंडलर को ओवरराइट करेगा जो तालिका में त्रुटि प्रबंधन के लिए है (पहला उपयोग करने योग्य 32 सिल्बरचैट्स (ऑपरेटिंग सिस्टम अवधारणाओं) के अनुसार 32 है)।

3) प्रारंभिक आईआरक्यू कौन सेट करता है? बायोस? ओएस?

4) आईआरक्यू के मिलान और इंटरप्ट वेक्टर में ऑफसेट के लिए कौन जिम्मेदार है?

5) आईआरक्यूएस साझा करना संभव है। वो कैसे संभव है? मेनबोर्ड पर हार्डवेयर लेन हैं जो इंटरप्ट कंट्रोलर को डिवाइस कनेक्ट करते हैं। लेन को उसी इंटरप्ट में कॉन्फ़िगर कैसे किया जा सकता है? एक टेबल होना चाहिए जो लेन 2 और 3 को आईआरक्यू 15 को संभालता है उदा। यह तालिका कहां रहती है और इसे कैसे कहा जाता है?

Answer 1

लिनक्स कर्नेल के संबंध में उत्तर। अधिकांश अन्य ओएस के लिए भी काम करना चाहिए।

1) यदि मैं एक डिवाइस ड्राइवर लिखता हूं और इसके लिए आईआरक्यू एक्स पंजीकृत करता हूं। सिस्टम कहां से पता चलता है कि कौन सा डिवाइस संभाला जाना चाहिए? उदाहरण के लिए मैं आईआरक्यू नंबर 10 के साथ request_irq() का उपयोग कर सकता हूं लेकिन सिस्टम कैसे जानता है कि हैंडलर का इस्तेमाल माउस या कीबोर्ड या जो भी मैं ड्राइवर लिखता हूं उसके लिए किया जाना चाहिए?

इसका कोई जवाब नहीं है। उदाहरण के लिए यदि यह एक कस्टम एम्बेडेड सिस्टम है, तो हार्डवेयर डिजाइनर ड्राइवर लेखक को बताएगा "मैं डिवाइस x से irq y रूट करने जा रहा हूं"। अधिक लचीलापन के लिए, उदाहरण के लिए नेटवर्क कार्ड के लिए जो आमतौर पर पीसीआई प्रोटोकॉल का उपयोग करता है। जब यह पता चला है तो एक नए डिवाइस को एक irq संख्या असाइन करने के लिए हार्डवेयर/फर्मवेयर स्तर मध्यस्थता है। यह तब पीसीआई कॉन्फ़िगरेशन रजिस्टर में से एक को लिखा जाएगा। ड्राइवर पहले इस डिवाइस रजिस्टर को पढ़ता है और उसके बाद उस विशेष irq के लिए अपने इंटरप्ट हैंडलर को पंजीकृत करता है। अन्य प्रोटोकॉल के लिए समान तंत्र होंगे।

आप क्या कर सकते हैं कर्नेल कोड में request_irq पर कॉल और ड्राइवर को irq मान कैसे प्राप्त किया गया है। यह प्रत्येक प्रकार के ड्राइवर के लिए अलग होगा।

इस सवाल का जवाब इस प्रकार है, सिस्टम नहीं जानता है। हार्डवेयर डिजाइनर या हार्डवेयर प्रोटोकॉल इस जानकारी को ड्राइवर लेखक को प्रदान करते हैं। और फिर चालक लेखक उस विशेष irq के लिए हैंडलर को पंजीकृत करता है, सिस्टम को बताता है कि यदि आप उस irq को देखते हैं तो क्या करना है।

2) तब इंटरप्ट वेक्टर कैसा दिख रहा है? मेरा मतलब है कि अगर मैं अपने डिवाइस के लिए आईआरक्यू 10 का उपयोग करता हूं तो यह एक मानक हैंडलर को ओवरराइट करेगा जो तालिका में त्रुटि प्रबंधन के लिए है (पहला उपयोग करने योग्य 32 सिल्बरचैट्स (ऑपरेटिंग सिस्टम अवधारणाओं) के अनुसार 32 है)।

अच्छा सवाल। इसमें दो भाग हैं।

ए) जब आप request_irq (irq, हैंडलर) अनुरोध करते हैं। सिस्टम वास्तव में आईवीटी या आईडीटी में प्रोग्राम एंट्री 0 नहीं करता है। लेकिन प्रवेश एन + irq। जहां एन उस सीपीयू पर समर्थित त्रुटि हैंडलर या सामान्य उद्देश्य अपवादों की संख्या है। विवरण सिस्टम से सिस्टम में भिन्न होते हैं।

बी) यदि आप गलत तरीके से किसी अन्य ड्राइवर द्वारा उपयोग किए जाने वाले आईआरक का अनुरोध करते हैं तो क्या होता है। आपको एक त्रुटि मिलती है और आईडीटी आपके हैंडलर के साथ प्रोग्राम नहीं किया जाता है।

नोट: आईडीटी डिस्क्रिप्टर तालिका को बाधित करता है।

3) प्रारंभिक आईआरक्यू कौन सेट करता है? बायोस? ओएस?

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

4) आईआरक्यू के मिलान और इंटरप्ट वेक्टर में ऑफसेट के लिए कौन जिम्मेदार है?

मैं वास्तव में स्पष्ट नहीं हूं कि आपका क्या मतलब है। प्रवाह इस तरह है। सबसे पहले आपके डिवाइस को एक irq संख्या असाइन की जाती है, और उसके बाद आप उस irq संख्या के साथ एक हैंडलर पंजीकृत करते हैं। यदि आप गलत irq संख्या का उपयोग करते हैं, और फिर अपने डिवाइस पर बाधा सक्षम करते हैं, तो सिस्टम क्रैश हो जाएगा। क्योंकि हैंडलर गलत irq संख्या के लिए पंजीकृत है।

5) आईआरक्यूएस साझा करना संभव है। वो कैसे संभव है? मेनबोर्ड पर हार्डवेयर लेन हैं जो इंटरप्ट कंट्रोलर को डिवाइस कनेक्ट करते हैं। लेन को उसी इंटरप्ट में कॉन्फ़िगर कैसे किया जा सकता है? एक टेबल होना चाहिए जो लेन 2 और 3 को आईआरक्यू 15 को संभालता है उदा। यह तालिका कहां रहती है और इसे कैसे कहा जाता है?

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

The code looks like this: 

driver1: 

d1_int_handler: 
     if (device_interrupted()) <------------- This reads the hardware 
     { 
      do_interrupt_handling(); 
      return MY_INTERRUPT; 
     }else { 
      return NOT_MY_INTERRUPT; 
     } 

driver2: 
     Similar to driver 1 


kernel: 
     do_irq(irq n) 
     { 
      if (shared_irq(n)) 
      { 
       irq_chain = get_chain(n); 
       while(irq_chain) 
       { 
        if ((ret = irq_chain->handler()) == MY_INTERRUPT) 
         break; 
        irq_chain = irq_chain->next; 
       } 
       if (ret != MY_INTERRUPT) 
        error "None of the drivers accepted the interrupt"; 
      } 
     }