पिछले सप्ताहांत में, 80386 हार्डवेयर संदर्भ स्विच के बारे में दिलचस्प तथ्यों का अध्ययन करते हुए, मुझे अचानक याद आया कि लिनक्स कर्नेल के पहले संस्करण इस पर निर्भर थे। और मैं उस कोड में डूब गया जिसे मैंने कई सालों से नहीं देखा था। अब मैंने लिनक्स के इतिहास के माध्यम से इस अद्भुत यात्रा का वर्णन करने का निर्णय लिया। मैं सभी सोने की डली और मजेदार कलाकृतियों को दिखाऊंगा जो मुझे रास्ते में मिलीं।

उद्देश्य: लिनक्स कर्नेल में स्विच करने के संदर्भ को पहले (0.01) से बदलकर LTS (4.14.67) के नवीनतम संस्करण में कैसे ट्रैक किया जाए, पहले और नवीनतम संस्करणों पर विशेष जोर दिया गया है।

• प्रारंभिक लिनक्स: प्राचीन इतिहास
  
• लिनक्स 1.0: अवधारणा का प्रमाण
  
• लिनक्स 2.0: उम्मीदवार
  
  • 2.2 सॉफ्टवेयर स्तर स्विचिंग
    
  • 2.4: अंतिम पुराना कोर
• लिनक्स 2.6: लोकप्रियता
  
• लिनक्स 3.0: आधुनिक ओएस
  
• लिनक्स 4.14.67: नवीनतम एलटीएस

वास्तव में, कहानी स्विचिंग संदर्भों के बारे में नहीं है, बल्कि एक छोटी परियोजना से आधुनिक ऑपरेटिंग सिस्टम के लिए लिनक्स के विकास के बारे में है। संदर्भ स्विच बस इस कहानी को दर्शाता है।

हम किस संदर्भ स्विचिंग के बारे में बात कर रहे हैं?

यद्यपि कई चीजें हैं जिन्हें संदर्भ स्विचिंग के रूप में माना जा सकता है (उदाहरण के लिए, कर्नेल मोड पर स्विच करना, एक बाधा हैंडलर पर स्विच करना), मेरा मतलब है आमतौर पर स्वीकृत अर्थ: प्रक्रियाओं के बीच स्विच करना । लिनक्स पर, यह switch_to() मैक्रो और इसमें सब कुछ है।

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

संदर्भ स्विच कार्यों की एक छोटी सूची:

1. कार्यक्षेत्र ओवरराइड: स्टैक रिकवरी (एसएस: एसपी)।
   
2. निम्नलिखित निर्देश खोजें: IP रिकवरी (CS: IP)।
   
3. टास्क स्टेट रिकवरी: सामान्य प्रयोजन रजिस्टरों की बहाली।
   
4. मेमोरी एड्रेस स्पेस स्वैप करना: पेज डायरेक्टरी (CR3) को अपडेट करना
   
5. ... और बहुत कुछ: एफपीयू, ओएस डेटा संरचनाएं, डिबग रजिस्टर, हार्डवेयर वर्कअराउंड, आदि।

यह स्पष्ट नहीं है कि इन कार्यों को कब और कहां किया जाता है, यदि सीपीयू किसी अन्य प्रक्रिया को लेता है। उदाहरण के लिए, लिनक्स 2.2 से पहले हार्डवेयर संदर्भ स्विचिंग कार्य 2, 3 को छुपाता है, और 4. कर्नेल मोड के बीच स्विच करने के बाद से टास्क 3 सीमित है। शेड्यूलर रिटर्न के बाद एक उपयोगकर्ता थ्रेड को पुनर्स्थापित करना एक iret कार्य है। विभिन्न कर्नेल संस्करणों में इनमें से कई कार्य switch_to() और अनुसूचक के बीच switch_to() । हम केवल गारंटी दे सकते हैं कि प्रत्येक संस्करण में हम हमेशा एक स्टैक स्वैप और एफपीयू स्विचिंग देखेंगे।

यह किसके लिए है?

किसी के लिए विशेष रूप से नहीं। समझने के लिए, आपको केवल x86 कोडांतरक को जानना होगा और, संभवतः, OS डिज़ाइन के संदर्भ में न्यूनतम शिक्षा होनी चाहिए।

मुझे तुरंत यह कहना होगा कि मैं लिनक्स कर्नेल का अनुरक्षक या योगदानकर्ता नहीं हूं। इन कामरेडों से या कर्नेल डेवलपर्स मेलिंग सूची से कोई भी जानकारी जो मेरी जानकारी के विपरीत है, को गंभीरता से लिया जाना चाहिए। मेरे पास एक यादृच्छिक व्यक्तिगत परियोजना है, न कि एक सहकर्मी की समीक्षा की गई पत्रिका में एक वैज्ञानिक लेख।

1.0 से पहले प्रारंभिक लिनक्स: प्राचीन इतिहास (1991)

प्रारंभिक लिनक्स कर्नेल सरल और कार्यात्मक है, जिसमें प्रमुख विशेषताओं की एक छोटी सूची है:

• एकल वास्तुकला (80386 / i386): केवल एक प्रकार का संदर्भ स्विच। कई 80386 सुविधाएँ पूरे कोर में हार्डकोड की गई हैं। इन भागों के संदर्भ के लिए, मैंने इंटेल 80386 प्रोग्रामर गाइड (1986) लिया।
  
• हार्डवेयर संदर्भ स्विचिंग: कार्यों को बदलने के लिए, कर्नेल अंतर्निहित तंत्र 80386 का उपयोग करता है।
  
• प्रीमेप्टिव मल्टीटास्किंग के साथ एक प्रक्रिया: एक समय में एक प्रक्रिया के साथ केवल एक सीपीयू सक्रिय होता है। हालांकि, एक और प्रक्रिया किसी भी समय शुरू हो सकती है। इस प्रकार, सामान्य तुल्यकालन नियम लागू होते हैं: साझा संसाधनों को अवरुद्ध करना (स्पिन-लॉक के बिना)। एक चरम मामले में, इंटरप्ट को अक्षम करना संभव है, लेकिन पहले म्यूटेक्स को लॉक करने पर विचार करें।

आगे की हलचल के बिना, दो प्रारंभिक संदर्भ स्विच पर एक नज़र डालें। कोड को बेहतर पठनीयता के लिए स्वरूपित किया गया है: निरंतरता वर्णों (\) के बिना प्रति पंक्ति एक तत्व।

लिनक्स 0.01

 /** include/linux/sched.h */ #define switch_to(n) { struct {long a,b;} __tmp; __asm__("cmpl %%ecx,_current\n\t" "je 1f\n\t" "xchgl %%ecx,_current\n\t" "movw %%dx,%1\n\t" "ljmp %0\n\t" "cmpl %%ecx,%2\n\t" "jne 1f\n\t" "clts\n" "1:" ::"m" (*&__tmp.a), "m" (*&__tmp.b), "m" (last_task_used_math), "d" _TSS(n), "c" ((long) task[n])); } 

लिनक्स 0.11

 /** include/linux/sched.h */ #define switch_to(n) { struct {long a,b;} __tmp; __asm__("cmpl %%ecx,_current\n\t" "je 1f\n\t" "movw %%dx,%1\n\t" "xchgl %%ecx,_current\n\t" "ljmp %0\n\t" "cmpl %%ecx,_last_task_used_math\n\t" "jne 1f\n\t" "clts\n" "1:" ::"m" (*&__tmp.a), "m" (*&__tmp.b), "d" (_TSS(n)), "c" ((long) task[n])); } 

तुरंत हड़ताली वह कितना छोटा है! प्रत्येक पंक्ति को व्यक्तिगत रूप से पार्स करने के लिए छोटा:

 #define switch_to(n) { 

तो switch_to() एक मैक्रो है। यह बिल्कुल एक जगह पर दिखाई देता है: schedule() की अंतिम पंक्ति schedule() । इसलिए, प्रीप्रोसेसिंग के बाद, मैक्रो शेड्यूलर क्षेत्र को साझा करता है। अज्ञात लिंक के वैश्विक क्षेत्र में एक चेक है, जैसे कि current और last_task_used_math । इनपुट तर्क n अगले कार्य की अनुक्रम संख्या है (0 से 63 तक)।

 struct {long a,b;} __tmp; 

स्टैक पर 8 बाइट्स (64 बिट्स) को सुरक्षित रखता है, दो 4-बाइट तत्वों a और b माध्यम से सुलभ। हम लंबी छलांग के संचालन के लिए इनमें से कुछ बाइट्स को बाद में सेट करेंगे।

 __asm__("cmpl %%ecx,_current\n\t" 

संदर्भ स्विच असेंबलर में एक लंबा इनलाइन ब्लॉक है। पहला निर्देश निर्धारित करता है कि क्या लक्ष्य पहले से ही चालू है। यह शेड्यूलर से वर्तमान current के मूल्य के साथ ईसीएक्स रजिस्टर में मूल्य की एक घटिया तुलना है। दोनों में कुछ प्रक्रिया के task_struct लिए संकेत होते हैं। ECX में नीचे दिए गए इनपुट के रूप में लक्ष्य कार्य के लिए एक संकेतक है: "c" ((long) task[n]) । तुलना परिणाम स्थिति रजिस्टर EFLAGS का मूल्य निर्धारित करता है: उदाहरण के लिए, ZF = 1 यदि दोनों बिंदुओं का मिलान होता है (x - x = 0)।

 "je 1f\n\t" 

यदि अगला कार्य वर्तमान एक है, तो आपको संदर्भ को स्विच करने की आवश्यकता नहीं है, इसलिए आपको इस पूरी प्रक्रिया को छोड़ देना चाहिए (कूदना चाहिए)। je निर्देश की जाँच करता है कि ZF = 1. यदि ऐसा है, तो यह कोड में इस बिंदु के बाद पहले लेबल '1' पर जाता है, जो 8 लाइनों से आगे है।

 "xchgl %%ecx,_current\n\t" 

नए कार्य को प्रतिबिंबित करने के लिए वैश्विक current को अद्यतन करता है। ECX (कार्य [n]) से सूचक वर्तमान में बदल जाता है। झंडे अपडेट नहीं किए गए हैं।

 "movw %%dx,%1\n\t" 

लक्ष्य चयनकर्ता डिस्क्रिप्टर सेगमेंट चयनकर्ता (TSS) इंडेक्स को पहले से आरक्षित स्थान पर ले जाता है। तकनीकी रूप से, यह DX रजिस्टर से __tmp.b पर __tmp.b को __tmp.b करता है, __tmp.b , हमारी आरक्षित 8-बाइट संरचना के 8 में से 5 बाइट्स। डीएक्स मान दिया गया इनपुट है: "d" (_TSS(n)) । बहु-स्तरीय _TSS मैक्रो एक वैध TSS खंड चयनकर्ता में विस्तारित होता है, जिसके बारे में मैं थोड़ी देर बाद चर्चा करूंगा। लब्बोलुआब यह है कि दो उच्च बाइट्स __tmp.b अब अगले कार्य के लिए एक सेगमेंट पॉइंटर है।

 "ljmp %0\n\t" 

TSS डिस्क्रिप्टर पर जाने के लिए एक हार्डवेयर संदर्भ स्विच 80386 है। यह सरल छलांग भ्रामक हो सकती है क्योंकि तीन अलग-अलग विचार हैं: पहला, ljmp एक अप्रत्यक्ष लंबी छलांग है जिसमें 6-बाइट (48-बिट) ऑपरेंड की आवश्यकता होती है। दूसरे, ऑपरेंड% 0 का अर्थ है __tmp. चर __tmp. । अंत में, जीडीटी में एक खंड चयनकर्ता पर स्विच करने का x86 में विशेष महत्व है। आइए इन बिंदुओं पर एक नजर डालते हैं।

अप्रत्यक्ष दूर का संक्रमण

महत्वपूर्ण बिंदु यह है कि इस संक्रमण में 6-बाइट का संचालन होता है। 80386 प्रोग्रामर के गाइड ने संक्रमण का वर्णन इस प्रकार है:

__Tmp.a पर जा रहे हैं

याद रखें कि __tmp संरचना में दो 4-बाइट मान शामिल हैं, और संरचना a पर आधारित a । लेकिन अगर हम इस तत्व को 6-बाइट ऑपरेंड के आधार पते के रूप में उपयोग करते हैं, तो हम पूर्णांक __tmp.b अंदर दो बाइट्स तक पहुंच __tmp.b । ये दो बाइट्स दूर पते के "सेगमेंट सेलेक्टर" का हिस्सा हैं। जब प्रोसेसर देखता है कि जीडीटी में सेगमेंट टीएसएस है, तो ऑफसेट का हिस्सा पूरी तरह से नजरअंदाज कर दिया जाता है। तथ्य यह है कि __tmp.a को आरंभीकृत नहीं किया जाता है, इससे कोई फर्क नहीं पड़ता, क्योंकि __tmp.b अभी भी पिछले movw निर्देश के लिए एक मान्य मूल्य है। आरेख में संक्रमण पता जोड़ें:



हमें कैसे पता चलेगा कि यह पता GDT को संदर्भित करता है? मैं कोड की अन्य पंक्तियों में विवरण प्रकट करूंगा, लेकिन संक्षिप्त संस्करण यह है कि चयनकर्ता में चार शून्य बिट्स जीडीटी खोज को ट्रिगर करते हैं। _TSS(n) मैक्रो इन चार शून्य की उपस्थिति की गारंटी देता है। निचले दो बिट खंड विशेषाधिकार स्तर (00 पर्यवेक्षक / कर्नेल से मेल खाते हैं), अगले शून्य बिट का मतलब है GDT तालिका (बूट समय पर GDTR में संग्रहीत)। चौथा शून्य तकनीकी रूप से सेगमेंट इंडेक्स का हिस्सा है, जो सभी TSS को GDT तालिका की समान प्रविष्टियों पर मजबूर करता है।

हार्डवेयर संदर्भ स्विच

__tmp में जंप एड्रेस GDT में TSS हैंडल को परिभाषित करता है। यहाँ बताया गया है कि यह 80386 के मैनुअल में कैसे वर्णित है:



प्रोसेसर स्वचालित रूप से हमारे लिए निम्न कार्य करता है:

• जाँच करता है कि क्या वर्तमान विशेषाधिकार स्तर की अनुमति है (हम कर्नेल मोड में हैं, इसलिए सब कुछ ठीक है)।
  
• सत्यापित करता है कि TSS मान्य है (होना चाहिए)।
  
• कार्य रजिस्टर (TR) में अभी भी संग्रहीत पुराने TSS में सभी वर्तमान कार्य स्थिति को बचाता है, इसलिए आपको EAX, ECX, EDX, EBX, ESP, EBP, ESP, ESI, EDI, ES, CS, SS, DS, FS, का उपयोग करने की आवश्यकता नहीं है जीएस और EFLAGS। ईआईपी को अगले निर्देश पर बढ़ाया जाता है और बचाया भी जाता है।
  
• नए कार्य के लिए TR को अपडेट करता है।
  
• सभी सामान्य रजिस्टर, EIP और PDBR (स्वैप एड्रेस स्पेस) को पुनर्स्थापित करता है। कार्य स्विच समाप्त हो गया है, इसलिए TS फ्लैग को CR0 रजिस्टर में सेट किया गया है।

तो, केवल निर्देश "ljmp %0\n\t" लिया और संदर्भ स्विच करने के सभी चरणों को पूरा किया। यह केवल एक छोटा सा हिस्सा है।

 "cmpl %%ecx,%2\n\t" 

हम सत्यापित करते हैं कि पिछले कार्य ने गणितीय सहसंसाधक को बहाल किया था। तर्क last_task_used_math सूचक है। टीएस ध्वज यह जांचने में मदद करता है कि क्या कॉपरप्रोसेसर का एक अलग संदर्भ है। हार्डवेयर संदर्भ स्विच कोप्रोसेसर को नियंत्रित नहीं करते हैं।

 "jne 1f\n\t" 

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

 "clts\n" 

टीएस ध्वज को साफ़ करें यदि अंतिम प्रक्रिया ने कोप्रोसेसर की स्थिति को बहाल किया।

 "1:" 

प्रसंग स्विच एंड मार्क। इस लेबल के सभी जंप कुछ या सभी प्रक्रियाओं को छोड़ देते हैं।

 ::"m" (*&__tmp.a), 

इस असेंबलर ब्लॉक में कोई आउटपुट नहीं है, और पहला इनपुट (% 0) GDT में TSS डिस्क्रिप्टर के लिए सुदूर सूचक के पहले चार बाइट्स की स्मृति में स्थान है। इसका उपयोग केवल पते के संदर्भ के रूप में किया जाता है, मान आरंभ नहीं किया जाता है।

 "m" (*&__tmp.b), 

दूसरा इनपुट (% 1) TSS डिस्क्रिप्टर के लिए सुदूर सूचक के बाइट्स 5 और 6 की स्मृति में स्थान है। तकनीकी रूप से, यह स्थान मेमोरी में चार बाइट्स रखता है, लेकिन केवल पहले दो को चेक किया जाता है और उपयोग किया जाता है।

 "m" (last_task_used_math), 

तीसरा इनपुट (% 2) पॉइंटर की याद में आखिरी task_struct , जिसने task_struct की स्थिति को बहाल किया।

 "d" (_TSS(n)), 

चौथा इनपुट (% 3 / %% edx) GDT में TSS डिस्क्रिप्टर सेगमेंट चयनकर्ता का पता है। आइए मैक्रो पर एक नज़र डालें:

 #define _TSS(n) ((((unsigned long) n)<<4)+(FIRST_TSS_ENTRY<<3)) #define FIRST_TSS_ENTRY 4 

इसका मतलब यह है कि पहला TSS डिस्क्रिप्टर 4 वां रिकॉर्ड है (इंडेक्स की शुरुआत सेगमेंट चयनकर्ता के 4 बिट के साथ होती है)। प्रत्येक बाद के टीएसएस प्रत्येक दूसरे जीडीटी रिकॉर्ड पर कब्जा कर लेता है: 4, 6, 8, आदि। पहले आठ कार्य इस तरह दिखते हैं:

टास्क #	16-बिट खंड चयनकर्ता
0	0000000000100 0 00
1	0000000000110 0 00
2	0000000001000 0 00
3	0000000001010 0 00
4	0000000001100 0 00
5	0000000001110 0 00
6	0000000010000 0 00
7	0000000010010 0 00

पता बिट्स को फ़ील्ड प्रारूप द्वारा अलग किया जाता है, क्योंकि यह 80386 में होना चाहिए:



चार कम से कम महत्वपूर्ण बिट हमेशा शून्य होते हैं, जो पर्यवेक्षक मोड, जीडीटी तालिका से मेल खाती है, और जीडीटी सूचकांक की प्रविष्टियों को भी बाध्य करता है।

 "c" ((long) task[n])); 

अंतिम प्रविष्टि (% 4 /% ecx) नए टास्क_स्ट्रैक का एक संकेतक है, जिसे हम स्विच करते हैं। ध्यान दें कि संदर्भ स्विच से ठीक पहले %% ecx मान पिछले कार्य में बदल जाता है।

0.01 और 0.11 के बीच अंतर

संदर्भ स्विच के बीच दो अंतर हैं। उनमें से एक सरल कोड सफाई है, और दूसरा आंशिक त्रुटि सुधार है।

• _last_task_used_math इनपुट चर के रूप _last_task_used_math हटा दिया _last_task_used_math क्योंकि प्रतीक पहले से ही वैश्विक दायरे में उपलब्ध है। संबंधित तुलना ऑपरेशन को सीधा लिंक में बदल दिया गया है।
  
• xchgl निर्देश को हार्डवेयर संदर्भ स्विच ( ljmp ) के करीब लाने के लिए xchgl साथ स्वैप किया गया। समस्या यह है कि ये ऑपरेशन परमाणु नहीं हैं: यह संभावना नहीं है कि xchgl और ljmp बीच एक व्यवधान उत्पन्न हो सकता है, जो गलत current कार्य और वास्तविक कार्य के बिना सहेजे गए स्थिति के साथ एक और संदर्भ स्विच को जन्म देगा। इन निर्देशों को प्रतिस्थापित करने से यह स्थिति बहुत कम हो जाती है। हालांकि, एक लंबे समय तक चलने वाली प्रणाली में यह "बहुत कम संभावना" है - "अपरिहार्य" का एक पर्याय।

लिनक्स 1.x: अवधारणा का प्रमाण

0.11 और 1.0 के बीच एक वर्ष में लगभग 20 पैच जारी किए गए थे। अधिकांश प्रयास उपयोगकर्ताओं और डेवलपर्स के लिए ड्राइवरों, सुविधाओं पर केंद्रित थे। कार्यों की अधिकतम संख्या 128 हो गई है, लेकिन संदर्भ स्विच में कई मूलभूत परिवर्तन नहीं हुए हैं।

लिनक्स 1.0

लिनक्स 1.0 अभी भी एक ही सीपीयू पर एक प्रक्रिया के साथ चलता है, हार्डवेयर संदर्भ स्विचिंग का उपयोग करते हुए।



लिनक्स 1.0

 /** include/linux/sched.h */ #define switch_to(tsk) __asm__("cmpl %%ecx,_current\n\t" "je 1f\n\t" "cli\n\t" "xchgl %%ecx,_current\n\t" "ljmp %0\n\t" "sti\n\t" "cmpl %%ecx,_last_task_used_math\n\t" "jne 1f\n\t" "clts\n" "1:" : /* no output */ :"m" (*(((char *)&tsk->tss.tr)-4)), "c" (tsk) :"cx") 

सबसे महत्वपूर्ण परिवर्तन यह था कि इनपुट तर्क कार्य_ संरचना के सरणी के लिए कार्य संख्या सूचकांक नहीं रह गया है। अब switch_to() एक पॉइंटर को एक नए कार्य में ले जाता है। तो आप __tmp संरचना को हटा सकते हैं, और इसके बजाय TSS के लिए एक सीधा लिंक का उपयोग कर सकते हैं। आइए प्रत्येक पंक्ति का विश्लेषण करें।

 #define switch_to(tsk) 

इनपुट अब अगले कार्य को task_struct करने के लिए एक पॉइंटर है।

 "__asm__("cmpl %%ecx,_current\n\t" 

बदला नहीं गया। जाँचता है कि क्या इनपुट कार्य पहले से ही चालू है, इसलिए किसी स्विच की आवश्यकता नहीं है।

 "je 1f\n\t" 

बदला नहीं गया। स्विच नहीं होने पर संदर्भ स्विच करना छोड़ दें।

 "cli\n\t" 

व्यवधानों को बाधित करता है ताकि एक वैश्विक कार्य और हार्डवेयर संदर्भ स्विचिंग को अपडेट करने के बीच टाइमर (या कोई और) दुर्घटनाग्रस्त न हो। यह रुकावट बैंहमर निम्नलिखित दो निर्देश (छद्म) परमाणु बनाकर शुरुआती कर्नेल संस्करणों की समस्या को हल करता है।

 "xchgl %%ecx,_current\n\t" "ljmp %0\n\t" 

कोई परिवर्तन नहीं: नए कार्य को प्रतिबिंबित करने और हार्डवेयर संदर्भ स्विच को लागू करने के लिए वर्तमान प्रक्रिया को स्वैप करें।

 "sti\n\t" 

बदल जाता है पर वापस व्यवधान।

 "cmpl %%ecx,_last_task_used_math\n\t" "jne 1f\n\t" "clts\n" "1:" 

लिनक्स 0.11 की तुलना में सब कुछ अपरिवर्तित है। टीएस रजिस्टर का प्रबंधन करता है और पिछले कार्य से गणितीय कोप्रोसेसर के समाशोधन की निगरानी करता है।

 : /* no output */ 

इस अंतर्निहित कोडांतरक का कोई आउटपुट नहीं है - कर्नेल के पुराने संस्करणों में टिप्पणियों की कमी से कोई स्पष्ट रूप से नाराज था।

 :"m" (*(((char *)&tsk->tss.tr)-4)), 

एक नए कार्य के TSS विवरणक के लिए एक खंड चयनकर्ता लोड करता है, जो अब task_struct सूचक से सीधे पहुँचा जा सकता है। tss.tr तत्व में GDT / TSS मेमोरी के संदर्भ में _TSS (task_number) है जो कर्नेल में 1.0 से पहले उपयोग किया गया था। हम अभी भी 4 बाइट्स से वापस आते हैं और शीर्ष दो बाइट्स लेने के लिए 6-बाइट सेगमेंट चयनकर्ता को लोड करते हैं। मजा आ गया!

 "c" (tsk) 

लगभग अपरिवर्तित - अब हम सीधे सूचक को लोड करते हैं, और इंडेक्स की तलाश नहीं करते हैं।

 :"cx") 

संदर्भ स्विचिंग ईसीएक्स रजिस्टर को ब्लॉक करता है।

लिनक्स 1.3

कर्नेल अब कई नए आर्किटेक्चर का समर्थन करता है: अल्फा, एमआइपीएस और स्पार्क। इसलिए, switch_to() चार अलग-अलग संस्करण हैं, जिनमें से एक कर्नेल को संकलित करते समय शामिल है। आर्किटेक्चर-विशिष्ट कोड को कर्नेल से अलग किया गया था, इसलिए आपको कहीं और x86 संस्करण देखने की आवश्यकता है।

लिनक्स 1.3

 /** include/asm-i386/system.h */ #define switch_to(tsk) do { __asm__("cli\n\t" "xchgl %%ecx,_current\n\t" "ljmp %0\n\t" "sti\n\t" "cmpl %%ecx,_last_task_used_math\n\t" "jne 1f\n\t" "clts\n" "1:" : /* no output */ :"m" (*(((char *)&tsk->tss.tr)-4)), "c" (tsk) :"cx"); /* Now maybe reload the debug registers */ if(current->debugreg[7]){ loaddebug(0); loaddebug(1); loaddebug(2); loaddebug(3); loaddebug(6); } } while (0) 

कुछ छोटे परिवर्तन: पूरे संदर्भ स्विच को नकली डू-टाइम लूप में लपेटा गया है। Feykov क्योंकि वह कभी नहीं दोहराता है। सी में एक नया कार्य करने के लिए स्विच करने की जांच सी में sheduler कोड के लिए switch_to() से चली गई है। कुछ डिबगिंग कार्यों को C कोड से switch_to () में स्थानांतरित कर दिया गया है, संभवतः उन्हें अलग करने से बचने के लिए। आइए बदलावों को देखें।

 #define switch_to(tsk) do { 

अब switch_to() एक डू- switch_to() 0) लूप में लिपटा हुआ है। यह डिज़ाइन त्रुटियों को रोकता है यदि स्थिति (यदि कोई हो) के परिणामस्वरूप मैक्रो कई बयानों तक फैलता है। वर्तमान में, यह नहीं है, लेकिन शेड्यूलर में परिवर्तन को देखते हुए, मुझे संदेह है कि यह कोड के संपादन का परिणाम है, बस मामले में। मेरा अनुमान:

1.3 में वास्तविक योजनाकार

 ...within schedule()... if (current == next) return; kstat.context_swtch++; switch_to(next); 

एक संभावित विकल्प जो switch_to को तोड़ता है ()

 ...within schedule()... if (current != next) switch_to(next); /* do-while(0) 'captures' entire * block to ensure proper parse */ 

 __asm__("cli\n\t" "xchgl %%ecx,_current\n\t" "ljmp %0\n\t" "sti\n\t" "cmpl %%ecx,_last_task_used_math\n\t" "jne 1f\n\t" "clts\n" "1:" : /* no output */ :"m" (*(((char *)&tsk->tss.tr)-4)), "c" (tsk) :"cx"); 

लिनक्स 1.0 की तुलना में कोई परिवर्तन नहीं। फिर भी, इंटरप्ट को करंट से * task_struct स्वैप करने से पहले अक्षम कर दिया जाता है, फिर हार्डवेयर संदर्भ स्विचिंग कार्य करता है और कोप्रोसेसर का उपयोग चेक किया जाता है।

 /* Now maybe reload the debug registers */ if(current->debugreg[7]){ 

सक्रिय ptrace के लिए एक नई प्रक्रिया के लिए डिबगिंग नियंत्रण की जाँच करता है (यहाँ गैर-शून्य पते का अर्थ है सक्रिय ptrace)। डीबग ट्रैकिंग switch_to() में चली गई है। ठीक उसी क्रम C का उपयोग 1.0 में किया जाता है। मुझे लगता है कि डेवलपर्स यह सुनिश्चित करना चाहते थे कि: 1) डिबगिंग संदर्भ स्विच 2 के जितना संभव हो उतना करीब है) स्विच_टो schedule() में नवीनतम है schedule() ।

 loaddebug(0); loaddebug(1); loaddebug(2); loaddebug(3); 

सहेजे गए ptrace स्थिति से डीबग ब्रेकपॉइंट रजिस्टरों को पुनर्स्थापित करता है।

 loaddebug(6); 

सहेजे गए ptrace स्थिति से डीबग नियंत्रण रजिस्टर पुनर्स्थापित करता है।

 } while (0) 

switch_to() ब्लॉक को बंद करता है। हालाँकि, स्थिति हमेशा समान होती है, यह सुनिश्चित करता है कि पार्सर फ़ंक्शन को आधार इकाई के रूप में लेता है जो schedule() में पड़ोसी स्थितियों के साथ बातचीत नहीं करता है schedule() । अंत में अल्पविराम की अनुपस्थिति पर ध्यान दें - यह मैक्रो कॉल के बाद खड़ा होता है: switch_to(next); ।

लिनक्स 2.0: उम्मीदवार (1996)

जून 1996 में, कर्नेल को संस्करण 2.0 में अद्यतन किया गया, इस प्रमुख संस्करण के तहत 15-वर्षीय ओडिसी शुरू किया गया, जो व्यापक व्यावसायिक समर्थन के साथ समाप्त हुआ। 2.x में, कर्नेल में लगभग सभी मूलभूत प्रणालियाँ आमूल परिवर्तन करती हैं। 2.6 से पहले सभी छोटी रिलीज पर विचार करें। संस्करण 2.6 को इतने लंबे समय के लिए विकसित किया गया है कि यह एक अलग अनुभाग के योग्य है।

लिनक्स 2.0

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

अब हमारे पास switch_to() दो संस्करण हैं switch_to() : Linux 1.x से एकल-प्रोसेसर संस्करण (UP) और सममितीय मल्टीप्रोसेसिंग (SMP) के लिए नया उन्नत संस्करण। सबसे पहले, पुराने कोड में बदलाव पर विचार करें, क्योंकि वहां से कुछ बदलाव एसएमपी संस्करण में भी शामिल हैं।

लिनक्स 2.0.1: यूनीप्रोसेसर वर्जन (यूपी)

लिनक्स 2.0.1 (यूपी)

 /** include/asm-i386/system.h */ #else /* Single process only (not SMP) */ #define switch_to(prev,next) do { __asm__("movl %2,"SYMBOL_NAME_STR(current_set)"\n\t" "ljmp %0\n\t" "cmpl %1,"SYMBOL_NAME_STR(last_task_used_math)"\n\t" "jne 1f\n\t" "clts\n" "1:" : /* no outputs */ :"m" (*(((char *)&next->tss.tr)-4)), "r" (prev), "r" (next)); /* Now maybe reload the debug registers */ if(prev->debugreg[7]){ loaddebug(prev,0); loaddebug(prev,1); loaddebug(prev,2); loaddebug(prev,3); loaddebug(prev,6); } } while (0) #endif 

दो बदलाव तुरंत स्पष्ट हैं:

• यू switch_to()का एक नया तर्क है: जिस प्रक्रिया से *task_structहम स्विच कर रहे हैं।
  
• अंतर्निहित कोडांतरक में वर्णों के सही प्रसंस्करण के लिए मैक्रो।

हमेशा की तरह, चलो लाइनों के साथ चलते हैं और परिवर्तनों पर चर्चा करते हैं।

 #define switch_to(prev,next) do { 

तर्क prevउस कार्य को परिभाषित करता है जिसे हम ( *task_struct) से स्विच कर रहे हैं । हम अभी भी मैक्रो को डू-टाइम (0) लूप में लपेट रहे हैं ताकि मैक्रो के चारों ओर सिंगल-लाइन को पार्स करने में मदद मिल सके।

 __asm__("movl %2,"SYMBOL_NAME_STR(current_set)"\n\t" 

वर्तमान में सक्रिय कार्य को नए चयनित में अपडेट करता है। यह कार्यात्मक रूप से समतुल्य है xchgl %%ecx,_current, सिवाय इसके कि हमारे पास SYMBOL_NAME_STRअसेंबली वर्णों को संसाधित करने के लिए कई कार्य_स्ट्रोक और एक मैक्रो ( ) की एक सरणी है । इसके लिए प्रीप्रोसेसर का उपयोग क्यों करें? तथ्य यह है कि कुछ कोडांतरकों (जीएएस) को चर नाम सी के अंडरस्कोर (_) को जोड़ने की आवश्यकता होती है। अन्य कोडांतरकों की यह आवश्यकता नहीं होती है। एक कन्वेंशन को हार्ड ड्राइव न करने के लिए, आप इसे अपने उपकरणों के सेट के अनुसार संकलन समय पर कॉन्फ़िगर कर सकते हैं।

 "ljmp %0\n\t" "cmpl %1,"SYMBOL_NAME_STR(last_task_used_math)"\n\t" "jne 1f\n\t" "clts\n" "1:" : /* no outputs */ :"m" (*(((char *)&next->tss.tr)-4)), 

कोई बदलाव नहीं जिसके बारे में हमने बात नहीं की है।

 "r" (prev), "r" (next)); 

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

 /* Now maybe reload the debug registers */ if(prev->debugreg[7]){ loaddebug(prev,0); loaddebug(prev,1); loaddebug(prev,2); loaddebug(prev,3); loaddebug(prev,6); } } while (0) 

सब कुछ ठीक वैसा ही है जैसा कि कर्नेल 1.3 में।

लिनक्स 2.0.1: मल्टीप्रोसेसर वर्जन (एसएमपी)

लिनक्स 2.0.1 (एसएमपी)

 /** include/asm-i386/system.h */ #ifdef __SMP__ /* Multiprocessing enabled */ #define switch_to(prev,next) do { cli(); if(prev->flags&PF_USEDFPU) { __asm__ __volatile__("fnsave %0":"=m" (prev->tss.i387.hard)); __asm__ __volatile__("fwait"); prev->flags&=~PF_USEDFPU; } prev->lock_depth=syscall_count; kernel_counter+=next->lock_depth-prev->lock_depth; syscall_count=next->lock_depth; __asm__("pushl %%edx\n\t" "movl "SYMBOL_NAME_STR(apic_reg)",%%edx\n\t" "movl 0x20(%%edx), %%edx\n\t" "shrl $22,%%edx\n\t" "and $0x3C,%%edx\n\t" "movl %%ecx,"SYMBOL_NAME_STR(current_set)"(,%%edx)\n\t" "popl %%edx\n\t" "ljmp %0\n\t" "sti\n\t" : /* no output */ :"m" (*(((char *)&next->tss.tr)-4)), "c" (next)); /* Now maybe reload the debug registers */ if(prev->debugreg[7]){ loaddebug(prev,0); loaddebug(prev,1); loaddebug(prev,2); loaddebug(prev,3); loaddebug(prev,6); } } while (0) 

क्या पहले से ही समझ में नहीं आ रहा है? मैं कहना चाहूंगा कि बाद में यह बेहतर हो जाएगा, लेकिन एसएमपी की दुनिया में ऐसा नहीं होगा। अंतरिक्ष को बचाने के लिए, मैं अब अपरिवर्तित तारों की सूची नहीं दूंगा।

एसएमपी संदर्भ स्विच के लिए तीन जोड़: 1) जिस तरह से एक एकल कोप्रोसेसर कई प्रोसेसर के साथ काम करता है उसे बदलना; 2) लॉक की गहराई को नियंत्रित करना, क्योंकि कर्नेल लॉक पुनरावर्ती है; 3) वर्तमान * task_struct के लिए CPU ID प्राप्त करने के लिए APIC से लिंक करें।

 if(prev->flags&PF_USEDFPU) 

जाँचता है कि जिस कार्य को हम स्विच कर रहे हैं वह एक कॉपीप्रोसेसर का उपयोग करता है। यदि हां, तो आपको स्विच करने से पहले एफपीयू में संदर्भ को कैप्चर करना होगा।

 __asm__ __volatile__("fnsave %0":"=m" (prev->tss.i387.hard)); 

TSS को FPU राज्य बचाता है। FNSAVE का उपयोग अपवाद हैंडलिंग को छोड़ने के लिए किया जाता है। __volatile__ऑप्टिमाइज़र द्वारा परिवर्तनों से इस निर्देश की रक्षा करनी चाहिए।

 __asm__ __volatile__("fwait"); 

सीपीयू की प्रतीक्षा की जा रही है जबकि एफपीयू पिछले बचत के साथ व्यस्त है।

 prev->flags&=~PF_USEDFPU; 

इस कार्य के लिए एक कोप्रोसेसर का उपयोग करने के ध्वज को अक्षम करता है, हमेशा शून्य होता है।

 prev->lock_depth=syscall_count; 

किसी पुराने कार्य के लिए कर्नेल लॉकिंग के नेस्टेड उपयोग की संख्या संग्रहीत करता है।

 kernel_counter+=next->lock_depth-prev->lock_depth; 

वैश्विक कर्नेल लॉक काउंटर को अगले कार्य के लिए पुराने कार्य को घटा देता है। प्रभावी रूप से अब निष्क्रिय पुराने कार्य से लॉक को हटा देता है, और नया कार्य उस स्थान से काम करना जारी रख सकता है जहां यह रुका था।

 syscall_count=next->lock_depth; 

किसी नए कार्य की लॉक स्थिति लौटाता है। यह वह जगह होनी चाहिए जहां वह समय के आखिरी खिंचाव में छूट गई।

 __asm__("pushl %%edx\n\t" 

हम EDX का उपयोग करने जा रहे हैं, इसलिए हम इसका वर्तमान मूल्य रखेंगे।

 "movl "SYMBOL_NAME_STR(apic_reg)",%%edx\n\t" 

EDIC I / O पते को EDX पर ले जाता है। हमें सीपीयू आईडी प्राप्त करने के लिए एपीआईसी का उपयोग करने की आवश्यकता है, क्योंकि हमें नहीं पता है कि कौन सा प्रोसेसर काम कर रहा है। apic_regOS आरंभीकरण के दौरान प्रसारण।

 "movl 0x20(%%edx), %%edx\n\t" 

EDX में APIC पहचानकर्ता रजिस्टर के मान को हटाता है। वास्तविक आईडी बिट्स 24-27 में है।

 "shrl $22,%%edx\n\t" 

APIC ID को 2-5 बिट्स पर शिफ्ट करता है।

 "and $0x3C,%%edx\n\t" 

बिट्स 2-5 में केवल APIC ID को मास्क करता है, जिससे CPU नंबर * 4 निकल जाता है।

 "movl %%ecx,"SYMBOL_NAME_STR(current_set)"(,%%edx)\n\t" 

वर्तमान सीपीयू के कार्य सूचक को अगले कार्य के लिए अद्यतन करता है। यूपी संस्करण ने वर्तमान कार्य को संग्रहीत करने के लिए ECX के विशिष्ट उपयोग को पहले ही हटा दिया है, लेकिन इसका उपयोग अभी भी SMP संस्करण में किया जाता है। EDX बिट्स में CPU संख्या 2-5, 4 से गुणा करता है, पॉइंटर आकार को _current_set से ऑफसेट करने के लिए स्केल में है।

 "popl %%edx\n\t" 

हमें ईडीएक्स के साथ किया जाता है, इसलिए हम इस प्रक्रिया से पहले उस मूल्य को बहाल करेंगे।

शेष रेखाएँ समान हैं।

लिनक्स 2.2 (1999)

लिनक्स 2.2 वास्तव में प्रतीक्षा के लायक था: यहां सॉफ्टवेयर संदर्भ स्विच आया था ! हम अभी भी TSS को संदर्भित करने के लिए टास्क रजिस्टर (TR) का उपयोग करते हैं। एसएमपी और यूपी प्रक्रिया एकीकृत एफपीयू राज्य प्रसंस्करण के साथ संयुक्त हैं। अधिकांश संदर्भ स्विचिंग अब सी। लिनक्स 2.2.0 कोड



(अंतर्निहित कोडांतरक) में किया जाता है

 /** include/asm-i386/system.h */ #define switch_to(prev,next) do { unsigned long eax, edx, ecx; asm volatile("pushl %%ebx\n\t" "pushl %%esi\n\t" "pushl %%edi\n\t" "pushl %%ebp\n\t" "movl %%esp,%0\n\t" /* save ESP */ "movl %5,%%esp\n\t" /* restore ESP */ "movl $1f,%1\n\t" /* save EIP */ "pushl %6\n\t" /* restore EIP */ "jmp __switch_to\n" "1:\t" "popl %%ebp\n\t" "popl %%edi\n\t" "popl %%esi\n\t" "popl %%ebx" :"=m" (prev->tss.esp),"=m" (prev->tss.eip), "=a" (eax), "=d" (edx), "=c" (ecx) :"m" (next->tss.esp),"m" (next->tss.eip), "a" (prev), "d" (next)); } while (0) 

यह नया एक आम switch_to()तौर पर पिछले सभी संस्करणों से अलग है: यह सरल है! अंतर्निहित कोडांतरक में, हम स्टैक और निर्देश बिंदु (संदर्भ स्विचिंग कार्य 1 और 2) स्वैप करते हैं। C ( __switch_to()) कोड में जाने के बाद बाकी सब कुछ किया जाता है ।

 asm volatile("pushl %%ebx\n\t" "pushl %%esi\n\t" "pushl %%edi\n\t" "pushl %%ebp\n\t" 

स्टोर EBX, ESI, EDI और EBP प्रक्रिया के ढेर में हम स्वैप करने जा रहे हैं। (... क्यों EBX?)

 "movl %%esp,%0\n\t" /* save ESP */ "movl %5,%%esp\n\t" /* restore ESP */ 

जैसा कि आप टिप्पणियों से देख सकते हैं, हम पुरानी और नई प्रक्रिया के बीच स्टैक पॉइंटर्स स्वैप करते हैं। पुरानी प्रक्रिया में ऑपरेंड% 0 ( prev->tss.esp) है, जबकि नई प्रक्रिया में % 5 ( next->tss.esp) है।

 "movl $1f,%1\n\t" /* save EIP */ 

संदर्भ वापस स्विच करने के बाद पुराने कार्य के अगले निर्देश के लिए निर्देश सूचक के मूल्य को सहेजना। ध्यान दें कि निम्न कथन का मान एक लेबल का उपयोग करता है 1:

 "pushl %6\n\t" /* restore EIP */ 

नए कार्य के लिए निम्नलिखित निर्देश तैयार करें। चूंकि हमने अभी एक नए स्टैक पर स्विच किया है, इसलिए यह आईपी नए कार्य के TSS से लिया गया है और स्टैक के शीर्ष पर रखा गया है। निष्पादन सी ​​कोड के 'रिट' के बाद निम्नलिखित कथन से शुरू होगा जिसे हम निष्पादित करने वाले हैं।

 "jmp __switch_to\n" 

हम अपने नए और बेहतर सॉफ़्टवेयर संदर्भ स्विच पर जाते हैं (नीचे देखें)।

 "popl %%ebp\n\t" "popl %%edi\n\t" "popl %%esi\n\t" "popl %%ebx" 

हम एक नए समय अंतराल में पुराने कार्य पर स्विच करने के बाद, संभवतः रिवर्स ऑर्डर में स्टैक से रजिस्टरों को पुनर्स्थापित करते हैं।

लिनक्स 2.2.0 (C)

 /** arch/i386/kernel/process.c */ void __switch_to(struct task_struct *prev, struct task_struct *next) { /* Do the FPU save and set TS if it wasn't set before.. */ unlazy_fpu(prev); gdt_table[next->tss.tr >> 3].b &= 0xfffffdff; asm volatile("ltr %0": :"g" (*(unsigned short *)&next->tss.tr)); asm volatile("movl %%fs,%0":"=m" (*(int *)&prev->tss.fs)); asm volatile("movl %%gs,%0":"=m" (*(int *)&prev->tss.gs)); /* Re-load LDT if necessary */ if (next->mm->segments != prev->mm->segments) asm volatile("lldt %0": :"g" (*(unsigned short *)&next->tss.ldt)); /* Re-load page tables */ { unsigned long new_cr3 = next->tss.cr3; if (new_cr3 != prev->tss.cr3) asm volatile("movl %0,%%cr3": :"r" (new_cr3)); } /* Restore %fs and %gs. */ loadsegment(fs,next->tss.fs); loadsegment(gs,next->tss.gs); if (next->tss.debugreg[7]){ loaddebug(next,0); loaddebug(next,1); loaddebug(next,2); loaddebug(next,3); loaddebug(next,6); loaddebug(next,7); } } 

सॉफ़्टवेयर संदर्भ स्विच में, TSS डिस्क्रिप्टर के लिए पुराने संक्रमण को नए C: फ़ंक्शन के लिए संक्रमण द्वारा बदल दिया गया था __switch_to()। यह फ़ंक्शन सी में लिखा गया है और इसमें कई परिचित घटक शामिल हैं, जैसे डिबग रजिस्टर। C पर जाने से आप उन्हें संदर्भ स्विच के और भी करीब ले जा सकते हैं।

 unlazy_fpu(prev); 

हम एफपीयू के उपयोग की जांच करते हैं और यदि इसका उपयोग करते हैं, तो इसकी स्थिति को बचा सकते हैं। अब यह हर प्रक्रिया के लिए होता है जो FPU का उपयोग करता है, इसलिए सफाई अब आलसी नहीं है। प्रक्रिया 2.0.1 से एसएमपी दिनचर्या के समान है, सिवाय इसके कि अब हमारे पास एक स्वच्छ मैक्रो है जिसमें मैनुअल टीएस ट्यूनिंग शामिल है।

 gdt_table[next->tss.tr >> 3].b &= 0xfffffdff; 

भविष्य के कार्य विवरणक के लिए BUSY बिट को साफ़ करता है। GDT को अनुक्रमित करने के लिए कार्य संख्या का उपयोग करता है। tss.trकार्य खंड चयनकर्ता का मान समाहित करता है, जहां निचले तीन बिट्स अनुमतियों के लिए उपयोग किए जाते हैं। हमें केवल एक इंडेक्स की आवश्यकता है, इसलिए हम इन बिट्स को शिफ्ट करते हैं। दूसरा TSS बाइट बिट 10 को हटाने के लिए संशोधित किया गया है।

 asm volatile("ltr %0": :"g" (*(unsigned short *)&next->tss.tr)); 

टास्क रजिस्टर एक पॉइंटर के साथ अगले कार्य खंड चयनकर्ता को लोड किया जाता है।

 asm volatile("movl %%fs,%0":"=m" (*(int *)&prev->tss.fs)); asm volatile("movl %%gs,%0":"=m" (*(int *)&prev->tss.gs)); 

पिछले कार्य के लिए FS और GS खंड रजिस्टर TSS में संग्रहीत हैं। हार्डवेयर संदर्भ स्विच में, यह चरण स्वचालित रूप से निष्पादित किया गया था, लेकिन अब हमें मैन्युअल रूप से ऐसा करने की आवश्यकता है। लेकिन क्यों? लिनक्स एफएस और जीएस का उपयोग कैसे करता है?

लिनक्स 2.2 (1999) पर कोई स्पष्ट उत्तर नहीं है। केवल यह कहा जाता है कि उनका उपयोग किया जाता है, इसलिए आपको उन्हें सहेजना चाहिए ताकि वे सुलभ रहें। कर्नेल मोड या उपयोगकर्ता डेटा को इंगित करने के लिए कर्नेल-मोड कोड इन खंडों को "उधार" देगा। साउंड और नेटवर्क ड्राइवर ऐसा ही करते हैं। हाल ही में (~ 2.6 आगे) एफएस और जीएस अक्सर स्थानीय स्ट्रीम स्टोरेज और डेटा क्षेत्र प्रति प्रोसेसर का समर्थन करते हैं।

 if (next->mm->segments != prev->mm->segments) asm volatile("lldt %0": :"g" (*(unsigned short *)&next->tss.ldt)); 

स्थानीय डिस्क्रिप्टर तालिका के खंडों को पुनर्स्थापित करता है यदि वे पहले से ही पुरानी प्रक्रिया के अनुरूप नहीं हैं। यह LDT रजिस्टर लोड करके किया जाता है।

 if (new_cr3 != prev->tss.cr3) asm volatile("movl %0,%%cr3": :"r" (new_cr3)); 

किसी नए कार्य के लिए वर्चुअल मेमोरी की स्थिति को अद्यतन करता है। विशेष रूप से, CR3 रजिस्टर सेट है, जिसमें एक नए संदर्भ में मेमोरी एक्सेस करने के लिए पृष्ठों की एक निर्देशिका है।

 loadsegment(fs,next->tss.fs); loadsegment(gs,next->tss.gs); 

नए कार्य के लिए एफएस और जीएस को बहाल किया जा रहा है। यह सही संरेखण सुनिश्चित करता है, और एक समस्या के मामले में, शून्य खंड लोड होता है।

 loaddebug(prev,7); 

अंत में, डीबग कंट्रोल रजिस्टर अब टीएसएस का उपयोग करके संग्रहीत और स्विच किया जाता है। पहले, यह रजिस्टर केवल चेक किया गया था, और भंडारण के लिए उपयोग नहीं किया गया था।

लिनक्स 2.4 (2001)

वर्जन 2.4 ने कर्नेल थ्रेड्स और टास्क क्यू जैसे कई नए फीचर्स पेश किए। शेड्यूलर में इसके और कुछ बदलावों के बावजूद, संदर्भ स्विच संस्करण 2.2 की तुलना में बहुत अधिक नहीं बदला है, हालांकि इसने सभी रजिस्टर डेटा को बदलने के पक्ष में टीआर को अपडेट करना बंद कर दिया है। मैं अनौपचारिक रूप से इसे "अंतिम लिगेसी कर्नेल" कहता हूं, क्योंकि सभी भविष्य के रिलीज 64-बिट x86 आर्किटेक्चर का उपयोग करते हैं।



लिनक्स 2.4.0 (अंतर्निहित कोडांतरक)

 /** include/asm-i386/system.h */ #define switch_to(prev,next,last) do { asm volatile("pushl %%esi\n\t" "pushl %%edi\n\t" "pushl %%ebp\n\t" "movl %%esp,%0\n\t" /* save ESP */ "movl %3,%%esp\n\t" /* restore ESP */ "movl $1f,%1\n\t" /* save EIP */ "pushl %4\n\t" /* restore EIP */ "jmp __switch_to\n" "1:\t" "popl %%ebp\n\t" "popl %%edi\n\t" "popl %%esi\n\t" :"=m" (prev->thread.esp),"=m" (prev->thread.eip), "=b" (last) :"m" (next->thread.esp),"m" (next->thread.eip), "a" (prev), "d" (next), "b" (prev)); } while (0) 

2.4 कर्नेल में संदर्भ स्विच केवल कुछ मामूली बदलाव करता है: EBX को अब धक्का नहीं दिया गया है, लेकिन अंतर्निहित कोडांतरक के आउटपुट में शामिल है। एक नया इनपुट तर्क सामने आया lastहै जिसमें समान मान है prev। यह ईबीएक्स के माध्यम से प्रेषित होता है, लेकिन इसका उपयोग नहीं किया जाता है।

 :"=m" (prev->thread.esp),"=m" (prev->thread.eip), :"m" (next->thread.esp),"m" (next->thread.eip), 

I / O ऑपरेंड अब कर्नेल थ्रेड्स के लिए स्टैक / निर्देश पॉइंटर्स को संदर्भित करता है। संदर्भ स्विच टीएसएस से स्टैक पॉइंटर्स को संदर्भित करने के लिए उपयोग किया जाता है।

लिनक्स 2.4.0 (C)

 /** arch/i386/kernel/process.c */ void __switch_to(struct task_struct *prev_p, struct task_struct *next_p) { struct thread_struct *prev = &prev_p->thread, *next = &next_p->thread; struct tss_struct *tss = init_tss + smp_processor_id(); unlazy_fpu(prev_p); tss->esp0 = next->esp0; asm volatile("movl %%fs,%0":"=m" (*(int *)&prev->fs)); asm volatile("movl %%gs,%0":"=m" (*(int *)&prev->gs)); /* Restore %fs and %gs. */ loadsegment(fs, next->fs); loadsegment(gs, next->gs); /* Now maybe reload the debug registers */ if (next->debugreg[7]){ loaddebug(next, 0); loaddebug(next, 1); loaddebug(next, 2); loaddebug(next, 3); /* no 4 and 5 */ loaddebug(next, 6); loaddebug(next, 7); } if (prev->ioperm || next->ioperm) { if (next->ioperm) { memcpy(tss->io_bitmap, next->io_bitmap, IO_BITMAP_SIZE*sizeof(unsigned long)); tss->bitmap = IO_BITMAP_OFFSET; } else tss->bitmap = INVALID_IO_BITMAP_OFFSET; } } 

सी कोड वाले हिस्से ने कुछ चीजें बदल दी हैं। TR रजिस्टर का कोई उल्लेख गायब हो गया है, इसके बजाय, हम वर्तमान प्रोसेसर के लिए सक्रिय TSS को सीधे बदल देते हैं। इनलाइन कोडांतरक के रूप में, प्रत्येक कार्य TSS डेटा को थ्रेड_स्ट्रोक के अंदर task_struct के संदर्भ में संदर्भित करता है। प्रत्येक सक्रिय CPU GDT से समर्पित TSS का उपयोग करता है और इन क्षेत्रों को सीधे अपडेट करता है।

 void __switch_to(struct task_struct *prev_p, struct task_struct *next_p) 

पिछले और अगले कार्यों के संकेत पर एक प्रत्यय जोड़ा गया है _p। यह एक छोटी लेकिन महत्वपूर्ण अति सूक्ष्म अंतर वजह से है prevऔर nextगिरी धागे में बदलने के लिए जा रहा है।

 struct thread_struct *prev = &prev_p->thread, *next = &next_p->thread; 

प्रत्येक कार्य के लिए TSS डेटा के बिंदु निर्धारित किए जाते हैं।

 tss->esp0 = next->esp0; 

नए कार्य से ऑफसेट के साथ स्टैक ऑफ़सेट रिंग 0 की जगह। जब तक यह पृष्ठ तालिका के पुनः लोड के लिए बाध्य न हो जाए ...

 asm volatile("movl %%fs,%0":"=m" (*(int *)&prev->fs)); asm volatile("movl %%gs,%0":"=m" (*(int *)&prev->gs)); 

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

 if (prev->ioperm || next->ioperm) { if (next->ioperm) { memcpy(tss->io_bitmap, next->io_bitmap, IO_BITMAP_SIZE*sizeof(unsigned long)); tss->bitmap = IO_BITMAP_OFFSET; 

आगामी कार्य के लिए सक्रिय TSS में पोर्ट मैपिंग I / O अनुमतियाँ सेट करता है।

 } else tss->bitmap = INVALID_IO_BITMAP_OFFSET; 

एक ज्ञात अमान्य बिटमैप (0x8000) के लिए सक्रिय TSS के लिए I / O अनुमतियाँ इंगित करता है।

लिनक्स 2.6: लोकप्रियता (2003)

जैसे ही कर्नेल 2.5 विदा हुआ, लीनियर-रन शेड्यूलर व्यावहारिक उपयोग की सीमा तक पहुंच गया, और एएमडी ने x86 के लिए एक एक्सटेंशन जारी किया जिसे कर्नेल डेवलपर्स का तत्काल ध्यान देने की आवश्यकता थी: x86-64।

लिनक्स 2.6.0

एक स्थिर क्रम के साथ कर्नेल अनुसूचक कर्नेल में 2.6.0 दिखाई दिया है। हालांकि यह पिछले रैखिक अनुसूचक की तुलना में एक कदम आगे है, लेकिन 2.6.23 में अंततः इसे पूरी तरह से निष्पक्ष अनुसूचक (सीएफएस) द्वारा बदल दिया गया। दूसरी ओर, नए 64-बिट आर्किटेक्चर ने आज तक के सबसे महत्वपूर्ण बदलाव किए हैं।

लिनक्स 2.6.0: i386 संस्करण

यह लेख में 32-बिट संदर्भ स्विच की नवीनतम उपस्थिति है।



लिनक्स 2.6.0 (i386 में निर्मित कोडांतरक)

 /** include/asm-i386/system.h */ #define switch_to(prev,next,last) do { unsigned long esi,edi; asm volatile("pushfl\n\t" "pushl %%ebp\n\t" "movl %%esp,%0\n\t" /* save ESP */ "movl %5,%%esp\n\t" /* restore ESP */ "movl $1f,%1\n\t" /* save EIP */ "pushl %6\n\t" /* restore EIP */ "jmp __switch_to\n" "1:\t" "popl %%ebp\n\t" "popfl" :"=m" (prev->thread.esp),"=m" (prev->thread.eip), "=a" (last),"=S" (esi),"=D" (edi) :"m" (next->thread.esp),"m" (next->thread.eip), "2" (prev), "d" (next)); } while (0) 

चार लाइनें हटाई गईं। ESI और EDI को पहले स्टैक पर धकेल दिया गया था, लेकिन अब I / O ऑपरेंड के माध्यम से धकेल दिया गया है।

लिनक्स 2.6.0 (i386 C)

 /** arch/i386/kernel/process.c */ struct task_struct * __switch_to(struct task_struct *prev_p, struct task_struct *next_p) { struct thread_struct *prev = &prev_p->thread, *next = &next_p->thread; int cpu = smp_processor_id(); struct tss_struct *tss = init_tss + cpu; __unlazy_fpu(prev_p); load_esp0(tss, next->esp0); /* Load the per-thread Thread-Local Storage descriptor. */ load_TLS(next, cpu); asm volatile("movl %%fs,%0":"=m" (*(int *)&prev->fs)); asm volatile("movl %%gs,%0":"=m" (*(int *)&prev->gs)); /* Restore %fs and %gs if needed. */ if (unlikely(prev->fs | prev->gs | next->fs | next->gs)) { loadsegment(fs, next->fs); loadsegment(gs, next->gs); } /* Now maybe reload the debug registers */ if (unlikely(next->debugreg[7])) { loaddebug(next, 0); loaddebug(next, 1); loaddebug(next, 2); loaddebug(next, 3); /* no 4 and 5 */ loaddebug(next, 6); loaddebug(next, 7); } if (unlikely(prev->io_bitmap_ptr || next->io_bitmap_ptr)) { if (next->io_bitmap_ptr) { memcpy(tss->io_bitmap, next->io_bitmap_ptr, IO_BITMAP_BYTES); tss->io_bitmap_base = IO_BITMAP_OFFSET; } else tss->io_bitmap_base = INVALID_IO_BITMAP_OFFSET; } return prev_p; } 

कुछ दिलचस्प बदलाव: फ़ंक्शन द्वारा लौटाए गए मूल्य और मैक्रो की उपस्थिति unlikely()। मैं [un] में लिपटे मौजूदा कोड में परिवर्तन पर विचार नहीं करूँगा, ताकि इसे फिर से समझा न जाए। मैक्रो कोड जनरेटर को केवल यह बताता है कि पाइप लाइनिंग में मदद करने के लिए कौन सी आधार इकाई पहले दिखाई देनी चाहिए।

 struct task_struct *__switch_to(...) 

__switch_to अब एक पुराने कार्य के लिए एक पॉइंटर लौटाता है। यह कहीं भी संसाधित नहीं है, इसलिए या तो परिवर्तन हटा दिया गया था या वे सम्मेलन का पालन करना चाहते थे। उदाहरण के लिए, क्लासिक सम्मेलन जब कोई फ़ंक्शन राज्य बदलता है, तो हम बाद में सहेजने और पुनर्स्थापित करने के लिए पिछली स्थिति को लौटाते हैं। जबकि यह काम नहीं करता है।

 load_TLS(next, cpu); 

नए कार्य के लिए GDT में स्थानीय थ्रेड स्टोर डिस्क्रिप्टर को अपडेट करता है। लिनक्स 2.6 विशिष्ट धारा खंडों के लिए जीडीटी में तीन टीएलएस प्रविष्टियों को प्रस्तुत करता है। तो, ग्लिबक पहले खंड का उपयोग करता है, शराब - दूसरा। अब हम क्रमिक रूप से आवश्यकतानुसार स्थानीय थ्रेड स्टोर को संदर्भित करने के लिए FS खंड रजिस्टर का उपयोग करते हैं।

 if (unlikely(prev->fs | prev->gs | next->fs | next->gs)) { 

अब हम केवल FS और GS को पुनर्स्थापित करते हैं यदि वे पिछले या अगले कार्य द्वारा उपयोग किए गए थे।

लिनक्स 2.6.0: x86_64 संस्करण

X86_64 संदर्भ स्विच 32-बिट एक से काफी अलग है। इस बार हम सावधानीपूर्वक कोड का अध्ययन करेंगे, क्योंकि भविष्य में हम केवल 64-बिट संस्करण पर ध्यान केंद्रित करेंगे।



लिनक्स 2.6.0 (अंतर्निहित कोड x86_64)

 /** include/asm-x86_64/system.h */ #define SAVE_CONTEXT "pushfq ; pushq %%rbp ; movq %%rsi,%%rbp\n\t" #define RESTORE_CONTEXT "movq %%rbp,%%rsi ; popq %%rbp ; popfq\n\t" #define __EXTRA_CLOBBER ,"rcx","rbx","rdx","r8","r9","r10","r11","r12","r13","r14","r15" #define switch_to(prev,next,last) asm volatile(SAVE_CONTEXT "movq %%rsp,%P[threadrsp](%[prev])\n\t" /* save RSP */ "movq %P[threadrsp](%[next]),%%rsp\n\t" /* restore RSP */ "call __switch_to\n\t" ".globl thread_return\n" "thread_return:\n\t" "movq %%gs:%P[pda_pcurrent],%%rsi\n\t" "movq %P[thread_info](%%rsi),%%r8\n\t" "btr %[tif_fork],%P[ti_flags](%%r8)\n\t" "movq %%rax,%%rdi\n\t" "jc ret_from_fork\n\t" RESTORE_CONTEXT : "=a" (last) : [next] "S" (next), [prev] "D" (prev), [threadrsp] "i" (offsetof(struct task_struct, thread.rsp)), [ti_flags] "i" (offsetof(struct thread_info, flags)), [tif_fork] "i" (TIF_FORK), [thread_info] "i" (offsetof(struct task_struct, thread_info)), [pda_pcurrent] "i" (offsetof(struct x8664_pda, pcurrent)) : "memory", "cc" __EXTRA_CLOBBER) 

मैक्रो को x86_64 में अपडेट किया गया है _switch_to(), इसलिए आपको फिर से इसकी लाइनों से गुजरना होगा। कई बदलाव बस नाम रजिस्टर ( r..बदले e..) हैं। कुछ अन्य सहायक हैं जिन्हें मैंने ऊपर संकेत दिया है।

 asm volatile(SAVE_CONTEXT 

ऊपर दिखाए गए सहायक मैक्रो के माध्यम से स्टैक पर कर्नेल संदर्भ बचाता है। 32-बिट संस्करण के समान, नए रजिस्टर नामों के अपवाद के साथ। मैक्रो को RESTORE_CONTEXT के साथ बिल्ट-इन असेंबलर ब्लॉक के अंत में रखा गया है।

 "movq %%rsp,%P[threadrsp](%[prev])\n\t" /* save RSP */ 

पुराने स्टैक पॉइंटर को पुराने कार्य के TSS में सहेजता है। इनपुट ऑपरेंड सेक्शन में परिभाषित नई नोटेशन पर ध्यान दें: यह [threadrsp]task_struct के अंदर thread.rsp की डायरेक्ट ऑफसेट है। %Pdereferences प्रबल: थ्रेडपॉइंट पॉइंटर यह सुनिश्चित करने के लिए कि अद्यतन SP ठीक से संग्रहीत है।

 "movq %P[threadrsp](%[next]),%%rsp\n\t" /* restore RSP */ 

नए कार्य के स्टैक पॉइंटर को पुनर्स्थापित करता है।

 "call __switch_to\n\t" 

संदर्भ स्विच के भाग C को आमंत्रित करता है। इसका वर्णन अगले भाग में किया गया है।

 ".globl thread_return\n" 

एक वैश्विक लेबल को परिभाषित करता है thread_return।

 "thread_return:\n\t" 

के लिए संक्रमण बिंदु thread_return। विशुद्ध रूप से यांत्रिक रूप से, निर्देश सूचक को अगले निर्देश का पालन करना चाहिए। वास्तव में या तो कर्नेल में या लाइब्रेरी में उपयोग नहीं किया जाता है (जैसे glibc)। मेरा अनुमान है कि pthreads इसका उपयोग कर सकते हैं ... लेकिन यह ऐसा नहीं लगता है।

 "movq %%gs:%P[pda_pcurrent],%%rsi\n\t" 

प्रति-कार्य डेटा क्षेत्र (पीडीए) को संदर्भित करके वर्तमान कार्य के लिए सूचकांक निर्धारित करता है। कर्नेल मोड में, जीएस को हमेशा प्रत्येक प्रोसेसर के लिए डेटा को इंगित करना चाहिए।

 "movq %P[thread_info](%%rsi),%%r8\n\t" 

संरचना thread_infoको r8 में ले जाता है। यह लिनक्स 2.6 के लिए नया है, और अनिवार्य रूप से एक हल्का संस्करण है task_structजो आसानी से स्टैक पर फिट बैठता है।

 "btr %[tif_fork],%P[ti_flags](%%r8)\n\t" 

CF में TIF_FORK बिट मान सहेजता है thread_info->flagsऔर संरचना में बिट को रीसेट करता है। कुछ पंक्तियों के बाद, यह बिट कांटा / क्लोनिंग के बाद सेट किया जाएगा और ret_from_fork चलाने के लिए उपयोग किया जाएगा।

 "movq %%rax,%%rdi\n\t" 

task_structRDI को पिछली स्ट्रीम बचाता है । EAX के साथ काम करने वाला अंतिम निर्देश C फ़ंक्शन को कॉल करना है __switch_to, जो prevEAX पर लौटता है।

 "jc ret_from_fork\n\t" 

यदि यह धागा एक ताज़ा कांटा / क्लोन है, तो फिर से शुरू करने के लिए ret_from_fork पर जाएं।

 : "=a" (last) 

पिछली धारा EAX पर वापस आ गई है।

 : [next] "S" (next), [prev] "D" (prev), [threadrsp] "i" (offsetof(struct task_struct, thread.rsp)), [ti_flags] "i" (offsetof(struct thread_info, flags)), [tif_fork] "i" (TIF_FORK), [thread_info] "i" (offsetof(struct task_struct, thread_info)), [pda_pcurrent] "i" (offsetof(struct x8664_pda, pcurrent)) 

इनलाइन असेंबलर के लिए इनपुट लिंक। उनमें से ज्यादातर ऑफसेट के साथ प्रत्यक्ष ऑपरेंड हैं। ऊपर हम पहले ही उनके माध्यम से भाग चुके हैं।

 : "memory", "cc" __EXTRA_CLOBBER) 

लिनक्स 2.6.0 (x86_64 C)

 /** arch/x86_64/kernel/process.c */ struct task_struct *__switch_to(struct task_struct *prev_p, struct task_struct *next_p) { struct thread_struct *prev = &prev_p->thread, *next = &next_p->thread; int cpu = smp_processor_id(); struct tss_struct *tss = init_tss + cpu; unlazy_fpu(prev_p); tss->rsp0 = next->rsp0; asm volatile("movl %%es,%0" : "=m" (prev->es)); if (unlikely(next->es | prev->es)) loadsegment(es, next->es); asm volatile ("movl %%ds,%0" : "=m" (prev->ds)); if (unlikely(next->ds | prev->ds)) loadsegment(ds, next->ds); load_TLS(next, cpu); /* Switch FS and GS. */ { unsigned fsindex; asm volatile("movl %%fs,%0" : "=g" (fsindex)); if (unlikely(fsindex | next->fsindex | prev->fs)) { loadsegment(fs, next->fsindex); if (fsindex) prev->fs = 0; } /* when next process has a 64bit base use it */ if (next->fs) wrmsrl(MSR_FS_BASE, next->fs); prev->fsindex = fsindex; } { unsigned gsindex; asm volatile("movl %%gs,%0" : "=g" (gsindex)); if (unlikely(gsindex | next->gsindex | prev->gs)) { load_gs_index(next->gsindex); if (gsindex) prev->gs = 0; } if (next->gs) wrmsrl(MSR_KERNEL_GS_BASE, next->gs); prev->gsindex = gsindex; } /* Switch the PDA context. */ prev->userrsp = read_pda(oldrsp); write_pda(oldrsp, next->userrsp); write_pda(pcurrent, next_p); write_pda(kernelstack, (unsigned long)next_p->thread_info + THREAD_SIZE - PDA_STACKOFFSET); /* Now maybe reload the debug registers */ if (unlikely(next->debugreg7)) { loaddebug(next, 0); loaddebug(next, 1); loaddebug(next, 2); loaddebug(next, 3); /* no 4 and 5 */ loaddebug(next, 6); loaddebug(next, 7); } /* Handle the IO bitmap */ if (unlikely(prev->io_bitmap_ptr || next->io_bitmap_ptr)) { if (next->io_bitmap_ptr) { memcpy(tss->io_bitmap, next->io_bitmap_ptr, IO_BITMAP_BYTES); tss->io_bitmap_base = IO_BITMAP_OFFSET; } else { tss->io_bitmap_base = INVALID_IO_BITMAP_OFFSET; } } return prev_p; } 

संस्करण x86_64 में, C संदर्भ स्विच कोड में कई बदलाव जोड़े गए हैं। मैं साधारण केस परिवर्तनों को नहीं दोहराऊंगा (उदाहरण के लिए, EAX को RAX का नाम देना)।

 asm volatile("movl %%es,%0" : "=m" (prev->es)); if (unlikely(next->es | prev->es)) loadsegment(es, next->es); 

पुराने कार्य के लिए ES सेगमेंट बचाता है, और यदि आवश्यक हो तो नया लोड करता है।

 asm volatile ("movl %%ds,%0" : "=m" (prev->ds)); if (unlikely(next->ds | prev->ds)) loadsegment(ds, next->ds); 

किसी पुराने कार्य के लिए एक डेटा खंड बचाता है, और यदि आवश्यक हो तो एक नया लोड करता है।

 unsigned fsindex; asm volatile("movl %%fs,%0" : "=g" (fsindex)); if (unlikely(fsindex | next->fsindex | prev->fs)) { loadsegment(fs, next->fsindex); if (fsindex) prev->fs = 0; } 

FS खंड को ले जाता है fsindex, और फिर यदि आवश्यक हो तो एक नए कार्य के लिए FS लोड करता है। सिद्धांत रूप में, यदि किसी पुराने या नए कार्य में एफएस के लिए एक वैध मूल्य है, तो उसके स्थान पर कुछ लोड किया जाता है (शायद NULL)। एफएस आमतौर पर स्थानीय स्ट्रीम स्टोरेज के लिए उपयोग किया जाता है, लेकिन संदर्भ स्विचिंग होने पर निर्भर करता है। वास्तव में जीएस के लिए समान कोड का उपयोग किया जाता है, इसलिए दोहराने की आवश्यकता नहीं है। जीएस आमतौर पर एक सेगमेंट है thread_info।

 if (next->fs) wrmsrl(MSR_FS_BASE, next->fs); 

यदि अगले कार्य में एफएस रजिस्टर का उपयोग किया जाता है, तो आपको यह सत्यापित करने की आवश्यकता है कि संपूर्ण 64-बिट मान लिखा गया है। याद रखें कि सेगमेंट रजिस्टर 16/32-बिट युग की एक कलाकृति है, इसलिए एक विशेष फ़ंक्शन यह जांचता है कि ऊपरी 32 बिट्स लिखे गए हैं।

 prev->fsindex = fsindex; 

पुराने कार्य के लिए FS सहेजें।

 prev->userrsp = read_pda(oldrsp); write_pda(oldrsp, next->userrsp); write_pda(pcurrent, next_p); write_pda(kernelstack, (unsigned long)next_p->thread_info + THREAD_SIZE - PDA_STACKOFFSET); 

आगामी कार्य के लिए पीडीए को अपडेट करना, पुराने कार्य के पुराने आरएसपी (सिस्कॉल) को संग्रहीत करना शामिल है। पीडीए को स्ट्रीम और स्टैक जानकारी के साथ अपडेट किया जाता है।

लिनक्स 3.0: आधुनिक ओएस (2011)

नंबर को धोखा न दें। वास्तव में, संस्करण 3.0 2.6.0 के लगभग 8 साल बाद जारी किया गया था । भारी संख्या में परिवर्तन एक पूरी पुस्तक के योग्य हैं, और मैं आपको सब कुछ नहीं बता सकता। संदर्भ स्विचिंग के लिए, i386 और x86_64 अलग-अलग प्रक्रिया फ़ाइलों (process_32.c और process_64.s।) के साथ x86 में संयुक्त हैं। यह लेख पहले से ही बहुत बड़ा है, इसलिए हम केवल बाद में x86_64 संस्करण का विश्लेषण करेंगे । हम केवल कुछ विवरणों को रेखांकित करेंगे और नवीनतम एलटीएस पर करीब से नज़र डालेंगे।



लिनक्स 3.0.1 (अंतर्निहित कोड x86_64)

 /** arch/x86/include/asm/system.h */ #define SAVE_CONTEXT "pushf ; pushq %%rbp ; movq %%rsi,%%rbp\n\t" #define RESTORE_CONTEXT "movq %%rbp,%%rsi ; popq %%rbp ; popf\t" #define __EXTRA_CLOBBER \ ,"rcx","rbx","rdx","r8","r9","r10","r11","r12","r13","r14","r15" #define switch_to(prev, next, last) asm volatile(SAVE_CONTEXT "movq %%rsp,%P[threadrsp](%[prev])\n\t" /* save RSP */ "movq %P[threadrsp](%[next]),%%rsp\n\t" /* restore RSP */ "call __switch_to\n\t" "movq "__percpu_arg([current_task])",%%rsi\n\t" __switch_canary "movq %P[thread_info](%%rsi),%%r8\n\t" "movq %%rax,%%rdi\n\t" "testl %[_tif_fork],%P[ti_flags](%%r8)\n\t" "jnz ret_from_fork\n\t" RESTORE_CONTEXT : "=a" (last) __switch_canary_oparam : [next] "S" (next), [prev] "D" (prev), [threadrsp] "i" (offsetof(struct task_struct, thread.sp)), [ti_flags] "i" (offsetof(struct thread_info, flags)), [_tif_fork] "i" (_TIF_FORK), [thread_info] "i" (offsetof(struct task_struct, stack)), [current_task] "m" (current_task) __switch_canary_iparam : "memory", "cc" __EXTRA_CLOBBER) 

आठ साल - और मैक्रो में switch_to()केवल चार परिवर्तन। उनमें से दो एक दूसरे के साथ जुड़े हुए हैं, और कुछ भी नया नहीं है।

 movq "__percpu_arg([current_task])",%%rsi\n\t 

task_structआरएसआई के लिए नए टांके चलता है । यह कार्य जानकारी तक पहुंचने का "नया" तरीका है: प्रत्येक सीपीयू में एक स्थिर प्रतीक होता है। पहले, जानकारी GS: [पीडीए ऑफसेट] के माध्यम से उपलब्ध थी। इसके बाद के RSI ऑपरेशन संस्करण 2.6 में ही हैं।

 __switch_canary 

यह मैक्रो आपको अतिरिक्त रूप से जाँचने की अनुमति देता है कि क्या CONFIG_CC_STACKPROTECTOR मैक्रो कर्नेल असेंबली के दौरान सक्षम है या नहीं। मैं इस विषय को बहुत गहराई से खोदने वाला नहीं हूं, सिवाय इसके कि यह तंत्र ढेर के हैकर विनाश से बचाता है । वास्तव में, हम एक यादृच्छिक मूल्य को बचाते हैं, और बाद में हम इसे जांचते हैं। यदि अर्थ बदल गया है, तो इसका अर्थ है परेशानी।

 testl %[_tif_fork],%P[ti_flags](%%r8)\n\t jnz ret_from_fork\n\t 

जाँचता है कि क्या क्लोनिंग / कांटा का उपयोग करके एक नया कार्य बनाया गया था, और फिर आगे बढ़ता है ret_from_fork()। यह एक निर्देश हुआ करता था btr, लेकिन अब हम कॉल समाप्त होने तक बिट के रीसेट को स्थगित कर देते हैं। परीक्षण परिवर्तन के कारण नाम बदलकर जेएनजेड कर दिया गया है: यदि बिट सेट है, तो टेस्ट (और) सकारात्मक होगा।

 __switch_canary_oparam 

के लिए स्टैक कैनरी का आउटपुट CONFIG_CC_STACKPROTECTOR।

 __switch_canary_iparam 

लिनक्स 3.0.1 के लिए इनपुट स्टैक कैनरी CONFIG_CC_STACKPROTECTOR

(x86_64 C)

 /** arch/x86/kernel/process_64.c */ __notrace_funcgraph struct task_struct * __switch_to(struct task_struct *prev_p, struct task_struct *next_p) { struct thread_struct *prev = &prev_p->thread; struct thread_struct *next = &next_p->thread; int cpu = smp_processor_id(); struct tss_struct *tss = &per_cpu(init_tss, cpu); unsigned fsindex, gsindex; bool preload_fpu; preload_fpu = tsk_used_math(next_p) && next_p->fpu_counter > 5; /* we're going to use this soon, after a few expensive things */ if (preload_fpu) prefetch(next->fpu.state); /* Reload esp0, LDT and the page table pointer: */ load_sp0(tss, next); savesegment(es, prev->es); if (unlikely(next->es | prev->es)) loadsegment(es, next->es); savesegment(ds, prev->ds); if (unlikely(next->ds | prev->ds)) loadsegment(ds, next->ds); savesegment(fs, fsindex); savesegment(gs, gsindex); load_TLS(next, cpu); __unlazy_fpu(prev_p); /* Make sure cpu is ready for new context */ if (preload_fpu) clts(); arch_end_context_switch(next_p); /* Switch FS and GS. */ if (unlikely(fsindex | next->fsindex | prev->fs)) { loadsegment(fs, next->fsindex); if (fsindex) prev->fs = 0; } /* when next process has a 64bit base use it */ if (next->fs) wrmsrl(MSR_FS_BASE, next->fs); prev->fsindex = fsindex; if (unlikely(gsindex | next->gsindex | prev->gs)) { load_gs_index(next->gsindex); if (gsindex) prev->gs = 0; } if (next->gs) wrmsrl(MSR_KERNEL_GS_BASE, next->gs); prev->gsindex = gsindex; /* Switch the PDA and FPU contexts. */ prev->usersp = percpu_read(old_rsp); percpu_write(old_rsp, next->usersp); percpu_write(current_task, next_p); percpu_write(kernel_stack, (unsigned long)task_stack_page(next_p) + THREAD_SIZE - KERNEL_STACK_OFFSET); /* Now maybe reload the debug registers and handle I/O bitmaps */ if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT || task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV)) __switch_to_xtra(prev_p, next_p, tss); /* Preload the FPU context - task is likely to be using it. */ if (preload_fpu) __math_state_restore(); return prev_p; } 

सी कोड में कुछ बदलाव हैं, लेकिन वे अपेक्षाकृत कम हैं, रिलीज के बीच आठ साल दिए गए हैं। उनमें से कुछ कॉस्मेटिक हैं, उदाहरण के लिए, सभी घोषणाओं के शीर्ष पर जाना। यहाँ क्या बदल गया है:

 __notrace_funcgraph struct task_struct * __switch_to(...) 

एक नया हस्ताक्षर __notrace_funcgraphट्रैकिंग से सक्रिय फुट को प्रतिबंधित करता है switch_to।

 preload_fpu = tsk_used_math(next_p) && next_p->fpu_counter > 5; if (preload_fpu) prefetch(next->fpu.state); 

यह जांचता है कि क्या एफपीयू अंतिम कार्य में पिछले 5 बार स्लाइस के लिए उपयोग किया गया था, और फिर बाद में उपयोग के लिए डेटा को कैश करने की कोशिश करता है।

 load_sp0(tss, next); 

कर्नेल स्पेस स्टैक पॉइंटर को लोड करता है, पेज टेबल को अपडेट करता है, और हाइपरविजर (यदि लागू हो) को सूचित करता है।

 savesegment(es, prev->es); 

ES खंड बचाता है। यह पूरी तरह से एक नवीनता नहीं है, सिर्फ 2.6 से इनलाइन कोडांतरक के लिए एक प्रतिस्थापन है:asm volatile("movl %%es,%0" : "=m" (prev->es)); ।

 if (preload_fpu) clts(); 

अगर इसका उपयोग किए जाने की संभावना है तो तुरंत FPU को रिबूट करता है। आवेदन clts()- एक ही विचार है कि हम लिनक्स के पहले संस्करण के साथ देखा था: "cmpl %%ecx,%2\n\t jne 1f\n\t clts\n"।

 jne 1f\n\t clts\n" arch_end_context_switch(next_p); 

वर्चुअलाइजेशन के लिए केवल प्रासंगिक है । सामान्य परिस्थितियों में, एक फ़ंक्शन कुछ भी नहीं करता है । अधिक जानकारी के लिए अंतिम कर्नेल संस्करण देखें।

 if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT || task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV)) __switch_to_xtra(prev_p, next_p, tss); 

प्रशासनिक कार्यों में लगे हुए हैं, जिसे पहले switch_toडिबग रजिस्टरों और I / O बिटमैप मापदंडों सहित अंत में वर्णित किया गया था । हम आपको इसके बारे में कोड समीक्षा 4.14.67 में बताएंगे।

 if (preload_fpu) __math_state_restore(); 

इसके उपयोग की जाँच करने के बाद FPU को पुनर्प्राप्त करता है। परिस्थितियों के सफल संयोजन के साथ, डेटा पहले से किए गए प्रारंभिक चयन के लिए पहले से ही कैश में होना चाहिए।

लिनक्स 4.14.67: नवीनतम LTS (2018)

संदर्भ स्विच के आंतरिक कामकाज में यह हमारी सबसे गहरी विसर्जन है। 3.0 की रिहाई के बाद से प्रक्रिया को काफी संशोधित किया गया है और कोड का आयोजन किया। कुल मिलाकर, यह अब साफ दिखता है और पहले से कहीं ज्यादा व्यवस्थित है। X86_64 के लिए:

• 3.4 switch_to() arch/x86/include/asm/switch_to.h . , context_switch() kernel/sched/core. .
  
• 4.9 switch_to() : prepare_switch_to() ( arch/x86/entry/entry_64.S ).
  
• C . 2.6.24 arch/x86/kernel/process_64.c .

Linux 4.14.67

 /** arch/x86/include/asm/switch_to.h */ #define switch_to(prev, next, last) do { prepare_switch_to(prev, next); ((last) = __switch_to_asm((prev), (next))); } while (0) 

यह पुरानी गुठली की तुलना में सरल दिखता है। यह पुनर्गठन समस्या के समाधान का परिणाम था जब एंडी लुतोमिरस्की ने लगभग मिलान कर्नेल स्टैक पेश किया ।

 prepare_switch_to(prev, next); 

यह सुनिश्चित करता है कि संदर्भों को स्विच करने से पहले कर्नेल स्टैक उपलब्ध हैं। वस्तुतः मैप किए गए कर्नेल स्टैक का उपयोग करते समय संदर्भ को बदलने के प्रयास के दौरान यह संभव दोहरी त्रुटि या कर्नेल आतंक से बचा जाता है।

 ((last) = __switch_to_asm((prev), (next))); 

वास्तविक संदर्भ स्विच शुरू करता है।

एक prepare_switch_toही स्रोत फ़ाइल में परिभाषित पर एक नज़र डालें ।

लिनक्स 4.14.67

 /** arch/x86/include/asm/switch_to.h */ static inline void prepare_switch_to(struct task_struct *prev, struct task_struct *next) { #ifdef CONFIG_VMAP_STACK READ_ONCE(*(unsigned char *)next->thread.sp); #endif } 

 #ifdef CONFIG_VMAP_STACK 

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

 READ_ONCE(*(unsigned char *)next->thread.sp); 

पृष्ठ तालिकाओं (pgd) को ठीक करने के लिए अगले स्टैक का उल्लेख। मुख्य समस्या यह है कि हम एक ऐसे पॉइंटर का उपयोग करने की कोशिश कर रहे हैं जो न केवल पृष्ठों के बाहर (पृष्ठ-बाहर) है, बल्कि vmalloc क्षेत्र के विलंबित लोडिंग के कारण इस कार्य की स्मृति के संदर्भ में भी नहीं है। यदि आप समस्या को पहले से हल नहीं करते हैं, तो पॉइंटर की अनुपस्थिति और अप्राप्यता का मतलब कर्नेल पैनिक है ।

लिनक्स 4.16.67

 /** arch/x86/entry/entry_64.S */ ENTRY(__switch_to_asm) UNWIND_HINT_FUNC /* Save callee-saved registers */ pushq %rbp pushq %rbx pushq %r12 pushq %r13 pushq %r14 pushq %r15 /* switch stack */ movq %rsp, TASK_threadsp(%rdi) movq TASK_threadsp(%rsi), %rsp #ifdef CONFIG_CC_STACKPROTECTOR movq TASK_stack_canary(%rsi), %rbx movq %rbx, PER_CPU_VAR(irq_stack_union)+stack_canary_offset #endif #ifdef CONFIG_RETPOLINE FILL_RETURN_BUFFER %r12, RSB_CLEAR_LOOPS, X86_FEATURE_RSB_CTXSW #endif /* restore callee-saved registers */ popq %r15 popq %r14 popq %r13 popq %r12 popq %rbx popq %rbp jmp __switch_to END(__switch_to_asm) 

में entry_64.S काम है कि लिनक्स में पिछले 25 वर्षों के इनलाइन कोडांतरक प्रदर्शन में शामिल है।

 UNWIND_HINT_FUNC 

ओब्जेक्टूल स्टैक ट्रेस टूल द्वारा उपयोग किए जाने वाले टूलटिप्स बनाता है जो बस बाहर निकलता है। यह विशेष बिल्ड प्रक्रियाओं के लिए आवश्यक है जो सामान्य सी भाषा कॉलिंग सम्मेलनों का पालन नहीं करते हैं। ऐसे संकेत संस्करण 4.6 में ओआरसी "कोड अनइन्डर" के सफल कार्यान्वयन का कारण हैं ।

 pushq %rbp, %rbx, %r12, %r13, %r14, %r15 

हम रजिस्टरों को पुराने स्टैक में सहेजते हैं , जिससे हम स्विच करते हैं।

 movq %rsp, TASK_threadsp(%rdi) movq TASK_threadsp(%rsi), %rsp 

मैं पुराने और नए कार्य के बीच स्टैक पॉइंटर्स स्वैप करता हूं। सीधे परिवेश विधानसभा से स्पष्ट नहीं है, लेकिन RDI और RSI इनपुट तर्क होते हैं task_struct *, पिछला और अगले सम्मेलनों सिस्टम वी ABI के अनुसार। यहाँ उनके उपयोग के साथ रजिस्टरों का एक सबसेट है:

 #ifdef CONFIG_CC_STACKPROTECTOR movq TASK_stack_canary(%rsi), %rbx movq %rbx, PER_CPU_VAR(irq_stack_union)+stack_canary_offset 

यदि स्टैक सुरक्षा सक्षम है, तो इस कार्य का कैनरी मान वर्तमान CPU के इंटरप्ट स्टैक में उपयुक्त स्थान पर ले जाया जाता है। स्टैक सुरक्षा आमतौर पर डिफ़ॉल्ट रूप से सक्षम होती है, इसलिए यह आमतौर पर होता है।

 #ifdef CONFIG_RETPOLINE FILL_RETURN_BUFFER %r12, RSB_CLEAR_LOOPS, X86_FEATURE_RSB_CTXSW 

यह शाखा भविष्यवाणी (स्पेक्टर भेद्यता) के संभावित शोषण से सुरक्षा है । शुद्ध स्वर !

 popq %r15, %r14, %r13, %r12, %rbx, %rbp 

रिवर्स क्रम में नए स्टैक से सभी रजिस्टरों को पुनर्स्थापित करता है : (r15, r14, r13, r12, rbx, rbp)

लिनक्स 4.16.67 ( टिप्पणियों के साथ स्रोत )

 /** arch/x86/kernel/process_64.c */ __visible __notrace_funcgraph struct task_struct * __switch_to(struct task_struct *prev_p, struct task_struct *next_p) { struct thread_struct *prev = &prev_p->thread; struct thread_struct *next = &next_p->thread; struct fpu *prev_fpu = &prev->fpu; struct fpu *next_fpu = &next->fpu; int cpu = smp_processor_id(); struct tss_struct *tss = &per_cpu(cpu_tss_rw, cpu); WARN_ON_ONCE(IS_ENABLED(CONFIG_DEBUG_ENTRY) && this_cpu_read(irq_count) != -1); switch_fpu_prepare(prev_fpu, cpu); save_fsgs(prev_p); load_TLS(next, cpu); arch_end_context_switch(next_p); savesegment(es, prev->es); if (unlikely(next->es | prev->es)) loadsegment(es, next->es); savesegment(ds, prev->ds); if (unlikely(next->ds | prev->ds)) loadsegment(ds, next->ds); load_seg_legacy(prev->fsindex, prev->fsbase, next->fsindex, next->fsbase, FS); load_seg_legacy(prev->gsindex, prev->gsbase, next->gsindex, next->gsbase, GS); switch_fpu_finish(next_fpu, cpu); /* Switch the PDA and FPU contexts. */ this_cpu_write(current_task, next_p); this_cpu_write(cpu_current_top_of_stack, task_top_of_stack(next_p)); /* Reload sp0. */ update_sp0(next_p); /* Now maybe reload the debug registers and handle I/O bitmaps */ if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT || task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV)) __switch_to_xtra(prev_p, next_p, tss); #ifdef CONFIG_XEN_PV if (unlikely(static_cpu_has(X86_FEATURE_XENPV) && prev->iopl != next->iopl)) xen_set_iopl_mask(next->iopl); #endif if (static_cpu_has_bug(X86_BUG_SYSRET_SS_ATTRS)) { unsigned short ss_sel; savesegment(ss, ss_sel); if (ss_sel != __KERNEL_DS) loadsegment(ss, __KERNEL_DS); } /* Load the Intel cache allocation PQR MSR. */ intel_rdt_sched_in(); return prev_p; } 

कोड का यह आखिरी ब्लॉक आपको संदर्भ स्विच में नवीनतम परिवर्तनों से परिचित होने की अनुमति देता है! यदि आपने तुरंत इस स्थान पर लेख को स्क्रॉल किया है, तो चिंता न करें - मैं यहां (और) अधिक से अधिक बिंदुओं पर और अधिक विस्तार से विचार करूंगा। कुछ अपवादों पर ध्यान दें जो संदर्भ स्विच में आते हैं।

 __visible __notrace_funcgraph struct task_struct * __switch_to(struct task_struct *prev_p, struct task_struct *next_p) 

C पर संदर्भ स्विच के लिए हस्ताक्षर कई भागों में हैं:

• अदृश्य - यह विशेषता यह सुनिश्चित करती है कि लेआउट प्रक्रिया के दौरान अनुकूलन चरित्र को नहीं हटाता है __switch_to()।
• __notrace_funcgraph - फुट्रेस__switch_to() ट्रेसर से बचाता है। फ़ंक्शन को संस्करण 2.6.29 में लगभग जोड़ा गया था, और जल्द ही इसे चालू कर दिया गया था।
• इनपुट तर्क पुराने और नए कार्यों के संकेत हैं जो RDI और RSI को दिए गए हैं।

 struct thread_struct *prev = &prev_p->thread; struct thread_struct *next = &next_p->thread; struct fpu *prev_fpu = &prev->fpu; struct fpu *next_fpu = &next->fpu; 

इनपुट डेटा से कुछ जानकारी एकत्र करता है task_struct *। थ्रेड_स्ट्रैक में कार्य के लिए TSS डेटा (रजिस्टर आदि) fpu>शामिल हैं । संरचना में FPU डेटा शामिल है, जैसे कि अंतिम सीपीयू का उपयोग किया जाता है, आरंभीकरण और रजिस्टर मूल्य।

 int cpu = smp_processor_id(); 

प्रोसेसर नंबर देता है जिसे हमें TSS डेटा, स्थानीय थ्रेड स्टोरेज और गैस जनरेटर की स्थिति की तुलना करने के लिए GDT को नियंत्रित करना होगा।

 struct tss_struct *tss = &per_cpu(cpu_tss_rw, cpu); 

वर्तमान TSS CPU को इंगित करता है ।

 WARN_ON_ONCE(IS_ENABLED(CONFIG_DEBUG_ENTRY) && this_cpu_read(irq_count) != -1); 

यह निर्धारित करता है कि संदर्भ स्विचिंग के दौरान IRQ स्टैक का उपयोग किया गया है या नहीं और प्रति लोड एक बार इसकी रिपोर्ट करता है। यह विकास 4.14 की शुरुआत में जोड़ा गया था, और वास्तव में यह कोड संदर्भ स्विचिंग को प्रभावित नहीं करता है।

 switch_fpu_prepare(prev_fpu, cpu); 

एफपीयू की वर्तमान स्थिति को बचाता है जबकि हम पुराने कार्य में हैं।

 save_fsgs(prev_p); 

एफएस और जीएस स्टोर करने से पहले हम स्थानीय स्ट्रीम स्टोरेज को बदलते हैं।

 load_TLS(next, cpu); 

नए कार्यों के स्थानीय थ्रेड भंडारण के लिए जीडीटी को पुनः लोड करें। यांत्रिक रूप से tls_array को एक नई स्ट्रीम से GDT रिकॉर्ड 6, 7, और 8 में कॉपी करता है।

 arch_end_context_switch(next_p); 

यह फ़ंक्शन केवल paravirtualization के साथ परिभाषित किया गया है। Paravirt मोड को बदलता है और शेष सभी बैच कार्य को साफ़ करता है। हाल के संस्करणों में प्रस्तुत 2.6.x. मैं इस कार्यक्षमता में बहुत मजबूत नहीं हूं, इसलिए मैं इसे अनुसंधान के लिए पाठकों पर छोड़ दूंगा ।

 savesegment(es, prev->es); if (unlikely(next->es | prev->es)) loadsegment(es, next->es); 

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

 load_seg_legacy(prev->fsindex, prev->fsbase, next->fsindex, next->fsbase, FS); 

नए FS सेगमेंट्स (GS छोड़ा गया)। यह 32-बिट और 64-बिट रजिस्टर प्रकारों के लिए रजिस्टर का पता लगाएगा और लोड करेगा। नया कार्य अब टीएलएस के लिए तैयार है।

 switch_fpu_finish(next_fpu, cpu); 

आने वाले कार्य के लिए FPU की स्थिति को आरम्भ करता है।

 this_cpu_write(current_task, next_p); 

वर्तमान सीपीयू ( task_struct *) कार्य को अद्यतन करता है । एफपीयू और पीडीए (प्रत्येक प्रोसेसर के लिए डेटा क्षेत्र) की स्थिति को प्रभावी रूप से अपडेट करता है।

 this_cpu_write(cpu_current_top_of_stack, task_top_of_stack(next_p)); 

सीपीयू ढेर सूचक है कि वास्तव में के रूप में SP1 ओवरलोड हो गया है अद्यतन करता है उत्पन्न कोड की सुरक्षा के लिए (प्रवेश ट्रैम्पोलिन)।

 update_sp0(next_p); 

इसे जांचने के लिए एक नए स्टैक का सत्यापन। ऐसा लगता है कि sp0 यहाँ निर्दिष्ट किया जाना चाहिए, sp1 नहीं? शायद नाम बदला जाना चाहिए।

 if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT || task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV)) __switch_to_xtra(prev_p, next_p, tss); 

अपडेट डिबग रजिस्टर और I / O बिटमैप्स। इन दोनों कार्यों को पहले संदर्भ स्विच में सीधे हैंडल किया गया था, लेकिन अब इसे स्थानांतरित कर दिया गया है __switch_to_xtra()।

 #ifdef CONFIG_XEN_PV if (unlikely(static_cpu_has(X86_FEATURE_XENPV) && prev->iopl != next->iopl)) xen_set_iopl_mask(next->iopl); 

Xen paravirtualization के लिए I / O विशेषाधिकार बिट्स को मैन्युअल रूप से स्वैप करता है। जाहिरा तौर पर, नियमित ध्वज स्विच ठीक से काम नहीं करता है , और इसलिए आपको सीधे वर्तमान बिट्स को मुखौटा करना होगा।

 if (static_cpu_has_bug(X86_BUG_SYSRET_SS_ATTRS)) { unsigned short ss_sel; savesegment(ss, ss_sel); if (ss_sel != __KERNEL_DS) loadsegment(ss, __KERNEL_DS); 

एएमडी प्रोसेसर में अप्रत्याशित SYSRET व्यवहार को छुपाता है जो गलत तरीके से सेगमेंट डिस्क्रिप्टर को अपडेट करता है।

 intel_rdt_sched_in(); 

कुछ इंटेल सफाई कार्य। अपडेट आरएमआईडी और क्लोसिड ।

 return prev_p; 

हो गया!

पूछे जाने वाले प्रश्न

आपने इन कर्नेल संस्करणों को क्यों चुना?
पहले और अंतिम संस्करण स्पष्ट उम्मीदवार थे। प्रारंभ में, मैंने चार और मध्यवर्ती संस्करणों (2.1, 2.3, 2.5 और 2.6.26) पर विचार करने की योजना बनाई, लेकिन लेख को ओवर-इनफ़्लो करने के लिए परिवर्तन पर्याप्त नहीं थे। वह पहले से ही बहुत बड़ी है।

इस अध्ययन में कितना समय लगा?
दो सप्ताह। कोड विश्लेषण, नोट्स और तकनीकी ट्यूटोरियल के लिए एक सप्ताह। फिर नोट्स को फिर से लिखने, चित्र बनाने और लेख को प्रारूपित करने के लिए एक सप्ताह।

4.14.67 - नवीनतम एलटीएस रिलीज नहीं?
मैंने 1 सितंबर को कोड का अध्ययन करना शुरू किया और स्रोत कोड 4.14.67 लिया। संस्करण 4.14.68 को चार दिन बाद पूरा किया गया था।

जैसे ही वे उपलब्ध होंगे मैं अन्य प्रश्न जोड़ दूंगा।