ენერგიის მენეჯმენტი Windows-ში. ენერგიის მენეჯმენტი Windows Powercfg მოძველებული ბირთვის აბონენტში

Windows Defender უსაფრთხოების ცენტრი, მათ შორის ახალი განყოფილება"მოწყობილობის უსაფრთხოება", რომელიც გთავაზობთ უსაფრთხოების მოწინავე ინსტრუმენტების მართვას, როგორიცაა "ბირთის იზოლაცია".

Core იზოლაცია არის ვირტუალიზაციაზე დაფუძნებული უსაფრთხოების ტექნოლოგია, რომელიც უზრუნველყოფს დამატებითი დონედაცვა ინტელექტუალური თავდასხმებისგან. მეხსიერების მთლიანობა არის ძირითადი იზოლაციის ტექნოლოგიის ერთ-ერთი კომპონენტი - ფუნქცია, რომელიც შექმნილია ჩასმის თავიდან ასაცილებლად მავნე კოდიმაღალი უსაფრთხოების პროცესებში. დაცვა უზრუნველყოფილია იმით, რომ ბირთვის ვირტუალური მეხსიერების გვერდი იწყებს შესრულებას მხოლოდ წარმატებული შემოწმების შემდეგ.

ვნახოთ, როგორ ჩართოთ მეხსიერების მთლიანობის ფუნქცია Windows 10 აპრილის 2018 წლის განახლებაში თქვენი კომპიუტერის უსაფრთხოების გასაუმჯობესებლად.

მეხსიერების მთლიანობის ჩართვა

გახსენით Windows Defender უსაფრთხოების ცენტრი.
აირჩიეთ "მოწყობილობის უსაფრთხოება" განყოფილება.

ბირთვის იზოლაციის განყოფილებაში დააწკაპუნეთ ბირთვის იზოლაციის დეტალების ბმულზე.
გადაიტანეთ მეხსიერების მთლიანობის გადამრთველი აქტიურ პოზიციაზე.

ამ ნაბიჯების დასრულების შემდეგ, თქვენ უნდა გადატვირთოთ კომპიუტერი, რომ ცვლილებები ძალაში შევიდეს.

შენიშვნაშენიშვნა: ამ ფუნქციის მუშაობისთვის თქვენს პროცესორს უნდა ჰქონდეს ვირტუალიზაციის ტექნოლოგიების მხარდაჭერა. ასევე, ვირტუალიზაცია უნდა იყოს ჩართული BIOS-ში ან UEFI-ში. წინააღმდეგ შემთხვევაში, ფუნქცია არ იქნება ხელმისაწვდომი.

ბირთვის იზოლაციის საკითხების დაფიქსირება

ზოგიერთ შემთხვევაში, შეიძლება შეგექმნათ თავსებადობის პრობლემები ზოგიერთ აპლიკაციაში, თუ ძირითადი იზოლაცია ჩართულია. პრობლემის გადასაჭრელად, თქვენ უნდა გამორთოთ ფუნქცია.

თუ თქვენ ცდილობთ გამორთოთ მეხსიერების მთლიანობა Windows Defender უსაფრთხოების ცენტრში, მაგრამ ოფცია ნაცრისფერი გახდა და გამოჩნდება შეტყობინება „ამ პარამეტრს მართავს თქვენი ადმინისტრატორი“, თქვენ კვლავ შეგიძლიათ გამორთოთ ფუნქცია სისტემის რეესტრის გამოყენებით.

შენიშვნა: რეესტრის არასწორად შეცვლამ შეიძლება სერიოზული პრობლემები გამოიწვიოს. რეკომენდირებულია შექმნა სარეზერვო ვინდოუსის რეესტრიამ ნაბიჯების შესრულებამდე. რეესტრის რედაქტორის მენიუდან აირჩიეთ ფაილი > ექსპორტი სარეზერვო ასლის შესანახად.

პრესის კომბინაცია ვინდოუსის გასაღებები+ R Run ფანჯრის გამოსატანად.
ჩაწერეთ regedit და დააჭირეთ OK რეესტრის რედაქტორის გასაშვებად.
გადადით შემდეგ გზაზე:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\DeviceGuard\Scenarios\HypervisorEnforcedCodeIntegrity

ორჯერ დააწკაპუნეთ ჩანაწერზე ჩართულია.
შეცვალეთ მნიშვნელობა 1-დან 0-მდე.
დააწკაპუნეთ OK.

გამორთვისთვის, ასევე შეგიძლიათ გამოიყენოთ მზა

კითხვა: როდის ხანგრძლივი მუშაობაკომპიუტერის ან ძილის რეჟიმიდან გასვლისას, დაწყების მენიუში შრიფტი დაკარგულია

როდესაც კომპიუტერი დიდი ხნის განმავლობაში მუშაობს ან იღვიძებს ძილისგან, Start მენიუ ხდება ასეთი.

როგორ გავასწორო? Დამეხმარე, გთხოვ..

პასუხი:უკვე ხელახლა დააინსტალირე და განახლებულია (

შეკითხვა: როგორ შემიძლია ჩემი კომპიუტერი ჩავაყენო ძილის რეჟიმში S1 ტიპის ("Stand by")?

არც ზე სამაგიდო კომპიუტერი, ვერც ლეპტოპზე ვერ გავარკვიე, როგორ გადავიყვანო კომპიუტერი ძილის რეჟიმში, როგორიცაა S1.

"powercfg /a" შესრულების შედეგი

ძილის შემდეგი მდგომარეობა ხელმისაწვდომია ამ სისტემაში:
ლოდინის (S3)

ძილის შემდეგი მდგომარეობა არ არის ხელმისაწვდომი ამ სისტემაში:
ლოდინის რეჟიმში (S1)

ლოდინის რეჟიმში (S2)
სისტემის firmware-ს არ აქვს ლოდინის მხარდაჭერა.

ჰიბერნაცია
ჰიბერაციის რეჟიმი არ არის ჩართული.

ლოდინის რეჟიმში (დაკავშირებული)
სისტემის firmware-ს არ აქვს ლოდინის მხარდაჭერა.

ჰიბრიდული ძილი

Სწრაფი გაშვება
ჰიბერაციის რეჟიმი მიუწვდომელია.

პასუხი:გააჩერეთ თქვენი კომპიუტერი უმოქმედოდ რამდენიმე წუთის განმავლობაში, შემდეგ დააძინეთ და გააღვიძეთ.

ღონისძიების ჟურნალში:
მოქმედება => მორგებული ხედის შექმნა
თარიღის პუნქტში დააყენეთ, მაგალითად, ორწუთიანი ინტერვალი და ნახეთ რა მოხდა.

მეტი იდეები არ მაქვს.

კარგად, შეამოწმეთ კომპიუტერთან დაკავშირებული დრაივერები და მოწყობილობები

კითხვა: ძილისგან გაღვიძება დილის 4 საათზე

თითქმის ყოველ ღამე კომპიუტერი მაღვიძებს და მაღვიძებს.
მოწყობილობის მენეჯერში, ქსელის ადაპტერები, მონიშნული "გაღვიძება ჯადოსნური პაკეტებით".
გამორთეთ გაღვიძების ტაიმერი დენის პარამეტრებში.
in ბრძანების ხაზიბრძანება powercfg /waketimers აჩვენებს ამას.

c:\>powercfg /waketimers
Legacy kernel აბონენტის მიერ დაყენებული ტაიმერი მოქმედებს 01/09/2016 4:14:46-მდე.
მიზეზი:

დახმარება. ვინ არის დამნაშავე და რა უნდა გააკეთოს?

პასუხი:საბოლოოდ განკურნა ეს დაავადება:

მართვის პანელი -> უსაფრთხოება და მოვლა -> მოვლა -> ავტომატური მოვლა -> შეცვალეთ ტექნიკური პარამეტრები -> მოხსენით მონიშვნა "დაუშვას ტექნიკური დავალების გაღვიძება ჩემი კომპიუტერის..."

თემა: ჩემი კომპიუტერი შემთხვევით ირთვება ღამით

ახლახან (დაახლოებით 1 ... 2 თვე), დაახლოებით 30 ... 60 წუთის შემდეგ კომპიუტერის ძილის რეჟიმში გადაყვანიდან (ისე, რომ თქვენ შეგიძლიათ გააგრძელოთ მუშაობა დილით მისი შეწყვეტის მომენტიდან), ის სპონტანურად ირთვება. სამუშაოს დაახლოებით ღამის 12 საათზე ვამთავრებ, ე.ი. ჩართვა ხდება ღამის 0:30...1:00 საათზე. ამ შემთხვევაში, მონიტორი ბნელი რჩება. საწოლიდან ვდგები, მაუსს ვამოძრავებ - მონიტორი ირთვება, პროფილში ნორმალურ რეჟიმში შევდივარ, ძილის რეჟიმში ვაბრუნებ - ამ ღამეს აღარ ირთვება.

Win7 კომპიუტერულ სისტემაზე არის რეზიდენტი ანტივირუსი MS Security Esentials. რამდენჯერმე გავუშვი ამჟამინდელი (ახლად გადმოწერილი) სამკურნალო საშუალებები mbar და DrWeb Cureit - ვიპოვე რამდენიმე ბაიკი, მაგრამ მაინც დარჩა სპონტანური გააქტიურება. ეს ჰგავს ვირუსს, რომელიც აკავშირებს ჩემს კომპიუტერს DDOS შეტევებთან. უფრო მეტიც, დროდადრო Google ბლოკავს წვდომას ჩემი IP-დან შემოსული საეჭვო ტრაფიკის გამო. ეს საკმაოდ დიდი ხანია (წელზე მეტი) ხდება, მაგრამ კომპიუტერის სპონტანური ჩართვა სულ ახლახანს შევნიშნე.

სინამდვილეში, საკითხავია: თუ პრობლემა ცნობილია და შედარებით ადვილია მკურნალობა, მაშინ ჩამოვტვირთავ რეკომენდებულ პროგრამულ უზრუნველყოფას, დავასკანირებ და გამოვაქვეყნებ. თუ პრობლემა უფრო რთულია, მაშინ არც თავს მოვიტყუებ და არც ადგილობრივ გურუებს და სულელურად გადავაწყობ სისტემას.

პასუხი: ფალკონისტირაღაც ვერ გავიგე...

შეტყობინება ფალკონისტი

კომპიუტერის ძილის რეჟიმში გადაყვანის შემდეგ... ის სპონტანურად ირთვება

ძილის რეჟიმი და ჰიბერაციის რეჟიმი 7-ში სრულიად განსხვავებული რამ არის. ძილის რეჟიმში გადასასვლელად, უბრალოდ დააჭირეთ კლავიატურაზე Sleep ღილაკს. თუ დააწკაპუნებთ დაწყებას და მაუსის გადატანას დააწებებთ ისარს Shut down-ის გვერდით, გამოჩნდება მენიუ, რომელშიც ასევე არის ძილის რეჟიმი. და ჰიბერნაცია. ჰიბერნაციის დროს კომპიუტერი გამორთულია კვების წყაროდან ისევე, როგორც გამორთვისას, მაგრამ კომპიუტერის ჩართვისას შეგიძლიათ დაიწყოთ მუშაობა ისევე, როგორც ძილის რეჟიმის შემდეგ.
მაგრამ შენ სხვა რამეზე გკითხე. შეამოწმეთ დავალების განრიგი?

კითხვა: კომპიუტერი ღამით იღვიძებს

კარგი დღე ყველას. მე უკვე შემექმნა ეს პრობლემა. თავისთავად, კომპიუტერი ღამით იღვიძებს, Windows 10 ღირს, მანამდე 7 იყო, ასეთი პრობლემა არ ყოფილა, ამიტომ ავირჩიე ეს კონკრეტული განყოფილება.
რაც უკვე გაკეთდა 2 დღის წინ:
1. ივენთ მაყურებელში ვიპოვე მიზეზი: ტაიმერი - შესრულდება დაგეგმილი დავალება "NT TASK\Microsoft\Windows\UpdateOrchestrator\Reboot", რომელმაც მოითხოვა კომპიუტერის გამოღვიძება ძილის რეჟიმიდან.
მივედი Task Scheduler-ში, ვიპოვე ეს დავალება და მოვხსენი პუნქტი: Conditions - Wake up the computer, რომ დავასრულოთ დავალება.
2. მივედი powercfg.cpl - ელექტროენერგიის გეგმის დაყენება - შეცვლა დამატებითი პარამეტრებისიმძლავრე - ძილი - გაღვიძების ქრონომეტრების დაშვება - გამორთვა.

ამაღამ სიტუაცია განმეორდა, მაგრამ ღონისძიების მაყურებელს მხოლოდ:

სისტემა გავიდა დაბალი სიმძლავრის მდგომარეობიდან.

ძილის დრო: 2016-10-29T21:38:38.657073700Z
გაღვიძების დრო: 2016-10-29T21:58:34.625754700Z

გამომავალი წყარო: მონაცემები არ არის

3. მოწყობილობის მენეჯერში მოხსნადი „დაუშვა ამ მოწყობილობას გამოაღვიძოს კომპიუტერი ლოდინის რეჟიმიდან“ მაუსიდან, კლავიატურიდან, ქსელის ბარათიდან და სადაც ვიპოვე ...

დაეხმარეთ მოგვარებაში ეს პრობლემააღარ ვიცი სად ამოთხარო...

პასუხი:

შეტყობინება GoLeMjkeee

ღირს ყოველ დღე 2-00 საათზე

დღისით შეცვლა.

შეტყობინება GoLeMjkeee

მაგრამ მონიშნე .... არ ღირს.

10-კა ის არის, ხასიათით.

კითხვა: როგორ დავიმალო ეკრანი „შესვლა“ ღილაკით ძილის რეჟიმიდან გაღვიძებისას?

Windows 10 Pro 1607.
ძილის რეჟიმიდან გასვლისას Windows გთხოვს დააჭიროთ „შესვლას“. ჩნდება გაღვიძებისას ლურჯი ეკრანიმომხმარებლის სახელის წარწერით და მის ქვეშ ღილაკით „შესვლა“. პაროლი არ არის დაყენებული, მომხმარებელი სისტემაში ერთადერთია ადმინისტრატორის უფლებებით. ჩატვირთვისას ყველაფერი კარგადაა, ეკრანები და ღილაკების დაჭერა არ არის, მხოლოდ დესკტოპი.

ოფციებში - ანგარიშები- შესვლის ოფციებს არ აქვს პუნქტი "შესვლა აუცილებელია".
მომხმარებლის ანგარიშების ფანჯარაში, მომხმარებლების ჩანართზე, მონიშნული ველი "მოითხოვეთ მომხმარებლის სახელი და პაროლი" მოხსნილია.
ელექტროენერგიის გეგმის პარამეტრებში არ არის "პაროლის მოთხოვნა გაღვიძებისას".

როგორ ამოიღოთ "შესვლა" ღილაკი ძილის რეჟიმიდან გასვლისას, რათა კომპიუტერმა ავტომატურად დაიწყოს დესკტოპი ამ ფანჯრის გვერდის ავლით?

პასუხი:ძილის რეჟიმის ამოღება

შეკითხვა: Windows 8.1 გამორთულია ძილის რეჟიმში

გამარჯობა.
ძილის რეჟიმის პრობლემა მაქვს. კომპიუტერი მთლიანად ითიშება ძილის დროს. იმათ. საკვები მთლიანად იკარგება. ადრე სისტემურ ერთეულზე ნათურა ციმციმებდა საძილეში, ახლა მთლიანად „ოპტუჰატ“ და მაუსიც usb-ით, კლავიატურა გადის და მხოლოდ ჩართვის ღილაკით შეგიძლია ჩართო და ბუნებრივია ყველა ინფორმაცია არ არის. გადაარჩინა.
ინტერნეტში ბევრი თემა წავიკითხე, მაგრამ არც ერთი პრობლემა არ არის ჩემი მსგავსი.
მე დაუყოვნებლივ დავწერ კომპიუტერის მახასიათებლებს: დედაპლატა ASUS p8h67, რადეონის ვიდეო HD7850 (asus), intel i5 2550k, 8 გბ ოპერატიული მეხსიერება, SSD სილიკონის სიმძლავრე s55 120 გბ, HDD WD 500 გბ.
ვინდოუსი 8.1 დავაყენე, ძალიან დიდი ხანია დგას და ძილის რეჟიმი ისე მუშაობდა, როგორც უნდა. ერთხელ მან შეწყვიტა მუშაობა, არც კი ვიცი ზუსტად რატომ და რის შემდეგ (ნებისმიერი ქმედებები) შეწყვიტა მუშაობა. ეტყობა მსგავსი არაფერი დამიყენებია, დრაივერი არ გამიახლოებია.
ჩვევის გამო, გამორთვის ნაცვლად, ხშირად ვაჭერ ძილს და ერთხელ მუშაობდა და მუშაობდა რამდენიმე დღის განმავლობაში, მაგრამ საბოლოოდ შეწყვიტა მუშაობა.
ვცადე დრაივერების განახლება ან დეინსტალაცია. ვცადე კომპიუტერიდან გათიშვა დამატებითი მოწყობილობები(კარგი, შენ არასოდეს იცი). გამორთეთ სხვადასხვა პროგრამები ძილის წინ. არაფერი ეშველა.
ინტერნეტში ვიპოვე ერთადერთი ინფორმაცია, რომელიც ზუსტად იგივეა, რაც ჩემი (პუნქტი 8):

რა თქმა უნდა, ვერ დავაყენე დრაივერი, სხვადასხვა პლატფორმები. ჩემთვის ვერ ვიპოვე.

არ მინდა OS-ის ხელახლა ინსტალაცია. ყველაფერი (ძილის გარდა) კარგად მუშაობს.
გაქვთ რაიმე იდეა, რისი ბრალი შეიძლება იყოს?

დამატებულია 17 წუთის შემდეგ
დამავიწყდა დამეწერა, რომ BIOS გადატვირთულია და განახლებულია.

პასუხი:შეამოწმეთ შემდეგ ან BP ან დედა. პროგრამულად, ჩვენ დავაყენეთ ძილისა და ჰიბერნაციის კონფიგურაცია powercfg/h ჩართულით.

კიდევ ერთი ვარიანტია შემოწმება (ჩანაცვლება). hiberfil.sys - ის პასუხისმგებელია ჰიბერნაციაზე.

კითხვა: ძილის რეჟიმი Windows 8-ში

ძილისგან გაღვიძების შემდეგ windows რეჟიმი 8 იწყებს გადატვირთვას და შემდეგ Windows-ის ჩამოტვირთვაგამოჩნდება შემდეგი შეტყობინება
მითხარი როგორ მოვიქცე?

პასუხი:

შეტყობინება აზატი145

Windows 8 გადაიტვირთება ჰიბერნაციიდან გაღვიძების შემდეგ

Პირველად.
მერე.

კითხვა: ჰიბრიდული ძილი თუ ჰიბერნაცია? რომელი ჯობია დესკტოპზე?

ძირითადად, კითხვა სათაურშია. როგორც საძიებო სისტემიდან მივხვდი, უფრო სწორად, ყველა საიტზე დაკოპირებული იგივე სტატიიდან, ჰიბრიდული ძილის რეჟიმის უპირატესობა მხოლოდ ჩართვის, გაღვიძების სისწრაფეშია, შეიძლება ითქვას. და თუ მსურს გამოვიყენო Hibernation რეჟიმი ჩემს დესკტოპზე Windows 7 x64, არის წყალქვეშა ქანები? უბრალოდ დენი უნდა გამოვრთე და ჰიბრიდული ძილით ჯობია ეს არ გავაკეთო. მადლობა ყველას ვინც გამოეხმაურება

პასუხი:წაიკითხეთ დღეს. კარგი, ვფიქრობ, სხვა პასუხი არ არსებობს ჩემს კითხვაზე, გარდა მოკლე ბრიფინგი Microsoft-ისგან. შემდეგ მე გაგიზიარებთ ჩემს დასკვნებს (მათთვის ვინც ამ თემაში ხვდება მსგავს საკითხზე).
Ისე:

დადებითიჰიბრიდული ძილის რეჟიმი: 1. სწრაფი ჩართვა, არ არის საჭირო კომპიუტერის მთლიანად გამორთვა;
მინუსები: 1. იტვირთება HDD(ჩვენი ფორუმის Windows 7 განყოფილებიდან ერთი მოდერატორის მიხედვით); 2. მთლიანად არ ითიშება, აგრძელებს დინების ჭამას, თუმცა ცოტათი (თუმცა ზოგიერთისთვის ეს ნივთი პლუსია)

მოკლედ, ჰიბერნაცია საჭიროა, თუ გსურთ მისი გამუდმებით გათიშვა, მაგრამ არ გსურთ OS-ის ჩატვირთვა/გამორთვა დიდი ხნით.
ჰიბრიდული ძილის რეჟიმი - მათთვის, ვინც კმაყოფილია მუდმივად ონლაინ კომპიუტერით.

კითხვა: ადრე ლეპტოპი გამორთული იყო დასაწყისში, ახლა ის ძილის რეჟიმშია

Ჩემი ლეპტოპი DELL INSPIRON 3521 Windows 8.1-ით გათიშვისას გამოიყენებოდა (გამოჩნდა DELL-ის ლოგო - გამორთვა - ხელახლა ჩართული და ნორმალური მუშაობა). განახლებული სისტემა 10k-მდე, არ უშველა. ჩავიცვი მთის სერვის ცენტრში, რომელიც ცნობილია ქალაქში და ვამაყობდი - იქ ლეპტოპი უსაფრთხოდ ისვენებდა ადამიანის ყურადღებისგან 2 კვირის განმავლობაში. მისი ამოღებით, მე მოვაგვარე პრობლემა გამორთვით სწრაფი დატვირთვადა ბედნიერად დაბრუნდა 8.1-ზე.
ერთი თვე გავიდა და ახლა ლეპტოპის თავსახურს რომ ვხურავ, ის გადადის ძილის რეჟიმში (ასე პარამეტრებში), მაგრამ 20 წუთის შემდეგ ან ცოტა მეტის შემდეგ მთლიანად ითიშება (ასე არ მომხდარა და დენი პარამეტრები არ შეცვლილა). როდესაც ჩართავთ სიტუაციას, რომელიც ზემოთ აღვწერე: ჩართვა - ლოგო - გამორთვა. გადატვირთვის შემდეგ ნორმალური მუშაობა. ყველა მძღოლი განახლებულია. რა შეიძლება იყოს პრობლემა და როგორ გამოვასწორო? სამწუხაროა ღარიბი კაცისთვის - სულ წელიწადნახევარია, მაგრამ მე მაქვს დიპლომი და სახელმწიფო საბუთები - ახლა მას ვერ გადავიტანე ოსტატებთან ...

პასუხი:როგორ გინდა რომ იმუშაოს? პირადად მე ვიყენებ ჰიბერნაციას და არა ძილის რეჟიმს, ასევე ჩართულია ჰიბერნაციაზე გადასვლა უმოქმედობის დროს, პარამეტრები არის დანართში

დენის პარამეტრების მიგრაცია

თქვენი კარგი სამუშაოს გაგზავნა ცოდნის ბაზაში მარტივია. გამოიყენეთ ქვემოთ მოცემული ფორმა

სტუდენტები, კურსდამთავრებულები, ახალგაზრდა მეცნიერები, რომლებიც იყენებენ ცოდნის ბაზას სწავლასა და მუშაობაში, ძალიან მადლობლები იქნებიან თქვენი.

მასპინძლობს http://www.allbest.ru/

1. თეორიული ინფორმაცია

1.1 Windows Kernel დრაივერების შემუშავება

მოკლე თეორიული ინფორმაცია

ბირთვის დრაივერების განვითარება

დრაივერი არის კომპიუტერული პროგრამა, რომელიც საშუალებას აძლევს სხვა პროგრამას (ჩვეულებრივ ოპერაციულ სისტემას) შევიდეს აპარატურაზე სტანდარტული გზით.

სქემატურად იმის ჩვენება, თუ როგორ მუშაობს სხვადასხვა ტიპის დრაივერები:

მოხერხებულად შეიძლება დაიყოს 2 ტიპად:

- ბირთვის დრაივერები (მუშაობენ პრივილეგიურ დონეზე 0, მაგრამ არანაირად არ ურთიერთობენ არც მომხმარებლის პროგრამასთან და არც მოწყობილობასთან. ჩვენ დავიწყებთ მათთან (ისინი უფრო მარტივია და შეიძლება სასარგებლოც იყოს).

მოწყობილობის დრაივერები - აუცილებელია მომხმარებლის პროგრამასა და მოწყობილობას შორის ურთიერთქმედების განსახორციელებლად, კერძოდ, მათ შორის მონაცემების გადასაცემად, მოწყობილობის გასაკონტროლებლად. უფრო მეტიც, მოწყობილობები შეიძლება იყოს როგორც რეალური, ასევე ვირტუალური). მძღოლს არცერთის კონტროლი არ უწევს ფიზიკური მოწყობილობა. ზოგიერთი ოპერაციული სისტემა ასევე გაძლევთ საშუალებას შექმნათ ვირტუალური მოწყობილობის დრაივერები - ობიექტები, რომლებიც იქცევიან I/O მოწყობილობების მსგავსი, მაგრამ არ შეესაბამება რომელიმე ფიზიკურ მოწყობილობას.

ბირთვის კომპონენტები მუშაობს პროცესორის პრივილეგირებულ რეჟიმში (ე.წ. ბირთვის რეჟიმში), შეუძლიათ ყველაფერი გააკეთონ, კერძოდ:

- მათ შეუძლიათ შეასრულონ პრივილეგირებული პროცესორის ბრძანებები (მაგალითად, lgdt),

- შეუძლია სისტემის მონაცემებსა და კოდებზე წვდომა,

- გქონდეთ პირდაპირი წვდომა აღჭურვილობაზე, მაგალითად, პორტების საშუალებით

- აქვს წვდომა მეხსიერების უჯრედებზე; დრაივერს არ შეუძლია უშუალოდ ფიზიკური მეხსიერების მანიპულირება, მაგრამ მას შეუძლია ნებისმიერი ფიზიკური მეხსიერების ვირტუალური მისამართის მიღება და მისი მანიპულირება.

თუ გსურთ დაწეროთ რაიმე სერიოზული აპლიკაცია, რომელიც მოითხოვს წვდომას სისტემის შიდა ფუნქციებზე ან მონაცემთა სტრუქტურებზე, მაშინ შეიძლება შეხვდეთ ბევრ შეზღუდვას, რომელთა გადალახვა შესაძლებელია მხოლოდ თქვენი კოდის სისტემის მისამართების სივრცეში განთავსებით. დოკუმენტირებულიდან, ამის გაკეთების მხოლოდ ერთი გზა არსებობს - დრაივერის დაყენება. ეს მეთოდი შედარებით მარტივი, საიმედო და რაც მთავარია, სრულად არის მხარდაჭერილი თავად ოპერაციული სისტემის მიერ.

ბირთვის კოდი (ფაქტობრივად, ეს არის თავად სისტემა) ითვლება სრულად სანდო. ამიტომ, როდესაც იტვირთება სისტემის მისამართების სივრცეში, დრაივერი ხდება სისტემის ნაწილი და არ ექვემდებარება რაიმე შეზღუდვას. Windows-ზე, ეს არის პრაქტიკულად ერთადერთი გზა არა OS-ის დეველოპერებისთვის, რომ დაწერონ ბირთვის დონის სისტემის კომპონენტები.

იმისათვის, რომ დაწეროთ და ისწავლოთ დრაივერების შემუშავება, გამოიყენეთ DDK (Device Development Kit) - დრაივერების შემუშავების სისტემა.

დოკუმენტაციის გარდა, DDK შეიცავს მოიცავს ფაილების კომპლექტს (.inc) და ბიბლიოთეკის ფაილებს (.lib).

ამრიგად, Windows მხარს უჭერს სხვადასხვა ტიპის მოწყობილობის დრაივერებს, მაგრამ გარდა ამისა, არის დრაივერები, რომლებიც არ არიან მოწყობილობის დრაივერები, მაგრამ უბრალოდ საშუალებას გაძლევთ შექმნათ პროგრამები, რომლებიც Windows-ში იმუშავებს ბირთვის რეჟიმში, ე.ი. პრივილეგიის დონეზე 0. ამავდროულად, მათ აქვთ სრული წვდომა OS და აპარატურაზე.

განვიხილოთ უმარტივესი ბირთვის რეჟიმის დრაივერი.

#შეიცავს

int DriverEntry (

PDRIVER_OBJECT-ში pDriverObject,

PUNICODE_STRING pusRegistryPath-ში) (

}

შესვლის წერტილი არის DriverEntry, რომელიც ფორმატირებულია, როგორც პროცედურა, რომელიც იღებს ორ პარამეტრს:

pDriverObject არის მაჩვენებელი ახლად შექმნილი დრაივერის ობიექტისკენ. როდესაც სისტემა იტვირთება დრაივერი, სისტემა ქმნის დრაივერის ობიექტს, რომელიც წარმოადგენს დრაივერის მეხსიერების სურათს. ამ ობიექტის მეშვეობით სისტემა აკონტროლებს დრაივერს. "მძღოლი" ობიექტი არის DRIVER_OBJECT ტიპის ჩვეულებრივი მონაცემთა სტრუქტურა.

pusRegistryPath - მაჩვენებელი რეესტრის გასაღებზე, რომელიც შეიცავს დრაივერის ინიციალიზაციის პარამეტრებს.

ეს ჩვენი პირველი დრაივერი მხოლოდ იტვირთება სისტემაში და მაშინვე განიტვირთება.

ახლა განიხილეთ შაბლონური პროგრამა, რომელიც უნდა იქნას გამოყენებული პროგრამის შესამუშავებლად კურსის მუშაობის პირველ საფეხურზე (kernel mode driver beeper.sys).

ამ დრაივერის ამოცანაა სისტემის დინამიკაზე ერთი ნოტის დაკვრა პირველ ოქტავამდე. ამისთვის დრაივერი იყენებს პროცესორის შესვლისა და გამოსვლის ინსტრუქციებს შესაბამის I/O პორტებზე წვდომისთვის. საყოველთაოდ ცნობილია, რომ I/O პორტებზე წვდომა არის წმინდა დაცვა ვინდოუსის სისტემარესურსი. მომხმარებლის რეჟიმიდან რომელიმე მათგანზე წვდომის მცდელობა, როგორც შეყვანისთვის, ასევე გამოსასვლელისთვის, აუცილებლად იწვევს გამონაკლისს.

ჩვენს მაგალითში იმუშავებს დინამიკი (ამისთვის, კერძოდ, გამოიყენება პორტი 61h, 0 და 1 ბიტი, პორტი 43h და 42h).

მძღოლის დაწყებისას 12-ვე შენიშვნა განისაზღვრება.

საჭირო იქნება არა მხოლოდ დინამიკის ჩართვა, არამედ ხმის სიხშირის დაყენება. ამისთვის გამოიყენება ტაიმერის ქვესისტემა, რომელიც მუშაობს პროცესორისგან დამოუკიდებლად და აქვს 3 არხი. არხის 2 გამომავალი დაკავშირებულია დინამიკთან, რომელიც გამოიყენება სხვადასხვა სიხშირის ხმის გამოსამუშავებლად. ხმის დიაპაზონი - 30Hz-6000Hz.

ხმის სიხშირის დასაყენებლად, საკონტროლო სიტყვა 0Bh იგზავნება პორტში 43h (ტაიმერის ბრძანების რეგისტრი):

mov al,0Bh

გარეთ 43 სთ, ალ

ეს მნიშვნელობა განსაზღვრავს არხის რაოდენობას, რომელსაც ჩვენ ვმართავთ, ოპერაციის ტიპს, არხის მუშაობის რეჟიმს და მრიცხველის ფორმატს.

შემდეგ ხელახლა გამოთვლილი ხმის სიხშირე (1193167/სიხშირე (Hz)) იგზავნება პორტში 42h ორ ნაწილად (ჯერ დაბალი ნაწილი, შემდეგ მაღალი ნაწილი).

მაგალითად, გვინდა მივიღოთ ხმის სიხშირე 100 ჰც. ხელახლა გამოთვალეთ სიხშირე

1193167/100 = 11931

შემდეგ:

მოვაქსი, 11931 წ

გარეთ 42 სთ, ალ

მოვ ალ, აჰ

გარეთ 42 სთ, ალ

კურსის მუშაობის პირველ საფეხურზე თქვენ უნდა შეცვალოთ პროგრამა ისე, რომ მან გამოუშვას სხვა მუსიკალური ხმები (თითოეულს აქვს საკუთარი ვერსია).

ხშირად, ამოცანები სხვადასხვა ხანგრძლივობით უნდა განისაზღვროს. ამისათვის მოსახერხებელია DO_DELAY პროცედურის გამოყენება, ირიბად განსაზღვრული პარამეტრის „ჟღერადობის დრო“ გადაცემით.

იმისათვის, რომ მოსახერხებელი იყოს დრაივერის გამართვა, არსებობს სხვადასხვა ხელსაწყოები. უმარტივესი რამ არის საჭირო ინფორმაციის ჩვენება Debug View კომუნალური პროგრამის სპეციალურ ფანჯარაში. ეს პროგრამა პირველად ამოქმედდა და კონფიგურირებულია შეტყობინებების ჩასაჭრელად ბირთვის დონიდან. გამოსასვლელად პროგრამა იძახებს DbgPrint ფუნქციას, რომელსაც აქვს ერთი პარამეტრი - გამომავალი სტრიქონი. დრაივერის გაშვების შემდეგ, Debug View ფანჯარა აჩვენებს ყველა გამომავალს.

დრაივერის ბირთვში დაყენების სხვადასხვა გზა არსებობს. ვინაიდან ჩვენი დრაივერი, ფაქტობრივად, არ არის საჭირო სისტემას (ის არ აკონტროლებს არცერთ მოწყობილობას), ჩვენ დროებით დავუკავშირებთ დრაივერს სისტემას და შემდეგ ამოვიღებთ მას.

ამისათვის თქვენ უნდა შექმნათ აპლიკაცია, რომელიც აწარმოებს დრაივერს. Როგორ? დრაივერი არის ბირთვის დონის სერვისი. ამიტომ, აპლიკაცია გამოიყენებს SCM - სერვისის კონტროლის მენეჯერს, რომელიც შედის Windows-ში და მუშაობს მომხმარებლის დონეზე.

ამრიგად, აუცილებელია გადაწყვეტის აგება ორი პროექტისგან: კონსოლის აპლიკაციიდან და დრაივერიდან.

C-ში დრაივერების შესაქმნელად, ჯერ უნდა:

- დააინსტალირეთ DDK,

- დააყენეთ გარემოს ცვლადი WNETBASE (მნიშვნელობა - გზა DDK-მდე, მაგალითად, e:\winddk\3790.1830).

მძღოლის პროექტი უნდა იყოს MakeFile ტიპის.

გააკეთეთ პროექტის პარამეტრები აპლიკაციის პარამეტრების გამოყენებით და ჩაწერეთ ხაზი Build Command Line ველში

ddkbuild -WNETXP chk . -ceZ

რას ნიშნავს სპეციალური სკრიპტის გამოძახება VC-თან DDK-თან კომუნიკაციისთვის

შემდეგი ფაილები უნდა იყოს წარმოდგენილი პროექტის მიმდინარე საქაღალდეში:

წყაროები, makefile, ddkbuild.cmd (სკრიპტი), დრაივერის წყარო ფაილი.c

პროექტის აშენების შემდეგ დრაივერს უნდა ჰქონდეს .sys გაფართოება.

აპლიკაცია იწყებს beeper.sys დრაივერს, ე.ი. აღწერს მას რეესტრში და ახორციელებს ექსპლუატაციაში. შემდეგ, როდესაც დასრულდება, ის ამოღებულია რეესტრიდან.

იმისათვის, რომ აპლიკაციამ შეძლოს დრაივერის გაშვება, გადაწყვეტის შექმნის შემდეგ, რომელიც შედგება ორი პროექტისგან, აპლიკაციისა და დრაივერისაგან, თქვენ უნდა მოათავსოთ განაცხადის შესრულებადი და დრაივერი იმავე საქაღალდეში და შემდეგ გაუშვათ აპლიკაცია.

დრაივერების გამართვა ძალიან რთულია. OS- ის მუშაობაში შეცდომების შემთხვევაში, ყველაზე ხშირად ის იყინება და საჭიროა გადატვირთვა. ხოლო ჩვენი დრაივერისთვის, გადატვირთვის შემდეგ, ასევე აუცილებელია beeper06 სერვისის ამოღება რეესტრიდან regedit-ის გამოყენებით (HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\), შემდეგ კი ხელახლა გადატვირთვა.

1.2 Windows ვირტუალური მოწყობილობის დრაივერები

ჯერჯერობით, ჩვენ შევიმუშავეთ ბირთვის რეჟიმის დრაივერი, რომელსაც შეუძლია გააკეთოს ის, რაც არ შეიძლება გაკეთდეს მომხმარებლის დონეზე, როგორიცაა I/O პორტებთან მუშაობა. ასეთ დრაივერს ეწოდება ბირთვის დრაივერი, მაგრამ არა მოწყობილობის დრაივერი, რადგან არ ხდება მონაცემების გადაცემა მომხმარებლის პროგრამასა და მოწყობილობას შორის (ბოლოს და ბოლოს, რატომ არის საჭირო დრაივერი ჩვეულებრივ? მომხმარებლის აპლიკაციასა და მოწყობილობას შორის მონაცემთა გაცვლის ორგანიზებისთვის) .

ახლა ჩვენ შევიმუშავებთ მოწყობილობის დრაივერებს, რომლებიც გადასცემენ მონაცემებს მომხმარებლის აპლიკაციასა და მოწყობილობას შორის.

როდესაც აპლიკაციას სჭირდება I/O ოპერაცია, დრაივერი იძახება. ამისათვის აპლიკაციას შეუძლია გასცეს მოთხოვნა მოწყობილობიდან მონაცემების წაკითხვის ან მოწყობილობაში მონაცემების ჩაწერის შესახებ. ხოლო თუ რაიმე სხვა ქმედებაა საჭირო, მაგალითად, პოლინგი ან მოწყობილობის კონტროლი, ან სხვა რამე, მაშინ ე.წ. IOCTL ინტერფეისი (Device In-Out Control).

სწორედ ასეთ შემთხვევას განვიხილავთ ვირტუალური მოწყობილობებისთვის, რადგან უფრო ხშირად რატომ გვჭირდება ვირტუალური მოწყობილობა დრაივერში? რათა მასში გადაიტანოთ მონაცემები, რომლებიც დრაივერმა როგორმე დაამუშავოს (როგორც ეს აპლიკაციაში შეუძლებელია) და შედეგი დააბრუნოს აპლიკაციაში. შეგახსენებთ, რომ ადრე განხილული ბირთვის ჩვეულებრივი დრაივერი არ აიღო არაფერი აპლიკაციიდან და არ დააბრუნა იქ არაფერი, არამედ უბრალოდ გააკეთა ისეთი ქმედებები, რაც აპლიკაციას არ შეეძლო.

როდესაც აპლიკაციას სჭირდება I/O ოპერაცია, დრაივერი იძახება. ამისთვის ე.წ. IOCTL ინტერფეისი (Device In-Out Control).

დარეკვის აპლიკაცია აკეთებს შემდეგს:

1) ფაილის გახსნა და მისი სახელურის მიღება:

GENERIC_READ + GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL

შედეგად, თუ ყველაფერი კარგად წავიდა, ჩვენ ვიღებთ მოწყობილობის სახელურს.

2) სამოქმედო კოდის გაგზავნა მძღოლისთვის (რა უნდა გააკეთოს, მძღოლს შეუძლია მრავალი განსხვავებული მოქმედების განხორციელება):

გამოძახება DeviceIoControl, სახელური, მოქმედების კოდი, შეყვანის ბუფერის მისამართი, შეყვანის ზომა, გამომავალი ბუფერის მისამართი, გამომავალი ზომა, ბუფერის მისამართი ბაიტების რეალური რაოდენობისთვის

3) ფაილის დახურვა და, შესაბამისად, აღწერის გათავისუფლება.

გამოიძახეთ CloseHandle მოწყობილობის სახელური

მონაცემების გადასატანად მოდულები (აპლიკაცია და დრაივერი) უნდა შეთანხმდნენ ურთიერთქმედების პროტოკოლზე (მოქმედების კოდები, ბუფერული სტრუქტურა - შეყვანა და გამომავალი).

იგივე მოქმედების კოდი გამოიყენება როგორც აპლიკაციაში, ასევე დრაივერში.

მოქმედების კოდი აპლიკაციაში და დრაივერში შეიძლება დაიწეროს თექვსმეტობითი ფორმით, ან შეგიძლიათ გამოიყენოთ CTL_CODE მაკრო, როგორც ეს კეთდება ლაბორატორიის მაგალითში. მუშაობა common.inc ფაილში.

მოდით შევხედოთ მოქმედების კოდის ნიმუში ვირტუალური მოწყობილობის დრაივერიდან, რომელიც გამოიყენება ლაბორატორიაში. სახელია IOCTL_GET.

ვირტუალური მოწყობილობის შემთხვევაში, ფაილის დროშა არის 0.

მოწყობილობის ტიპი - FILE_DEVICE_UNKNOWN = 22 სთ

ნებართვები - FILE_READ_ACCESS+FILE_WRITE_ACCESS = 1+2=3=11b

ფუნქციის კოდი არის 800 სთ-დან FFF სთ-მდე. გვაქვს 800 სთ.

ბუფერული მეთოდი - აპლიკაციასა და დრაივერს შორის მონაცემების გადაცემის გზა (სამი შესაძლებელია):

მცირე რაოდენობის მონაცემებისთვის, ჩვეულებრივ გამოიყენება METHOD_BUFFERED (00b) - დამატებითი ბუფერი გამოიყოფა არა გვერდის მეხსიერებაში, რომელიც საკმარისია შეყვანისა და გამომავალი ბუფერისთვის. ამ ბუფერის მისამართი მოთავსებულია IRP-ში AssociatedIrp.SystemBuffer ველში. I/O მენეჯერი ზრუნავს მომხმარებლის ბუფერსა და დამატებით ბუფერს შორის მონაცემების გადაწერის სამუშაოზე.

მონაცემთა პირდაპირი წვდომა (ბუფერის გარეშე) - METHOD_OUT_DIRECT (2) - გამოსასვლელად ან METOD_IN_DIRECT (1) - შეყვანისთვის; ველი IRP-დან - MdlAddress. ეს არის პირდაპირი ზარი - I/O მენეჯერი ათავსებს ფიზიკურ გვერდებს, რომლებიც შეიცავს მომხმარებლის რეჟიმის ბუფერს მეხსიერებაში. ის ქმნის დამხმარე სტრუქტურას MDL (მეხსიერების აღმწერის სია) ჩაწერილი გვერდების აღსაწერად. და მძღოლის დეველოპერი მუშაობს MDL-ით.

წვდომა მომხმარებლის დონის ბუფერით - METHOD_NEITHER(3); ველი IRP-დან - SystemBuffer. I/O მენეჯერი დრაივერს გადასცემს მომხმარებლის რეჟიმის ვირტუალურ მისამართებს. დრაივერში კი მათთან ძალიან ფრთხილად უნდა იყოთ, რადგან ამ შემთხვევაში დრაივერმა უნდა იმუშაოს მხოლოდ დარეკვის თემის კონტექსტში.

როდესაც აპლიკაცია დრაივერს უგზავნის სამოქმედო კოდს, I/O მენეჯერი იწყებს მუშაობას. ის პასუხისმგებელია I/O მოთხოვნის პაკეტის (IRP) გენერირებაზე და დრაივერზე გაგზავნაზე შემდგომი დამუშავებისთვის.

ჩვენ განვიხილავთ 3 ტიპის მოთხოვნას:

IRP_MJ_CREATE - გადაეცემა CreateFile-ზე,

IRP_MJ_DEVICE_CONTROL - გადაეცემა DeviceIoControl-ზე

IPR_MJ_CLOSE - CloseHandle-ზე

IRP პაკეტი შედგება სათაურის და I/O განლაგების სტეკებისგან. I/O მენეჯერი ქმნის I/O სტეკის უჯრედების რაოდენობას, რომელიც ტოლია მოთხოვნის დამუშავებაში ჩართული დრაივერების ფენების რაოდენობას. თითოეულ დრაივერს აქვს წვდომა საკუთარ სტეკის მდებარეობაზე. როდესაც დრაივერი აგზავნის IRP-ს ქვედა დონის დრაივერს, სტეკის მდებარეობის მაჩვენებელი გადაადგილდება ამ დრაივერის მიერ მოთხოვნილ ადგილას. საპირისპიროდ, მოთხოვნის დამუშავების შემდეგ, მაჩვენებელი გადადის ზედა დონის დრაივერის უჯრედში. მაჩვენებლის მიღება ფუნქციის გამოყენებით - IoGetCurrentStackLocation().

თითოეული განაწილების სტეკი შეიცავს მაჩვენებელს DeviceObject-ისა და FileObject-ის მიმართ, რომლისთვისაც მოხდა მოთხოვნა. IRP-ები ყოველთვის ინახება გვერდის გარეშე მეხსიერებაში.

შემდეგი ობიექტები იქმნება და გამოიყენება მძღოლის მუშაობისთვის:

მძღოლის ობიექტი;

მოწყობილობის ობიექტები;

მძღოლის ეტაპები.

1) მძღოლის ობიექტის შექმნა. შექმნილია დრაივერის ჩატვირთვისას მისი გაშვების ეტაპზე. ამ მომენტში იხსნება DriverEntry ფუნქცია და ივსება MajorFunction მასივი, ასევე მოწყობილობის ობიექტის მაჩვენებელი და პირიქით.

მოწყობილობის ობიექტი მოიცავს:

მოწყობილობის ტიპი.

2) შექმენით სიმბოლური ბმული მოწყობილობასთან. იმისათვის, რომ "device" ობიექტი ხელმისაწვდომი გახდეს მომხმარებლის რეჟიმის კოდისთვის, დრაივერმა უნდა შექმნას "\??" კიდევ ერთი ობიექტი - სიმბოლური ბმული (სიმბოლური ბმული). shablon.sys დრაივერი ქმნის სიმბოლურ ბმულს "slshablon" თავის მოწყობილობასთან "devshablon" დირექტორიაში "\??", რომლის მნიშვნელობა არის სტრიქონი "\Device\devshablon".

ამრიგად, უკვე დრაივერის ჩატვირთვისას (ჩვენს შემთხვევაში, OS-ის ჩატვირთვის ეტაპზე), მეხსიერებაში გვაქვს სამი ობიექტი: დრაივერი „\Driver\shablon“, მოწყობილობა „\Device\shablon“ და სიმბოლური ბმული. მოწყობილობა "\??\slshablon".

3) გახსნა. შემდეგი, როდესაც აპლიკაცია იწყება, CreateFile გამოძახებულია. არის მოწყობილობის ბმული. DEVICE_OBJECT მოწყობილობის ობიექტის სტრუქტურიდან მიღებულია ინფორმაცია დრაივერის შესახებ, რომელიც მას ემსახურება. I/O მენეჯერი ქმნის IRP_MJ_CREATE ტიპის I/O მოთხოვნას და აგზავნის დრაივერს. ეს ეუბნება დრაივერს, რომ მომხმარებლის რეჟიმის კოდი ცდილობს მის მოწყობილობაზე წვდომას. თუ მძღოლს წინააღმდეგი არ აქვს, მაშინ ის აბრუნებს წარმატების კოდს. ჩვენს დრაივერს აქვს სპეციალური დისპეტჩერიზაციის პროცედურა, რომელიც პასუხობს ამ IRP - DispatchCreateClose (არსებობს მოწყობილობის გახსნისა და დახურვის კომბინირებული პროცედურა). მასში STATUS_SUCCESS გადაეცემა Io.Status.Status ველში, ხოლო 0 Io.Status.Information-ში, რადგან ამ შემთხვევაში არაფრის გადატანა არ არის საჭირო. მძღოლის ასეთი პასუხი არის სიგნალი ობიექტის მენეჯერისთვის, რომ შექმნას ვირტუალური ფაილი. ეს ქმნის ახალ ჩანაწერს პროცესის სახელურის ცხრილში, ფაილის ობიექტის მითითებით და აბრუნებს ახალ სახელურს მომხმარებლის რეჟიმის კოდში.

თუ ყველაფერი წესრიგშია, მაშინ CreateFile-ის მიერ დაბრუნებულ ფაილის აღწერს ვინახავთ hDevice ცვლადში.

4) I/O ოპერაციები. ახლა ჩვენ შეგვიძლია გავაკონტროლოთ ეს მოწყობილობა DeviceIoControl ფუნქციების გამოძახებით. ვინაიდან მოწყობილობის დრაივერს პრინციპში შეუძლია შეასრულოს მრავალი განსხვავებული დავალება, საჭიროა როგორმე განასხვავოთ მოთხოვნები. სწორედ ამისთვის არის განკუთვნილი მეორე პარამეტრი dwIoControlCode, რომელსაც ეწოდება I/O კონტროლის კოდი, რომელიც აგებულია გარკვეული წესების მიხედვით.

მოწყობილობის სახელურის გამოყენებით, I/O მენეჯერი ამოიღებს ინფორმაციას დრაივერის შესახებ, რომელიც მას ემსახურება, აყალიბებს IRP_MJ_DEVICE_CONTROL ტიპის I/O მოთხოვნის პაკეტს და გაუგზავნის დრაივერს. დრაივერში გამოიძახება შესაბამისი DispatchControl პროცედურა, რომელიც გადასცემს სამოქმედო კოდს და ინფორმაციას შეყვანისა და გამომავალი ბუფერის მისამართებისა და ზომის შესახებ, როგორც პარამეტრებს. ეს ყველაფერი გადაიცემა IRP-ის საშუალებით. პროცედურაში IRP-დან აღებულია საჭირო ინფორმაცია: მოქმედების კოდი, მონაცემთა გადაცემის ბუფერის მისამართი.

DispatchControl პროცედურა ასრულებს აუცილებელ მოქმედებებს, ჩვენს შემთხვევაში IRP პაკეტის მისამართს ESI რეესტრიდან, შემდეგ შედეგს გადასცემს გამომავალი ბუფერის მეშვეობით აპლიკაციას.

წინა პროცედურის მსგავსად, ჩვენ ვაგზავნით დასრულების სტატუსს და დრაივერისგან გადაცემული ბაიტების რაოდენობას IRP-ით.

აპლიკაციაში ეს მონაცემები ფორმატირებული და ნაჩვენებია.

5) დახურვა. როგორც ეს უნდა გაკეთდეს იმ სახელურებით, რომლებიც აღარ არის საჭირო, CloseHandle ფუნქციის გამოძახებით ვხურავთ მოწყობილობის სახელურს.

6) მძღოლის გადმოტვირთვა. წაშალეთ სიმბოლური ბმული და წაშალეთ მოწყობილობის ობიექტი.

კომპლექსი (2) შედგება ორი პროგრამისგან:

აპლიკაცია, რომელიც დრაივერს სთხოვს IRP მისამართს და შემდეგ გამოსცემს ამ მისამართს სტანდარტული ფანჯარა Windows.

Shablon.sys არის მძღოლი.

შაბლონის დრაივერი აკეთებს იმას, რისი გაკეთებაც შეუძლებელია მომხმარებლის დონეზე ამ საქმესგანსაზღვრავს esi რეგისტრის შიგთავსს, როდესაც დრაივერი მუშაობს.

აპლიკაცია იღებს esi შინაარსს გამომავალი ბუფერში, გარდაქმნის მას თექვსმეტობით გამომავალ გამოსავალად და გამოაქვს სტანდარტული Windows ფანჯარაში.

თუ გჭირდებათ ინფორმაციის მიღება CMOS-დან დრაივერში, მაშინ გჭირდებათ:

გაგზავნეთ პორტში 70h CMOS ოფსეტი, რომელიც ჩვენ გვაინტერესებს;

მცირე შეფერხება;

მიიღეთ ინფორმაცია პორტიდან 71h al.

შემდეგ ჩაწერეთ ეს ინფორმაცია გამომავალი ბუფერში.

განაცხადში კი, თქვენ უნდა აიღოთ ინფორმაცია გამომავალი ბუფერიდან, საჭიროების შემთხვევაში, დააკონვერტიროთ და აჩვენოთ იგი, ან გააანალიზოთ და, შედეგიდან გამომდინარე, აჩვენოთ საჭირო ტექსტი სტანდარტულ ფანჯარაში.

ეს ლაბორატორია ვარაუდობს, რომ დრაივერი მუდმივად არის დაინსტალირებული Windows-ზე .inf ფაილის გამოყენებით Control Panel-ის გამოყენებით - აპარატურის ინსტალაცია: დაამატეთ ახალი მოწყობილობა, ხელით ინსტალაცია, აჩვენეთ ყველა მოწყობილობა, დააინსტალირეთ დისკიდან, დაათვალიერეთ .inf ფაილის ასარჩევად (დრაივერი უნდა იყოს იმავე საქაღალდეში).

დრაივერის დაყენების შესამოწმებლად, მართვის პანელში აირჩიეთ System, Hardware, Device Manager.

1.3 არსებულ დრაივერებზე წვდომა მომხმარებლის რეჟიმის აპლიკაციებიდან

აპლიკაციის დრაივერთან მუშაობის ალგორითმი

დრაივერთან მუშაობისთვის, მომხმარებლის რეჟიმის აპლიკაციამ უნდა მიიღოს დრაივერის სახელური. ამ მანიპულატორის მიღება შესაძლებელია CreateFile ან CreateFileA API ფუნქციის გამოყენებით, რომელიც მუშაობს ASCII სიმბოლოებით. შემდეგი, გამოიყენება DeviceIoControl API ფუნქცია, რომელსაც, როგორც ერთ-ერთ პარამეტრს, გადაეცემა IOCTL კოდი. IOCTL კოდი არის საკონტროლო კოდი, რომელიც აცნობებს დრაივერს ოპერაციის შესახებ, რომელსაც ითხოვს აპლიკაცია, პარამეტრების გადაცემის მეთოდი და წვდომის უფლებები, რაც აპლიკაციას სჭირდება ამ ოპერაციის შესასრულებლად. განაცხადის დარეკვის შემდეგ

DeviceIoControl ეგზავნება დრაივერს IRP_MJ_DEVICE_CONTROL-ის მიერ. როდესაც მოთხოვნები დამუშავდება, კონტროლი უბრუნდება აპლიკაციას და აპლიკაცია რჩება მძღოლის პასუხის გასაანალიზებლად და ღია სახელურების დახურვისთვის.

მაგალითი

შემდეგ მაგალითში, მომხმარებლის რეჟიმის აპლიკაცია უგზავნის IOCTL_DISK_GET_PARTITION_INFO_EX მოთხოვნას ფაილური სისტემის დრაივერს, აანალიზებს მიღებულ ინფორმაციას და გამოსცემს მყარი დისკის დანაყოფის ფორმატს.

#შეიცავს

int _tmain(int argc, _TCHAR* argv)

DWORD dwBytes დაბრუნდა = 0;

char cPartitionStyle = (0);

PARTITION_INFORMATION_EX piPartitionInfo;

HANDLE hDevice = CreateFileA(

/*1*/"\\\\.\\c:",

/*2*/GENERIC_READ | GENERIC_WRITE,

/*3*/FILE_SHARE_READ | FILE_SHARE_WRITE,

/*5*/OPEN_EXISTING,

თუ (hმოწყობილობა == INVALID_HANDLE_VALUE)

MessageBoxA(NULL, "CreateFileA შეცდომა!", "Error", 0);

თუ (DeviceIoControl(

/*1*/(HANDLE) hDevice,

/*5*/&piPartitionInfo,

/*6*/sizeof(piPartitionInfo),

/*7*/&dwBytes დაბრუნდა,

if (piPartitionInfo.PartitionStyle == PARTITION_STYLE_MBR)

MessageBoxA(NULL, "PARTITION_STYLE_MBR", "Caption", 0);

else if (piPartitionInfo.PartitionStyle == PARTITION_STYLE_GPT)

MessageBoxA(NULL, "PARTITION_STYLE_GPT", "Caption", 0);

MessageBoxA(NULL, "PARTITION_STYLE_RAW", "Caption", 0);

MessageBoxA(NULL, "DeviceIoControl შეცდომა", "Error", 0);

CloseHandle (hDevice);

მაგალითის გარჩევა

განაცხადის მუშაობისთვის აუცილებელი ცვლადები დეკლარირებულია. PARTITION_INFORMATION_EX არის სტრუქტურა, რომელიც აღწერს ინფორმაციას ამის შესახებ მძიმე განყოფილებადისკი.

typedef struct (

) PARTITION_INFORMATION_EX;

პროგრამის ამ ნაწილში გამოიძახება CreateFileA ფუნქცია სახელურის მისაღებად, რომელიც იწერება hDevice ცვლადში.

DeviceIoControl ფუნქციას სინქრონულად უწოდებენ. მას ეძლევა:

მოწყობილობის აღმწერი;

IOCTL კოდი IOCTL_DISK_GET_PARTITION_INFO_EX;

მაჩვენებელი შეყვანის ბუფერზე, ჩვენს შემთხვევაში NULL;

შეყვანის ბუფერის ზომა;

მაჩვენებელი გამომავალი ბუფერზე;

გამომავალი ბუფერის ზომა;

მითითება ტიპის ცვლადი DWORD, რომელიც შეინახავს დაბრუნებული ბაიტების რაოდენობას;

მაჩვენებელი OVERLAPPED სტრუქტურაზე, რომელიც გამოიყენება ასინქრონული ზარიფუნქციები.

კონტროლის დაბრუნების შემდეგ, ფუნქციის წარმატებით შესრულების შემთხვევაში, ინფორმაცია დანაყოფის შესახებ ინახება PARTITION_INFORMATION_EX სტრუქტურაში.

ხდება ინფორმაციის ანალიზი და გამოტანა. კონტროლის დაბრუნებამდე ოპერაციული სისტემაღია სახელურები შეიძლება დაიხუროს. ეს საშუალებას გაძლევთ გააკეთოთ CloseHandle(__in HANDLE) ფუნქცია. თუ აღწერები არ არის დახურული, მაშინ ოპერაციული სისტემა ამას გააკეთებს თქვენთვის.

2. კურსის მუშაობის დასრულება

2.1 ნაბიჯი 1

ვარჯიში: 1. შექმენით ბირთვის დრაივერი პორტებზე წვდომით, რომელიც ასრულებს მოქმედებებს ვარიანტის მიხედვით და აწვდის ინფორმაციას Debug View ფანჯარაში (ვარიანტის მიხედვით), ისევე როგორც აპლიკაცია, რომელიც უშვებს დრაივერს.

ჩამონათვალი Kurs_test.cpp

#include "stdafx.h"

#include "windows.h"

#include "stdlib.h"

SC_HANDLE hSCManager;

SC_HANDLE hService;

char acDriverPath;

თუ (hSCManager!=0)(

// მოთამაშის რეგისტრაცია SCManager ცხრილში

if (hService!=0)(

// წაშალეთ დრაივერის ჩანაწერი

DeleteService(hService);

CloseServiceHandle(hService);

დაბრუნება 0;

}

Beeper.sys ჩამონათვალი

#შეიცავს

#define TIMER_FREQUENCY 1193167 // 1,193,167 Hz

#define PITCH_C 523 // 523.25 Hz

#define PITCH_Cs 554 // 554.37 Hz

#define PITCH_D 587 // 587.33 Hz

#define PITCH_Ds 622 // 622.25 Hz

#define PITCH_E 659 // 659.25 Hz

#define PITCH_F 698 // 698.46 Hz

#define PITCH_Fs 740 // 739.99 Hz

#define PITCH_G 784 // 783.99 Hz

#define PITCH_Gs 831 // 830.61 Hz

#define PITCH_A 880 // 880.00 Hz

#define PITCH_As 988 // 987.77 Hz

ბათილად DO_DELAY(int time)(

გრძელი i,j;

ამისთვის (i=0; i<=time*0xfffff; i++) {}

}

ბათილად DO_BIG_DELAY(int time)(

DO_DELAY(2*ჯერ);

}

void Xylophone (int nPitch)(

int nTone = TIMER_FREQUENCY/nPitch

_ასმ(

mov al, 10110110b;// ჩაწერეთ საკონტროლო სიტყვა 43 სთ-ზე

out 43h, al;//აუდიო კონტროლის არხი - ლოგიკური წრე ტაიმერის ტონის და პროგრამული უზრუნველყოფით კონტროლირებადი სისტემის პორტის ბიტების გამოყენებით

mov eax, nTone;//გაანგარიშებული სიხშირე ჩაწერეთ 42-ზე

გარეთ 42 სთ, ალ;//უმაღლესი ნაწილი

mov al, ah;//ქვედა ნაწილი

გარეთ 42 სთ, ალ

in al, 61h;//კონტროლის თანმიმდევრობის შეცვლა - ბოლო ბიტების გადაყვანა ერთებად

;// ბიტი 0 - სპიკერის გამოყენების ნებართვა

;// ბიტი 1 - ტაიმერი-2 დინამიკთან დაკავშირების ნებართვა

ან ალ, 00000011b; დინამიკი ჩართულია

გარეთ 61 სთ, ალ

}

DO_DELAY (0x7f);

_ასმ(

ალში, 61 სთ

და ალ, 11111100b; დინამიკი გამორთულია

გარეთ 61 სთ, ალ

}

ქსილოფონი (PITCH_C);

დაბრუნება STATUS_DEVICE_CONFIGURATION_ERROR;

}

2.2 ნაბიჯი 2

შექმენით ვირტუალური მოწყობილობის დრაივერი, რომელიც საშუალებას გაძლევთ შეასრულოთ მოქმედებები, რომლებიც ხელმისაწვდომია მხოლოდ პრივილეგიების ნულოვან დონეზე (ოფციონის მიხედვით), შემდეგ კი შედეგები გადაიტანოთ აპლიკაციას მე-3 პრივილეგიის დონეზე, რათა გამოჩნდეს ისინი ეკრანზე.

აპლიკაციაში ჩვენ ვაჩვენებთ შედეგს სტანდარტულ Windows ფანჯარაში.

ჩამონათვალი shablon.c

#შეიცავს // სხვადასხვა NT განმარტებები

#შეიცავს

UNICODE_STRING g_usDeviceName;

UNICODE_STRING g_usSymbolicLinkName;

void DriverUnload(IN PDRIVER_OBJECT pDriverObject)(

IoDeleteSymbolicLink(&g_usSymbolicLinkName);

IoDeleteDevice(pDriverObject->DeviceObject);

}

NTSTATUS DispatchCreateClose(PDEVICE_OBJECT pDeviceObject, PIRP pIRp)(//პროცესი MJ_CREATE MJ_CLOSE

pIrp->IoStatus.Status = STATUS_SUCCESS;

pIrp->IoStatus.Information = 0;

IoCompleteRequest(pIrp,IO_NO_INCREMENT);

დაბრუნება STATUS_SUCCESS;

}

NTSTATUS DispatchControl(PDEVICE_OBJECT pDeviceObject, PIRP pIrp)(//დამუშავება IRP_MJ_DEVICECONTROL

NTSTATUS სტატუსი;

int regEsi;

// აიღეთ მაჩვენებელი IO_STACK_LOCATION-ზე, მასში IoControlCode-ზე

if (pIrp->Tail.Overlay.CurrentStackLocation->Parameters.DeviceIoControl.IoControlCode ==IOCTL_GET)(

//შეადარეთ მოქმედების კოდი და თუ ეს ჩვენი კლიენტია, მაშინ:

_ასმ(

mov eax,0

მოძრაობა, 10 სთ

გარეთ 70 სთ, ალ

71 საათში

cbw

cwde

mov regEsi,eax

}

// ეს არის ჩვენი ფუნქციონირება - ვიღებთ esi რეესტრის შიგთავსს

// ჩაწერეთ სისტემის ბუფერში

((int)pIrp->AssociatedIrp.SystemBuffer) = regEsi;

pIrp->IoStatus.Information = 4; // და დააყენეთ შედეგის ზომა

სტატუსი = STATUS_SUCCESS;

) სხვა სტატუსი = STATUS_INVALID_DEVICE_REQUEST;

pIrp->IoStatus.Status = სტატუსი;

IoCompleteRequest(pIrp, IO_NO_INCREMENT);

დაბრუნება (სტატუსები);

}

int DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING pusRegistryPath)(

NTSTATUS სტატუსი;

PDEVICE_OBJECT pDeviceObject;

// Unicode სტრიქონების ინიციალიზაცია

RtlInitUnicodeString(&g_usDeviceName, L"\\Device\\DevGet");

RtlInitUnicodeString(&g_usSymbolicLinkName, L"\\??\\sldevGet");

// დრაივერის ობიექტის შევსება - გარკვევით აუხსენით დრაივერს რომელი ფუნქცია რას ამუშავებს

pDriverObject->DriverUnload =

pDriverObject->MajorFunction =

// ლოგიკური ვირტუალური მოწყობილობის ობიექტის შექმნა

სტატუსი = IoCreateDevice(pDriverObject, 0, &g_usDeviceName, FILE_DEVICE_UNKNOWN, 0, FALSE, &pDeviceObject);

if(!NT_SUCCESS(სტატუსი))(დაბრუნების სტატუსი;)

// შექმენით სიმბოლური ბმული მოწყობილობასთან

სტატუსი = IoCreateSymbolicLink(&g_usSymbolicLinkName, &g_usDeviceName);

if(!NT_SUCCESS(სტატუსი))(

IoDeleteDevice(pDeviceObject);

დაბრუნების სტატუსი;

}

დაბრუნების სტატუსი;

}

ჩამონათვალი coursework2.cpp

#include "stdafx.h"

#include "windows.h"

#include "stdlib.h"

#define IOCTL_GET CTL_CODE (FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED, FILE_READ_ACCESS + FILE_WRITE_ACCESS)

int _tmain(int argc, _TCHAR* argv)(

HANDLE hDevice;

BOOL DevControl;

DWORD dwBytes დაბრუნდა;

ქარსტრინგი;

/*

Პარამეტრები:

lpFileName ნულშეწყვეტილი სტრიქონის მისამართი, რომელიც განსაზღვრავს ობიექტის სახელს, რომლის შექმნა ან გახსნა.

dwDesiredAccess ობიექტზე წვდომის ტიპი. ამ პარამეტრს შეუძლია მიიღოს შემდეგი მნიშვნელობების ნებისმიერი კომბინაცია:

ღირებულება: აღწერა:

0 განსაზღვრავს შეკითხვას ობიექტის ხელმისაწვდომობის შესახებ მითითებულ მოწყობილობაზე. აპლიკაციას შეუძლია მოითხოვოს მოწყობილობის ატრიბუტები მასზე წვდომის გარეშე.

GENERIC_READ განსაზღვრავს წაკითხვის წვდომას ობიექტიდან. მონაცემთა წაკითხვა შესაძლებელია ფაილიდან და ფაილის მაჩვენებლის გადატანა შესაძლებელია. შეუთავსეთ GENERIC_WRITE წაკითხვა-ჩაწერის წვდომისთვის.

GENERIC_WRITE განსაზღვრავს ჩაწერის წვდომას ობიექტზე. მონაცემები შეიძლება ჩაიწეროს ფაილში და ფაილის მაჩვენებელი შეიძლება გადავიდეს. შეუთავსეთ GENERIC_READ-ს წაკითხვა-წერის წვდომისთვის.

dwShareMode ობიექტზე გაზიარებული წვდომის რეჟიმი. თუ დაყენებულია ნულზე, ობიექტის გაზიარება შეუძლებელია მრავალ პროგრამას შორის. ობიექტის გახსნის ყველა შემდგომი ოპერაცია წარუმატებელი იქნება, სანამ ობიექტის სახელური არ დაიხურება. ობიექტის გასაზიარებლად გამოიყენეთ შემდეგი მნიშვნელობების კომბინაცია:

ღირებულება: აღწერა:

FILE_SHARE_DELETE საშუალებას აძლევს ოპერაციების თანმიმდევრობას გახსნას ობიექტი და მოითხოვოს წაშლის წვდომა.

FILE_SHARE_READ საშუალებას აძლევს ოპერაციების თანმიმდევრობას გახსნას ობიექტი წაკითხვის წვდომის მოთხოვნით.

FILE_SHARE_WRITE საშუალებას აძლევს ოპერაციების თანმიმდევრობას გახსნას ობიექტი და მოითხოვოს ჩაწერის წვდომა

lpSecurityAttributes SECURITY_ATTRIBUTES სტრუქტურის მისამართი, რომელიც განსაზღვრავს, შეიძლება თუ არა ფუნქციის მიერ დაბრუნებული სახელურის მემკვიდრეობით გადაცემა ბავშვის პროცესის მიერ.

თუ lpSecurityAttributes არის NULL, მაშინ სახელურის მემკვიდრეობა შეუძლებელია.

dwCreationDisposition

ღირებულება: აღწერა:

CREATE_ALWAYS ყოველთვის ქმნის ახალ ფაილს.

თუ ფაილი არსებობს, ფუნქცია გადაწერს ფაილს.

CREATE_NEW ქმნის ახალ ფაილს. ფუნქცია ჩაიშლება, თუ ფაილი არსებობს.

OPEN_ALWAYS ღია ფაილი, ყოველთვის. თუ ფაილი არ არსებობს, ფუნქცია ქმნის მას ისევე, როგორც dwCreationDisposition იქნებოდა CREATE_NEW.

OPEN_EXISTING ხსნის ფაილს. ფუნქცია ჩაიშლება, თუ ფაილი არ არსებობს.

TRUNCATE_EXISTING ხსნის ფაილს და ამცირებს მას ნულოვან ზომამდე. ფუნქცია ჩაიშლება, თუ ფაილი არ არსებობს.

dwFlagsAndAttributes ფაილის დროშები და ატრიბუტები.

როდესაც არსებული ფაილი იხსნება, CreateFile უგულებელყოფს შაბლონის ფაილს.

დაბრუნების მნიშვნელობები:

თუ ფუნქცია წარმატებულია, ღია სახელური უბრუნდება მითითებულ ფაილს. თუ მითითებული ფაილი არსებობს ფუნქციის გამოძახებამდე და dwCreationDisposition არის CREATE_ALWAYS ან OPEN_ALWAYS, GetLastError ზარი დაბრუნდება ERROR_ALREADY_EXISTS-ის შემთხვევაშიც კი, თუ ფუნქცია წარმატებული იქნება. თუ ფაილი არ არსებობს ზარამდე, GetLastError დააბრუნებს 0 (ნულს).

შეცდომის შემთხვევაში, ფუნქცია დაბრუნდება INVALID_HANDLE_VALUE. შეცდომის შესახებ დამატებითი ინფორმაციისთვის დარეკეთ GetLastError.

*/

თუ (hDevice != 0)(

/*

hDevice არის CreateFile-ის მიერ დაბრუნებული სახელური.

dwIocontrolCode არის მნიშვნელობა, რომელიც განსაზღვრავს შესასრულებელ ოპერაციას.

lpInBuffer არის ბუფერის მისამართი, რომელიც შეიცავს dwIoControlCode-ში მითითებული ოპერაციის შესასრულებლად საჭირო მონაცემებს. თუ ოპერაცია არ საჭიროებს მონაცემებს, შეგიძლიათ გაიაროთ NULL.

nInBufferSize არის ბაიტების ზომა ბუფერში, რომელზეც მითითებულია lpInBuffer.

lpOutBuffer არის ბუფერის მისამართი, რომელიც შეივსება გამომავალი მონაცემებით, როდესაც ოპერაცია წარმატებული იქნება. თუ ოპერაციას არ აქვს გამოსავალი, ეს ველი უნდა იყოს NULL.

nOutBufferSiz არის ბუფერის ზომა, რომელზეც მითითებულია lpOutbuffer.

lpBytesReturned - dword ტიპის ცვლადის მისამართი, რომელიც მიიღებს lpOutBuffer-ში შეყვანილი მონაცემების ზომას.

lpOverlapped არის OVERLAPPED სტრუქტურის მისამართი, თუ გსურთ ოპერაცია იყოს ასინქრონული. თუ გსურთ დაელოდოთ ოპერაციის დასრულებას, ჩადეთ NULL ამ ველში.

*/

wsprintf((LPSTR) stroka, "%X", adwOutBuffer);//სტრიქონის ჩაწერა ბუფერში (adwOutBuffer --> stroka)

CloseHandle (hDevice);

დაბრუნება 0;

}

დრაივერის ძირითადი კომპიუტერული პროგრამა

2.3 ნაბიჯი 3

ჩამონათვალი coursework.cpp

#შეიცავს

{

DWORD უსარგებლო;

0, // ფაილის ატრიბუტები

დაბრუნება (FALSE);

}

0, // შეყვანის ბუფერის ზომა

CloseHandle (hDevice);

დაბრუნება (bresult);

}

int main (int argc, char *argv)

{

/*

typedef struct (

PARTITION_STYLE PartitionStyle; // დანაყოფის ფორმატი

LARGE_INTEGER საწყისი ოფსეტი; // განყოფილების დაწყების ოფსეტური

LARGE_INTEGER დანაყოფის სიგრძე; // დანაყოფის ზომა

DWORD PartitionNumber; // განყოფილების ნომერი

BOOLEAN RewritePartition; // თუ დანაყოფი დასაწერია, მაშინ TRUE

კავშირი (

PARTITION_INFORMATION_MBR Mbr; // დამატებითი ინფორმაცია MBR Style განყოფილება

PARTITION_INFORMATION_GPT Gpt; // დამატებითი ინფორმაცია GPT სტილის განყოფილება

};

) PARTITION_INFORMATION_EX;

*/

BOOL bResult;

სისტემა ("პაუზა");

return((int)bResult);

}

2.4 ნაბიჯი 4

1) გააერთიანეთ 1-3 საფეხურებში შემუშავებული ყველა ფუნქცია პროგრამების ერთ ნაკრებში.

საბოლოო კომპლექსი ასე უნდა გამოიყურებოდეს:

- ჩვენი დრაივერი ჩაშენებულია სისტემაში და იტვირთება Windows-ის ჩატვირთვის ფაზაში.

- აპლიკაცია დრაივერს სთხოვს აუცილებელ (ნაბიჯ 2-ში დაყენებული) ინფორმაციას, დრაივერი გადასცემს ამ ინფორმაციას, დინამიკიც ცოტა ხნით ჩაირთვება და მელოდია (ნაბიჯ 1-ში მითითებული) უკრავს. შემდეგ აპლიკაცია უგზავნის მოთხოვნას სისტემაში არსებულ დრაივერს (მე-3 ნაბიჯის ვარიანტის მიხედვით).

2) გასცეს ახსნა-განმარტება, რომელშიც უნდა იყოს აღწერილი ოთხივე ეტაპი, ასევე თეორიული ინფორმაცია თითოეული ეტაპისთვის.

#include "stdafx.h"

#include "windows.h"

#include "stdlib.h"

#define IOCTL_GET CTL_CODE (FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED, FILE_READ_ACCESS + FILE_WRITE_ACCESS)

BOOL GetPartitionNumber(PARTITION_INFORMATION_EX *pex)

{

HANDLE hDevice; // შემოწმებული მოწყობილობის აღმწერი

BOOL bResult; // შედეგის დროშა

DWORD უსარგებლო;

hDevice = CreateFile(TEXT("\\\\.\\c:"), // მოწყობილობა გასახსნელად

GENERIC_READ | GENERIC_WRITE, // მოწყობილობაზე წვდომა

FILE_SHARE_READ |FILE_SHARE_WRITE, // გაზიარების რეჟიმი

NULL, // ნაგულისხმევი უსაფრთხოების ატრიბუტები

OPEN_EXISTING, // მდებარეობა

0, // ფაილის ატრიბუტები

NULL); // არ დააკოპიროთ ფაილის ატრიბუტები

თუ (hDevice == INVALID_HANDLE_VALUE)( // ვერ იხსნება მოწყობილობა

printf("CreateFile() ვერ მოხერხდა!\n");

დაბრუნება (FALSE);

}

bResult = DeviceIoControl(hDevice, // მოთხოვნილი მოწყობილობა

IOCTL_DISK_GET_PARTITION_INFO_EX, // ოპერაცია უნდა შესრულდეს

NULL, // მაჩვენებელი შეყვანის ბუფერზე

0, // შეყვანის ბუფერის ზომა

pex, sizeof(*pex), // გამომავალი ბუფერი

&უსარგებლო, // დაბრუნებული ბაიტების რაოდენობა

(LPOVERLAPPED) NULL); // შეყვანის/გამოსვლის სინქრონიზაცია (I/O)

CloseHandle (hDevice);

დაბრუნება (bresult);

}

int _tmain(int argc, _TCHAR* argv)(

SC_HANDLE hSCManager;

SC_HANDLE hService;

char acDriverPath;

HANDLE hDevice;

BOOL DevControl;

DWORD dwBytes დაბრუნდა;

LPVOID adwInBuffer, adwOutBuffer;

ქარსტრინგი;

PARTITION_INFORMATION_EX pex; // მოწყობილობის სტრუქტურა

BOOL bResult;

hDevice = CreateFile("\\\\.\\sldevGet",GENERIC_READ+GENERIC_WRITE,0, NULL,OPEN_EXISTING, 0, NULL);

თუ (hDevice != 0)(

DevControl = DeviceIoControl(hDevice,IOCTL_GET,&adwInBuffer, sizeof(adwInBuffer),&adwOutBuffer,sizeof(adwOutBuffer), &dwBytesReturned,NULL);

if ((DevControl != 0)&&(dwBytesReturned != 0))(

wsprintf((LPSTR) stroka, "%X", adwOutBuffer);//სტრიქონის ჩაწერა ბუფერში (adwOutBuffer --> stroka)

if (stroka =="00000100") MessageBox(NULL,"Found 1.44 Mb","Yermakov FDD სკანერი",MB_OK);

else MessageBox(NULL,"ვერ მოიძებნა","Yermakov FDD სკანერი",MB_OK);

hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);

თუ (hSCManager!=0)(

GetFullPathName("beeper.sys",sizeof acDriverPath,acDriverPath,NULL);

// მუსიკოსის რეგისტრაცია SCM ცხრილებში

hService=CreateService(hSCManager,"beeper11","Nice Melody Beeper11",

SERVICE_START+წაშლა,SERVICE_KERNEL_DRIVER,SERVICE_DEMAND_START,

SERVICE_ERROR_IGNORE,acDriverPath,NULL,NULL,NULL,NULL,NULL);

if (hService!=0)(

StartService (hService, 0, NULL);

DeleteService(hService);

CloseServiceHandle(hService);

)else MessageBox(NULL,"ვერ დარეგისტრირდება დრაივერი",NULL,MB_ICONSTOP);

CloseServiceHandle (hSCManager);

)else MessageBox(NULL,"ვერ დაკავშირება SCManager-თან",NULL, MB_ICONSTOP);

)else MessageBox(NULL,"საკონტროლო კოდის გაგზავნა შეუძლებელია",NULL,MB_OK);

CloseHandle (hDevice);

)else MessageBox(NULL, "Dev არ არის წარმოდგენილი", NULL, MB_ICONSTOP);

bResult = GetPartitionNumber(&pex);

if (bResult)( printf("PartitionNumber = %d\n", pex.PartitionNumber);

)else( printf ("GetPartitionNumber() ვერ მოხერხდა. შეცდომა %d.\n", GetLastError());)

სისტემა ("პაუზა");

return((int)bResult);

}

3. აპლიკაციის ოპერაცია

სურათი 3.1. დრაივერი მე-2 საფეხურიდან

სურათი 3.2. დრაივერი მე-3 საფეხურიდან

მასპინძლობს Allbest.ru-ზე

მსგავსი დოკუმენტები

ბირთვის რეჟიმის დრაივერსა და მომხმარებლის აპლიკაციას შორის ურთიერთქმედების მექანიზმები: დრაივერის მრავალშრიანი არქიტექტურა, მონაცემთა დამალვის ალგორითმი, დრაივერი-აპლიკაციის ურთიერთქმედება, მომხმარებლის ინტერფეისიფაილზე წვდომის ფილტრაციის პროგრამები.

საკურსო ნაშრომი, დამატებულია 23/06/2009

Windows NT I/O არქიტექტურა. შიდა ორგანიზაცია USB ავტობუსი. WDM დრაივერის მოდელის არსებითი მახასიათებელი. განვითარებული დრაივერის შესვლის წერტილები, კოდის მოთავსება მეხსიერებაში, დრაივერის დაყენება სისტემაში. დრაივერის კოდის დანერგვა C ენაზე.

საკურსო ნაშრომი, დამატებულია 27/09/2014

მომხმარებლის რეჟიმის სტრუქტურა, რომელიც მომხმარებელს სისტემასთან ურთიერთობის საშუალებას აძლევს. ბირთვის რეჟიმის აღწერა, რომელიც უზრუნველყოფს მომხმარებლის აპლიკაციების (პროგრამების) უსაფრთხო შესრულებას. Windows NT ტექნიკის აბსტრაქციის ფენა.

პრეზენტაცია, დამატებულია 23/10/2013

Windows 98 ბირთვი 16-ბიტიანი ბირთვის მოდულების როლი. სიჩქარის პრობლემები. თანამშრომლობითი და პრევენციული მრავალამოცანა. გაუმჯობესებული რესურსების გამოყენება Windows 98-ში. WordArt-ის გამოყენება. MS Outlook Express: შეტყობინებების შექმნა და გაგზავნა.

საკონტროლო სამუშაო, დამატებულია 14/04/2005 წ

ყველა კომპიუტერული მოწყობილობის ერთობლივი მუშაობა და მის რესურსებზე წვდომა. გრაფიკული საოპერაციო ოთახის კონცეფცია და ფუნქციები ვინდოუსის სისტემები. მითითება windows სერვისი. კონტროლი ფაილების სისტემა. Plug and play ტექნოლოგია. GUI Windows.

ტესტი, დამატებულია 01/22/2011

ოპერაციული სისტემის მახასიათებლები. ვინდოუსის განვითარების ისტორია. შედარებითი მახასიათებლები ვინდოუსის ვერსიები. ელემენტები და windows ინსტრუმენტები xp. აპლიკაციის პროგრამები Windows XP-ში. დესკტოპი და ლეპტოპ კომპიუტერებიგაშვებული Windows.

ანგარიში, დამატებულია 16/10/2011

ბირთვის რეჟიმის დრაივერის და საკონტროლო აპლიკაციის გამოყენება სისტემის ძაფების შესაქმნელად. მონაცემთა დამუშავების იმიტაცია და შეფერხებების ორგანიზება. დრაივერის განვითარება C++-ში. სატესტო სტენდის კონფიგურაცია. შეფერხებების შეცვლისა და ტაიმერის მუშაობის სიზუსტე.

საკურსო ნაშრომი, დამატებულია 24/06/2009

Windows ოპერაციული სისტემის შიდა სტრუქტურის შესწავლა. NT არქიტექტურა და ბირთვის სტრუქტურა. ფუნქციების გადართვის მეთოდები ბირთვის რეჟიმში და ბირთვის რეჟიმში. გაიგო მძღოლმა. I/O პაკეტები. Windows სისტემის სტაბილურობისა და უსაფრთხოების შეფასება.

ნაშრომი, დამატებულია 01/02/2014

Firewall-ის კონცეფცია, ტიპები და მოქმედება. ჩაშენებული Windows Firewall-ში. Windows XP SP2, წვდომა firewall-ის პარამეტრებზე Windows XP Service Pack 2. Windows Vista, ტრაფიკი დაშვებულია. Windows 7, აქტიური პროფილის პარამეტრები. პირადი Firewall, ტესტის დონეები.

რეზიუმე, დამატებულია 19/11/2010

გაცნობა ტექნიკური მახასიათებლები პერსონალური კომპიუტერი. ოპერაციული სისტემის ინსტალაცია და ვინდოუსის დრაივერები 7. გზები ფანჯრების გაწმენდა XP Professional SP3. ოპერაციული სისტემის აღდგენის მეთოდები. Შესრულება Microsoft-ის ინსტალაციებიოფისი 2010 წ.

მაიკროსოფტი Windows 10 ოპერაციული სისტემა დიდ ყურადღებას აქცევს უსაფრთხოებას. სისტემის ერთ-ერთი მნიშვნელოვანი ელემენტია " Windows Defender“, მაგრამ ის ვერ უმკლავდება ყველა საფრთხეს. კერძოდ, ბოლო დროს პოპულარობას იძენს Ransomware ვირუსები, რომელთა ყველაზე ცნობილი რეინკარნაციებია მავნე პროგრამაპეტია და. Microsoft-მა Windows 10-ში დანერგა ძირითადი იზოლაციისა და მეხსიერების მთლიანობის ფუნქციები გამოსასყიდის ვირუსებთან საბრძოლველად. ისინი ნაგულისხმევად გამორთულია.

Სარჩევი:

რა არის ბირთვის იზოლაცია და მეხსიერების მთლიანობა

ძირითადი იზოლაცია- ეს არის დამატებითი დაცვის პროცესი, რომელიც უზრუნველყოფილია კომპიუტერული პროცესების ოპერაციული სისტემისა და მოწყობილობისგან დაცვის მეთოდით. ამ ქმედებების გამო, კომპიუტერში ვირუსების შეღწევისას შესაძლებელია ოპერაციული სისტემის მუშაობის შეფერხების თავიდან აცილება.

მეხსიერების მთლიანობაარის ბირთვის იზოლაციის თანმხლები დამცავი ფუნქცია, რომელიც მიზნად ისახავს უცნობი პოტენციურად საშიში პროგრამების მიერ პროცესებზე წვდომის შეზღუდვას. მაღალი დონეუსაფრთხოება.

მნიშვნელოვანია: ბირთვის იზოლაციის ფუნქცია მუშაობს მხოლოდ იმ შემთხვევაში, თუ ამისათვის საკმარისი პირობებია კომპიუტერის აპარატურის მხრიდან. AT BIOS პარამეტრებივირტუალიზაციის ტექნოლოგია უნდა იყოს აქტიური, რის გამოც Windows 10-ზე გაშვებულ კომპიუტერს შეუძლია სხვადასხვა აპლიკაციების გაშვება ვირტუალურ კონტეინერში, რაც ზღუდავს მათ წვდომას სისტემის ძირითადი კომპონენტებისგან.

როგორ ჩართოთ ბირთვის იზოლაცია და მეხსიერების მთლიანობა

Windows 10 ოპერაციული სისტემის პარამეტრები საშუალებას გაძლევთ სრულად მართოთ თქვენი კომპიუტერის უსაფრთხოების ფუნქციები. Windows 10-ის პარამეტრების საშუალებით შეგიძლიათ ჩართოთ ბირთვის იზოლაცია და მეხსიერების მთლიანობა შემდეგნაირად:

როგორც ზემოთ აღინიშნა, თუ კომპიუტერის აპარატურულ კომპონენტს არ აქვს ვირტუალიზაციის მხარდაჭერა, მოცემული ფუნქციაარ იმუშავებს. როდესაც ჩართულია, მომხმარებელი დაინახავს ქვედა მარჯვენა კუთხეში შეტყობინებას „მეხსიერების მთლიანობის უზრუნველყოფა ვერ ხერხდება. შესაძლო შეუთავსებლობა“. თუ ეს შეტყობინება გამოჩნდება, რეკომენდირებულია შეხვიდეთ BIOS-ში და ნახოთ, ჩართულია თუ არა ფუნქცია. უსაფრთხო ჩატვირთვა(ჩატვირთვის რეჟიმი).

როგორ გამორთოთ ბირთვის იზოლაცია და მეხსიერების მთლიანობა

ოპერაციული სისტემის ახალი ფუნქციები, რომლებიც სერიოზულად მოქმედებს მის მუშაობაზე, ყოველთვის ემუქრება პრობლემების გამოწვევას კომპიუტერის მუშაობის დროს. გამონაკლისი არ არის ბირთვის იზოლაციის ფუნქცია. მომხმარებლები, რომლებმაც უკვე სცადეს ის, აღნიშნავენ მაიკროსოფტის ფორუმებზე, რომ პრობლემები ექმნებათ რიგი თამაშებისა და პროგრამების გაშვებისას. ამ პრობლემის გადაჭრის ერთადერთი გზა არის ბირთვის იზოლაციის ფუნქციის და მეხსიერების მთლიანობის გამორთვა. შესაძლოა, მომავალ განახლებებში აპლიკაციის შემქმნელებმა ან Microsoft-მა გამოასწორონ ეს შეუთავსებლობა.

ბირთვის იზოლაციისა და მეხსიერების მთლიანობის გამორთვის სამი გზა არსებობს: