ड्राइवर और एप्लिकेशन के बीच साझा मेमोरी को लागू करना

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



ड्राइवर को 32-बिट विंडोज एक्सपी के लिए बनाया गया था (इसने इसके संचालन की जाँच की और
32-बिट विंडोज 7 पर)।

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

सिद्धांत की बिट

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

मेमोरी आवंटन

#pragma LOCKEDCODE NTSTATUS AllocateSharedMemory(PDEVICE_EXTENSION pdx, PIRP Irp) { // AllocateSharedMemory KdPrint(("SharedMemory: Entering AllocateSharedMemory\n")); int memory_size = 262144000; // 250 Mb PHYSICAL_ADDRESS pstart = { 0x0, 0x00000000 }; PHYSICAL_ADDRESS pstop = { 0x3, 0xffffffff }; PHYSICAL_ADDRESS pskip = { 0x0, 0x00000000 }; // pointer to the output memory => pdx->vaReturned pdx->vaReturned = (unsigned short **) GenericGetSystemAddressForMdl(Irp->MdlAddress); // create MDL structure (pointer on MDL => pdx->mdl) pdx->mdl = MmAllocatePagesForMdl(pstart, pstop, pskip, memory_size); if (pdx->mdl != NULL) { KdPrint(("SharedMemory: MDL allocated at address %08X\n", pdx->mdl)); // get kernel space virtual address pdx->kernel_va = (unsigned short*) MmGetSystemAddressForMdlSafe(pdx->mdl, NormalPagePriority); if (pdx->kernel_va != NULL) { KdPrint(("SharedMemory: pdx->kernel_va allocated at address %08X\n", pdx->kernel_va)); for (int i = 0; i < 10; ++i) { pdx->kernel_va[i] = 10 - i; // write in memory: 10-9-8-7-6-5-4-3-2-1 } } else { KdPrint(("SharedMemory: Not mapped memory into kernel space\n")); return STATUS_NONE_MAPPED; } // get user space virtual address pdx->user_va = (unsigned short*) MmMapLockedPagesSpecifyCache(pdx->mdl, UserMode, MmCached, NULL, FALSE, NormalPagePriority); if (pdx->user_va != NULL) { KdPrint(("SharedMemory: pdx->user_va allocated at address %08X\n", pdx->user_va)); // return pointer on sharing memory into user space *pdx->vaReturned = pdx->user_va; } else { KdPrint(("SharedMemory: Don't mapped memory into user space\n")); return STATUS_NONE_MAPPED; } } else { KdPrint(("SharedMemory: Don't allocate memory for MDL\n")); return STATUS_MEMORY_NOT_ALLOCATED; } return STATUS_SUCCESS; } // AllocateSharedMemory 

भागों में कार्य विश्लेषण:
हम पॉइंटर को सेव करते हैं, जिसके साथ हम पॉइंटर को अपने एप्लिकेशन को आवंटित मेमोरी में पास करते हैं:

 pdx->vaReturned = (unsigned short **) GenericGetSystemAddressForMdl(Irp->MdlAddress); 

अगला चरण आकार की मेमोरी के गैर-स्थानांतरित करने योग्य भौतिक मेमोरी का आवंटन है। इसके आधार पर एमडीएल ( मेमोरी डिस्क्रिप्टर लिस्ट ) संरचना का निर्माण, सूचक जिसके लिए चर pdx-> mdl में संग्रहीत किया जाता है

 pdx->mdl = MmAllocatePagesForMdl(pstart, pstop, pskip, memory_size); 

जैसा कि आप छवि से देख सकते हैं, हमें निश्चित भौतिक पृष्ठों का वर्णन करने के लिए एमडीएल संरचना की आवश्यकता है।

तब हमें सिस्टम एड्रेस स्पेस में MDL के लिए वर्चुअल एड्रेस की रेंज मिलती है और पॉइंटर में इन पेंडर्स पर पॉइंटर को सेव करते हैं-> kernel_va:

 pdx->kernel_va = (unsigned short*) MmGetSystemAddressForMdlSafe(pdx->mdl, NormalPagePriority); 

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

लूप में, पहले 10 मेमोरी सेल को 10 से 1 की संख्या के साथ लिखें, ताकि आप उपयोगकर्ता मोड से आवंटित मेमोरी की उपलब्धता की जांच कर सकें:

 for (int i = 0; i < 10; ++i) { pdx->kernel_va[i] = 10 - i; // write in memory: 10-9-8-7-6-5-4-3-2-1 } 

अब आपको आवंटित मेमोरी को उस एप्लिकेशन के एड्रेस स्पेस में मैप करना होगा जो ड्राइवर तक पहुँचा हो:

 pdx->user_va = (unsigned short*) MmMapLockedPagesSpecifyCache(pdx->mdl, UserMode, MmCached, NULL, FALSE, NormalPagePriority); 

चर pdx-> vaReturned एक सूचक के लिए एक संकेतक है और pdx संरचना में घोषित किया गया है (ड्राइवर को देखें। source_driver फ़ोल्डर में)। इसका उपयोग करते हुए, हम आवेदन के लिए pdx-> user_va पॉइंटर पास करेंगे:

 *pdx->vaReturned = pdx->user_va; 

मुक्त स्मृति

 #pragma LOCKEDCODE NTSTATUS ReleaseSharedMemory(PDEVICE_EXTENSION pdx, PIRP Irp) { // ReleaseSharedMemory KdPrint(("SharedMemory: Entering ReleaseSharedMemory\n")); if (pdx->mdl != NULL) { MmUnmapLockedPages(pdx->user_va, pdx->mdl); MmUnmapLockedPages(pdx->kernel_va, pdx->mdl); MmFreePagesFromMdl(pdx->mdl); IoFreeMdl(pdx->mdl); KdPrint(("SharedMemory: MDL at address %08X freed\n", pdx->mdl)); } return STATUS_SUCCESS; } // ReleaseSharedMemory 

यहां एप्लिकेशन पता स्थान खाली किया गया है:

 MmUnmapLockedPages(pdx->user_va, pdx->mdl); 

सिस्टम पता स्थान:

 MmUnmapLockedPages(pdx->kernel_va, pdx->mdl); 

फिर भौतिक पृष्ठों को मुक्त कर दिया जाता है:

 MmFreePagesFromMdl(pdx->mdl); 

और "मार" एमडीएल:

 IoFreeMdl(pdx->mdl); 

हम उपयोगकर्ता मोड से ड्राइवर के लिए अपील करते हैं

(संलग्न सामग्री में संपूर्ण आवेदन कोड देखें)

पहली बात यह है कि CreateFile () फ़ंक्शन का उपयोग करके डिवाइस मैनिप्युलेटर (हैंडल) प्राप्त करें:

 hDevice = CreateFile(L"\\\\.\\SharedMemory", GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL); 

तब आपको DeviceIoControl () फ़ंक्शन का उपयोग करके ड्राइवर को I / O अनुरोध भेजने की आवश्यकता होती है:

 unsigned short** vaReturned = new unsigned short*(); ioCtlCode = IOCTL_ALLOCATE_SHARED_MEMORY; checker = DeviceIoControl(hDevice, ioCtlCode, NULL, 0, vaReturned, sizeof(int), &bytesReturned, NULL); 

फ़ंक्शन कॉल को IRP पैकेट में बदल दिया जाता है, जिसे ड्राइवर के डिस्पैच फ़ंक्शन (ड्राइवर कंट्रोलसीपी फ़ाइल में DispatchControl) में संसाधित किया जाएगा। यानी DeviceIoControl () कॉल करते समय, नियंत्रण ड्राइवर फ़ंक्शन में स्थानांतरित किया जाएगा, जिसका कोड ऊपर वर्णित किया गया था। डिवाइस, डिबग व्यू प्रोग्राम में DeviceIoControl () फ़ंक्शन को कॉल करते समय (आपको बॉक्स को चेक करने की आवश्यकता है ताकि यह कर्नेल मोड ईवेंट को पकड़ ले) हम निम्नलिखित देखेंगे:



जब नियंत्रण आवेदन पर वापस आ जाता है, तो vaReturned चर साझा मेमोरी को इंगित करेगा (अधिक सटीक रूप से, यह एक संकेतक को इंगित करेगा जो पहले से ही मेमोरी को इंगित करेगा)। चलो स्मृति को एक नियमित सूचक प्राप्त करने के लिए थोड़ा सरलीकरण करें:

 unsigned short* data = *vaReturned; 

अब, डेटा पॉइंटर का उपयोग करते हुए, हमारे पास एप्लिकेशन से साझा मेमोरी तक पहुंच है:

जब आप "आवंटित मेमोरी" बटन पर क्लिक करते हैं, तो एप्लिकेशन ड्राइवर पर नियंत्रण स्थानांतरित करता है, जो ऊपर वर्णित सभी चरणों को करता है, और आवंटित मेमोरी को एक पॉइंटर लौटाता है, जो डेटा पॉइंटर के माध्यम से एप्लिकेशन से एक्सेस किया जाएगा। “Fill TextEdit” बटन का उपयोग करते हुए, हम पहले 10 तत्वों की सामग्री को प्रदर्शित करते हैं जो ड्राइवर को QTextEdit में भरे गए थे और हम साझा मेमोरी के लिए एक सफल कॉल देखते हैं।

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

स्रोत कोड

1. source_driver.rar ।
2. source_app.rar ।
3. source_generic_oney

ड्राइवर (source_driver) के आधार के लिए, मैंने वाल्टर ओनी से एक उदाहरण लिया (उदाहरण उनकी किताब से जुड़े हैं, Microsoft Windows ड्राइवर मॉडल का उपयोग करके)। जेनेरिक कोर लाइब्रेरी को डाउनलोड करना भी आवश्यक है, जैसा कि विधानसभा और ड्राइवर संचालन के दौरान इस पुस्तकालय की आवश्यकता है।

जो लोग खुद इसे आजमाना चाहते हैं

एक निर्देशिका बनाएं (उदा। C: \ ड्राइवर) और वहां स्रोत (source_driver, source_generic_oney और source_app) को अनपैक करें। यदि आप ड्राइवर का पुनर्निर्माण नहीं करेंगे, तो यह नियंत्रण कक्ष के माध्यम से मैन्युअल रूप से नए उपकरण स्थापित करने के लिए पर्याप्त है (inf-file: sharememory.inf को निर्दिष्ट करके) - नए उपकरण स्थापित करें (Windows XP के लिए)। फिर आपको habr_app.exe (source_app / release) चलाने की आवश्यकता है।

यदि आप आश्वस्त करने का निर्णय लेते हैं, तो:
1. आपको डब्ल्यूडीके इंस्टॉल करना होगा।
2. सबसे पहले आपको जेनेरिक लाइब्रेरी के पुनर्निर्माण की आवश्यकता है, क्योंकि ओएस संस्करण के आधार पर, आउटपुट फ़ाइलों वाले फ़ोल्डर को अलग-अलग कहा जा सकता है (जैसे, XP के लिए - Winjchk_wxp_x86, Win7 के लिए - objchk_win7_x86)।
3. अंक 1 और 2 के बाद, आप WDK में शामिल x86 चेक्ड बिल्ड पर्यावरण का उपयोग करके ड्राइवर को "बिल्ड" कमांड के साथ बनाने की कोशिश कर सकते हैं।

सूत्रों का कहना है

• Wasm.ru से लेख
• वाल्टर वे "माइक्रोसॉफ्ट विंडोज ड्राइवर मॉडल का उपयोग कर रहे हैं" (आईएसबीएन 978-5-91180-057-4, 0735618038)।
• पेशेवर के लिए जेफरी रिक्टर विंडोज। प्रभावी Win32 अनुप्रयोगों का निर्माण ”(आईएसबीएन 5-272-00384-5, 1-57231-996-8)।
• MSDN

UPD: jon habrayuzer इस लिंक को साझा किया गया जिसका अर्थ है कि साझा मेमोरी Qt ।