एक मल्टीटास्किंग बातचीत शुरू करना

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

शुरू करने के लिए, हम एक महत्वपूर्ण प्रश्न को हल करेंगे: हम किस मल्टीटास्किंग को लागू करेंगे? हार्डवेयर है, मल्टीटास्किंग सॉफ्टवेयर है ...
पहले ऐसा लगता है कि हार्डवेयर बेहतर है, आखिरकार, इंटेल ने स्पष्ट रूप से इस तंत्र को "मक्खी" बनाने की कोशिश की, लेकिन यहां नुकसान हैं। सबसे पहले, यह धीमी है। कैसे? इंटेल इंजीनियरों से पूछें। दूसरे, सभी ने पहले ही पढ़ा है कि हार्डवेयर मल्टीटास्किंग के साथ हमें TSS (टास्क-स्टेट सेगमेंट) का उपयोग करना चाहिए, जिसके डिस्क्रिप्टर GDT में स्टोर किए गए हैं, जो समायोजित कर सकते हैं ... (ड्रम रोल) ... 8192 डिस्क्रिप्टर। ऐसा लग सकता है कि यह पर्याप्त है, लेकिन सर्वर पर (हां, हां, हम सपना देखेंगे) यह पर्याप्त नहीं हो सकता है। हमारे लिए, सिद्धांत रूप में, यह महत्वपूर्ण नहीं है, लेकिन हम इसे ईमानदारी से करेंगे - सॉफ्टवेयर मल्टीटास्किंग।
इस समस्या में, मैं केवल स्विचिंग कार्यों के लिए तंत्र पर विचार करने का प्रस्ताव करता हूं।
अब बात करते हैं कि हमें क्या करना है।
1) TSS के लिए किसी प्रकार के प्रतिस्थापन के साथ आते हैं।
2) तय करें कि प्रक्रियाओं के लिए पता स्थान कैसे लागू किया जाए।
3) कार्य स्विचन पर विचार करें।
चलो प्रीमेप्टिव मल्टीटास्किंग को लागू करते हैं, अर्थात्, हम यह करेंगे: टाइमर टिक के अनुसार (जो प्रति सेकंड 18.2 बार चूक करता है), हम कार्यों को स्विच करेंगे। टीएसएस के बजाय, आप एक संरचना दर्ज कर सकते हैं जिसमें प्रक्रिया की स्थिति बच जाएगी। प्रत्येक प्रक्रिया के लिए पता स्थान स्थिर है (आपको कहीं शुरू करना है, ठीक है?)। यही है, मोटे तौर पर, हम राम का एक टुकड़ा लेते हैं और इसे एन बराबर भागों में विभाजित करते हैं।
अब आप कार्यान्वयन शुरू कर सकते हैं।

सबसे पहले, आइए एक प्रतिस्थापन TSS शुरू करें; इसे गर्व से TSS_struct कहा जाता है और इस तरह देखें:

TSS_struct:
0: privilage level (0|3)
1: ESP (Ring0)
5: CR3
9: EIP
13: EFLAGS
17: EAX
21: ECX
25: EDX
29: EBX
33: ESP (Ring3)
37: EBP
41: ESI
45: EDI
49: ES
51: CS
53: SS
55: DS
57: FS
59: GS
61: LDT_selector
63-256 - free


अब हम उस फ़ंक्शन को लागू करते हैं जिसे हम टाइमर के प्रत्येक टिक पर कॉल करेंगे।
हमें पुराने कार्य की स्थिति को बनाए रखने की आवश्यकता है, एक और कार्य ढूंढना है, एक नया लोड करना है। TSS_structs को चिह्नित करने के लिए हम 10 बाइट्स का उपयोग करेंगे, जहां प्रत्येक बिट 1 कार्य को दर्शाएगा। यह 2 स्थितियों पर विचार करने के लायक है जो स्टैक को प्रभावित करेगा:
1) विशेषाधिकार स्तर नहीं बदलता है;
2) बदल रहा है;
पहले संस्करण में, स्टैक इस तरह दिखेगा:

;|EFLAGS
;|CS
;|EIP <---- ESP
;V


दूसरे में, इस तरह:
;|SS
;|ESP
;|EFLAGS
;|CS
;|EIP <---- ESP
;V


ध्यान दें कि केवल उन रजिस्टरों को जो बाधा हैंडलर परिवर्तन मूल्यों को निष्पादित करने के लिए आवश्यक हैं।
इस मुद्दे में, मैं केवल Ring0 पर विचार करने का प्रस्ताव करता हूं। रिंग (1 | 2 | 3) हमने अभी तक विचार नहीं किया है, और वहां का व्यवहार अलग होगा, इसलिए हम खुद को सीमित कर लेंगे।
इससे पहले कि हम कोड लिखना शुरू करें, मैं आपको बता दूं कि जहां मैं व्यक्तिगत रूप से रुका हूं, वहां फिसलन वाले स्थान हैं, और अक्सर लंबे समय तक।
1) सबसे प्राथमिक: हम गलत तरीके से वापसी पते को निर्दिष्ट करते हैं जिसे हम स्टैक पर धक्का देते हैं।
2) EFLAGS में IF फ्लैग (इंटरप्ट फ्लैग) सेट न करें। यही है, नकाबपोश व्यवधान निषिद्ध हैं, और आप स्विचिंग कार्यों के बारे में भूल सकते हैं।
3) यह महत्वपूर्ण है कि अगले कार्य के खोज फ़ंक्शन में गलती न करें। इसकी सादगी के बावजूद, आप वहां बीटल प्रजनन कर सकते हैं। व्यक्तिगत रूप से, मैंने इसे ओल्गा के माध्यम से अलग से निकाल दिया, ताकि परिणाम सच होने की गारंटी हो।
4) यदि आप प्रक्रिया से प्रक्रिया तक नहीं कूदने का फैसला करते हैं, लेकिन कॉल के माध्यम से शांति और शांति से कार्य करने के लिए, तो स्टैक के बारे में मत भूलना! सामान्य तौर पर, स्टैक, मेरी राय में, इस व्यवसाय में सबसे फिसलन वाला स्थान है।
अब एक संक्षिप्त संदर्भ स्विचिंग प्रक्रिया पर विचार करें। संक्षिप्त क्यों? हमें मल्टीटास्किंग दिखाने की आवश्यकता है, इसलिए मैंने अब यहां बहुत सारे कोड नहीं लिखे हैं। हमारा एक डेमो है।
ठीक है, चलो इस तथ्य से शुरू करते हैं कि हमें एक नए कार्य का वर्णन करने की आवश्यकता है। चूंकि यह Ring0 में निष्पादित होता है, आइए हम स्टैक छोड़ दें और सभी सेगमेंट का मूल्य अकेले रजिस्टर करें। बस डेटा को वापस करने के लिए रखें। यह सिर्फ एक प्रदर्शन है! यह सब पर गर्व नाम create_task नहीं होना चाहिए। बस बूट प्रक्रिया के लिए मान डालें और बिट को अधिग्रहित TSS_structs के बिटमैप में सेट करें। तो:

create_task:
mov ax,20h; - .
mov es,ax
mov [es:100h+9],dword task;EIP
pushfd ;EFLAGS
pop eax
mov [es:100h+13],eax;EFLAGS
mov [es:100h+51],word 8h ;CS – Ring0,

bts word [bysi_TSS_map],6 ;
mov ax,10h;
mov es,ax
ret


यहां 20h चयनकर्ता का उपयोग किया जाता है। TSS_structs के भंडारण के लिए मेरे पास यह क्षेत्र है। अधिक। हम 6 बिट क्यों सेट करते हैं? और यहाँ पकड़ है। कोड जो पहले से ही निष्पादित किया जा रहा है वह भी बन जाना चाहिए ...। कार्य। इसलिए, आपको यह 7 वां बिट चिह्नित करने की आवश्यकता है:

bts word [bysi_TSS_map],7


अब संदर्भों को सहेजने और स्विच करने की प्रक्रियाओं को देखते हैं, एक नए कार्य की खोज करते हैं।
यहां सब कुछ सरल और आसान है: हम कार्य संख्या द्वारा TSS_struct पते की गणना करते हैं, एक नया खोजते हैं, इसके TSS_struct से डेटा पढ़ते हैं और नए कार्य पर जाते हैं।
इसलिए, पीआईटी हैंडलर से हम कार्य स्विचिंग प्रक्रिया पर जाते हैं - task_switch:
task_switch:

mov [temp_1],eax
mov [temp_2],es

xor eax,eax
mov ax,20h
mov es,ax

call calculate_TSS_struct_address ;: EDI –
jmp store_context


स्टोर करने के लिए चर कहाँ हैं:

temp_1 dd 0;EAX
temp_2 dw 0;ES


भविष्य में हमें उस पते की गणना करनी होगी। इसलिए हम इसे एक प्रक्रिया के रूप में जारी करते हैं।

calculate_TSS_struct_address:
push eax
push ebx
mov eax,[cur_task_num]; dword' .
mov ebx,100h
mul ebx
pop ebx
mov edi,eax;EDI – TSS_struct
pop eax
ret


अब संदर्भ बचाने के लिए प्रक्रिया पर विचार करें। Banality - ऑफसेट पर हमने मान डाल दिया। वह सब है।

store_context:
;mov eax,cr3 ;
;mov [es:edi+5],eax

pushfd
pop eax
mov [es:edi+13],eax;EFLAGS

mov [es:edi+21],ecx
mov [es:edi+25],edx
mov [es:edi+29],ebx
mov [es:edi+37],ebp
mov [es:edi+41],esi
mov [es:edi+45],edi

mov ax,[temp_2]
mov [es:edi+49],ax;ES

mov eax,[temp_1]
mov [es:edi+17],eax
mov [es:edi+53],ss
mov [es:edi+55],ds
mov [es:edi+57],fs
mov [es:edi+59],gs
;sldt ax ;
;mov [es:edi+61],ax

pop eax
mov [es:edi+9],eax;EIP
;
pop ax
mov [es:edi+51],ax;CS

popfd ;EFLAGS

jmp find_next_task


निम्न फ़ंक्शन बिटमैप में अगले शिकार की खोज करता है और ईडीआई में अपना पता देता है।

find_next_task:
xor edx,edx
mov eax,[cur_task_num]
mov ecx,8
div ecx
;EAX -
;EDX - ''
test edx,edx
jnz .norm

mov edi,7
jmp .step

.norm: mov edi,8
.step: sub edi,edx;real bit #
mov edx,edi
mov edi,eax

.cycle:
bt word [bysi_TSS_map+edi],dx
jc .found
cmp dx,0
je .inc_byte
dec dx
jmp .cycle

.inc_byte:
cmp edi,10; - 800- .
je .error
inc edi
mov dx,7
jmp .cycle

.found:
push edx
mov eax,8
mul edi
pop edx

mov di,7
sub di,dx
add eax,edi
mov [cur_task_num],eax
call calculate_TSS_struct_address
jmp load_context

.error:
mov dx,7; .
xor edi,edi
jmp .cycle


अब वह सब कुछ संदर्भ लोड हो रहा है।

load_context:
;mov eax,[es:edi+5];CR3 -
;mov cr3,eax

;mov esp,[es:edi+1];
;mov ss,[es:edi+53]

mov ecx,[es:edi+21]
mov edx,[es:edi+25]
mov ebx,[es:edi+29]
mov ebp,[es:edi+37]
mov esi,[es:edi+41]
mov edi,[es:edi+45]

;mov ds,[es:edi+55]; .
;mov fs,[es:edi+57]
;mov gs,[es:edi+59]

; '' ( iretd)
push dword [es:edi+13];EFLAGS
push word [es:edi+51] ;CS
push dword [es:edi+9];EIP

jmp timer.s_t


यहां यह ध्यान देने योग्य है। जैसा कि हम याद करते हैं, रुकावट के दौरान, स्टैक में 3 मान संग्रहीत होते हैं (इस मामले में, सांप्रदायिक) (विशेषाधिकार स्तर नहीं बदलता है)। संक्रमण से पहले, हम नए कार्य के 'निर्देशांक' को स्टैक पर डालते हैं, पीआईटी हैंडलर पर नियंत्रण स्थानांतरित करते हैं और iretd बनाते हैं। हमारी पीड़ा खत्म हो गई है? लगभग। नए कार्य के संदर्भ में, आपको इंटरप्ट को सक्षम करने के लिए sti करने की आवश्यकता है। वह सब है। और तुम भयभीत थे!
टाइमर के लिए हैंडलर निम्नलिखित फॉर्म लेगा:

timer:
;........
.s_t:
push ax ; EOI
mov al,20h
out 20h,al
out 0a0h,al
pop ax
iretd ;


अब हम कार्यों का परिचय देते हैं।
याद रखें, इससे पहले हमारे पास jmp $ अंतिम कोड है?
अब आप वहां चरित्र में वृद्धि कर सकते हैं। दृष्टिगोचर और शीघ्रता से।
और जिस कार्य का हमने पहले उल्लेख किया है, उसका प्रतिनिधित्व किया जा सकता है

task:
sti
inc byte [gs:0]
jmp task


अब हम इसे सभी को एक साथ रखते हैं और परिणाम का आनंद लेते हैं।

So. यहाँ परिचयात्मक लेख है और यह खत्म हो गया है।
मल्टीटास्किंग का एक सदुपयोग लागू किया। 'कार्य' के पास अपने स्वयं के स्टैक, सेगमेंट और स्थानीय डिस्क्रिप्टर टेबल नहीं हैं ... अभी भी बहुत काम करना बाकी है। यहाँ भविष्य के रिलीज के लिए विषय हैं। मैं अपनी अंग्रेजी ('बाईसी' = 'व्यस्त' के लिए माफी मांगता हूं; लंबे समय तक हर जगह कोड को ठीक करना आसान है)।