ზოგიერთ აპლიკაციას Windows-ზე გასაშვებად მაღალი პრივილეგიები სჭირდება და ადმინისტრატორის სახით უნდა იყოს გაშვებული. ეს გიბიძგებთ " Მომხმარებლის ანგარიშის კონტროლი(მომხმარებლის ანგარიშის კონტროლი ან UAC), რომელშიც სისტემა ითხოვს თქვენს თანხმობას აპლიკაციის გაშვებაზე.
ბევრ მომხმარებელს არასწორად სჯერა, რომ მომხმარებლის ანგარიშის კონტროლი მხოლოდ უსიამოვნოა და გამორთავს მას. ამავდროულად, კომპიუტერის უსაფრთხოება სერიოზულად დაზარალდა, რადგან. აპლიკაციების გაშვებაზე მომხმარებლის თანხმობა აღარ არის საჭირო და ნებისმიერი მავნე პროგრამაშეუძლია შეუფერხებლად დაიწყოს და იმუშაოს. ანტივირუსის არსებობა ასევე ვერ უზრუნველყოფს კომპიუტერის უსაფრთხოების 100% გარანტიას.
ამ სტატიაში მე გაჩვენებთ, თუ როგორ გაამარტივოთ თქვენი საყვარელი აპლიკაციების ადმინისტრატორის სახით გაშვების პროცესი UAC (სრულად ან ნაწილობრივ) გამორთვისა და უსაფრთხოების დარღვევის გარეშე.
აპლიკაციის ადმინისტრატორად გაშვების რამდენიმე გზა არსებობს:
მაგალითად, ჩვენ გავუშვით ბრძანების სტრიქონი (cmd) როგორც ადმინისტრატორი.
მეთოდი ნომერი 1 (ნორმალური) - გაშვება მაუსის მარჯვენა ღილაკით (გამოსახულია UAC მოთხოვნა)
დააწკაპუნეთ მაუსის მარჯვენა ღილაკით სასურველი აპლიკაციადა აირჩიეთ " Ადმინისტრატორის სახელით გაშვება":
მეთოდი ნომერი 2 - გაშვება გამოყენებით " Ctrl+Shift+Enter" (გამოსახულია UAC მოთხოვნა)
დააწკაპუნეთ დაწყება, საძიებო ზოლში ჩაწერეთ სასურველი ბრძანება და დააწკაპუნეთ Ctrl+Shift+Enter.
მეთოდი ნომერი 3 - დააყენეთ გაშვება ადმინისტრატორად მალსახმობის თვისებებში (გამოსახულია UAC მოთხოვნა)
დააწკაპუნეთ მაუსის მარჯვენა ღილაკით სასურველ მალსახმობზე და აირჩიეთ " Თვისებები".
გადადით ჩანართზე" ლეიბლი", დაჭერა " დამატებით", შეამოწმე " Ადმინისტრატორის სახელით გაშვება":
ან გადადით " თავსებადობა"და შეამოწმეთ ყუთი" გაუშვით ეს პროგრამა ადმინისტრატორის სახით":
მეთოდი #4 - გააადვილეთ არჩეული აპლიკაციების გაშვება სამუშაო გრაფიკის გამოყენებით (UAC მოთხოვნა არ არის ნაჩვენები)
Მნიშვნელოვანი!ეს მეთოდი მუშაობს მხოლოდ ანგარიშებზე, რომლებიც ჯგუფის წევრები არიან. ადმინისტრატორები. ეს არ იმუშავებს რეგულარული მომხმარებლებისთვის, რადგან მათი ჭერი შეზღუდული ნებართვებითაა.
მოდით გადავიდეთ საინტერესო გზა. თუ არის პროგრამა, რომელსაც მუდმივად მართავთ და ის მოდის სანდო პროგრამული უზრუნველყოფის გამყიდველისგან, მაგალითად, ეს windows აპლიკაცია- შეიძლება უფრო ადვილი იყოს დაწყება. შექმენით მალსახმობი ამისთვის სასურველი პროგრამაარ იღებს 2 წუთზე მეტს და ეს საშუალებას მოგცემთ თავიდან აიცილოთ არასაჭირო ქმედებები მომავალში. ჩვენ ვიწყებთ დავალების განრიგი (დაწყება---> ყველა პროგრამა ---> სტანდარტული---> სერვისი---> დავალების განრიგი) და დააჭირეთ " შექმენით დავალება":
დააკონკრეტეთ სახელიახალი ამოცანისთვის და მონიშნეთ ყუთი " იმოძრავეთ უმაღლესი პრივილეგიებით":
გადადით ჩანართზე მოქმედებები, დაჭერა " Შექმნა", შემდეგ ფანჯარაში დააჭირეთ" Მიმოხილვა":
მიუთითეთ სასურველი აპლიკაციის გზა და დააწკაპუნეთ " გახსენით":
სურათის გადიდება
Დაჭერა " კარგი":
დახურეთ გრაფიკი და გააგრძელეთ მალსახმობის შექმნა.
დესკტოპზე მალსახმობის შესაქმნელად, დააწკაპუნეთ მარჯვენა ღილაკით, აირჩიეთ " Შექმნა" ---> "ლეიბლი":
მინდორში ქონების მდებარეობაშეიყვანეთ:
Schtasks / run /tn cmd_admin
სად cmd_admin- ჩვენ მიერ შექმნილი დავალების სახელწოდება. თუ სახელი შეიცავს სივრცეებს, ის უნდა იყოს ჩასმული ბრჭყალებში.
დააყენეთ ეტიკეტის სახელი:
სურათის გადიდება
მალსახმობი შექმნილია და მზად არის გამოსაყენებლად.
ხატის შესაცვლელად - დააწკაპუნეთ მალსახმობზე მარჯვენა ღილაკით, აირჩიეთ " Თვისებები":
გადადით ჩანართზე" ლეიბლი"და დააჭირეთ" ხატის შეცვლა":
"Მიმოხილვა..."
მიუთითეთ პროგრამის გზა:
სურათის გადიდება
აირჩიეთ სასურველი ხატულა და დახურეთ ორივე ფანჯარა " კარგი":
ახლა სასურველი აპლიკაციის ადმინისტრატორად გაშვება ხდება შექმნილ მალსახმობზე ორჯერ დაწკაპუნებით, ხოლო UAC მოთხოვნა არ არის ნაჩვენები და უსაფრთხოება ხელუხლებელი რჩება.
ავტომატიზაციის კომუნალური პროგრამა "მეთოდი No4"
თუ თქვენ გჭირდებათ მალსახმობების შექმნა დიდი რაოდენობით პროგრამებისთვის, მოსახერხებელია გამოიყენოთ კომუნალური პროგრამა.
კომუნალურ პროგრამასთან მუშაობა ორ მარტივ ნაბიჯამდე მოდის:
- ინსტალაცია
- შესრულებადი ფაილის (*.exe, *.bat, *.cmd) გადატანა კომუნალურ მალსახმობზე:
ფოკუსის ავტომატური გადატანა გაშვებულ პროგრამაზე
განრიგისგან აპლიკაციების გაშვების სპეციფიკა არის ის, რომ ფოკუსი არ გადადის ფანჯარაში და, მაგალითად, ბრძანების ბრძანების ხაზში ჩასაწერად, დამატებით უნდა დააჭიროთ ფანჯარას. ეს ქცევა დაგეხმარებათ რუტინული დაგეგმილი ოპერაციების ავტომატიზაციაში, მაგრამ "მეთოდი # 4" ყოველთვის არ არის მოსახერხებელი.
არსებობს რამდენიმე მეთოდი "გვერდის ავლით". ისინი ცოტა განსხვავებულად მუშაობენ, ამიტომ აირჩიე ის, რომელიც საუკეთესოდ ჯდება. პირველი უფრო მოსახერხებელია პროგრამების გასაშვებად, ხოლო მეორე სკრიპტების გასაშვებად.
დავამატეთ დავალების შექმნისას:
დაწყების ბრძანების გამოყენებით
პროგრამა ან სკრიპტი:
არგუმენტები:
/c დაწყება /d "path_to_program" file_name.exe
/c დაწყება /d "C:\Windows\System32\" cmd.exe
NirCmd Utility-ის გამოყენება
პროგრამა ან სკრიპტი:
Path_to_nircmd\nircmd.exe
არგუმენტები:
Exec აჩვენებს "path_to_program\file_name.exe"
Exec აჩვენებს "C:\Windows\System32\cmd.exe"
"Run" დიალოგის გაშვება, როგორც ადმინისტრატორი
დაწყების მსგავსი ბრძანების ხაზიშეგიძლიათ დააკონფიგურიროთ დიალოგური ფანჯრის გაშვება " გაიქეცი", და მასში შეყვანილი ბრძანებები ასევე იმუშავებს როგორც ადმინისტრატორი. ამ მიდგომის მოხერხებულობა იმაში მდგომარეობს, რომ შენახულია ადრე გამოყენებული ბრძანებების სია და თქვენ შეგიძლიათ აირჩიოთ ის, რაც გჭირდებათ სიიდან.
განრიგში დავალების შექმნისას, " შექმენით მოქმედება"მიუთითეთ:
სფეროში" პროგრამა ან სკრიპტი":
Rundll32
სფეროში" დაამატეთ არგუმენტები":
Shell32.dll, #61
ჩამოტვირთეთ უტილიტა, ამოალაგეთ. ჩვენ ვიწყებთ ბრძანების ხაზს, შევიყვანთ სასურველ ბრძანებას, სინტაქსი საკმაოდ მარტივია:
<путь к утилите> <путь к нужному приложению>
გამოჩნდება UAC მოთხოვნა და აპლიკაცია იმუშავებს როგორც ადმინისტრატორი.
Შენიშვნა:Კონტექსტში windows მენიუ 7 არსებობს ფაილის გზის კოპირების ძალიან მოსახერხებელი ფუნქცია: დააჭირე ცვლა, დააწკაპუნეთ ფაილზე მარჯვენა ღილაკით, აირჩიეთ " კოპირება როგორც გზა".
პროგრამების გაშვება მომხმარებლის მიერ ადმინისტრატორის სახით ადმინისტრატორის პაროლის შეყვანის გარეშე
Მნიშვნელოვანი!ეს მეთოდი არასაიმედოა, რადგან შეზღუდული უფლებების მქონე მომხმარებელს საშუალებას აძლევს გაუშვას კოდი სრული უფლებებით. მზაკვრ მომხმარებელს ან მავნე პროგრამას შეუძლია ისარგებლოს ამით და დაარღვიოს სისტემა.
განვიხილოთ კიდევ ერთი საინტერესო პრობლემა: თქვენი ანგარიში Windows შესვლაარის ადმინისტრატორების ჯგუფის წევრი, არის ერთი ან მეტი ანგარიში, რომელიც არის მომხმარებლების ჯგუფის წევრი. მომხმარებელმა უნდა გაუშვას პროგრამა, რომელიც მოითხოვს სიმაღლეს. ჩვეულებრივ ასე გამოიყურება: მომხმარებელი აწკაპუნებს ფაილზე მარჯვენა ღილაკით და ირჩევს "Run as administrator", რომელიც მოგთხოვთ შეიყვანოთ ადმინისტრატორის პაროლი:
რა თქმა უნდა, მომხმარებლებისთვის ადმინისტრატორის პაროლის დარიგება არ არის ყველაზე მეტად კარგი იდეაა. ამის გადასაჭრელად, ჩვენ გამოვიყენებთ ალექსეი კურიაკინის AdmiLink პროგრამას. მისი დახმარებით ადმინისტრატორს შეუძლია შექმნას მალსახმობი მომხმარებლისთვის საჭირო პროგრამის გასაშვებად, ხოლო ადმინისტრატორის პაროლის შეყვანა საჭიროა მხოლოდ 1 ჯერ - მალსახმობის შექმნისას. როდესაც მომხმარებელი იწყებს პროგრამას, პაროლი გადაეცემა დაშიფრული ფორმით.
ეს მეთოდი იმუშავებს, თუ პროგრამის გაშვება შესაძლებელია მხოლოდ ადმინისტრატორის სახით და დეველოპერს არ დაავიწყდა ამ მდგომარეობის დაზუსტება manifest-ში. თუმცა, ჯერ კიდევ არსებობს დიდი რიცხვიძველი პროგრამები ან პროგრამები, რომლებიც შეიძლება გაუშვათ როგორც შიგნით ნორმალური რეჟიმი, და ადმინისტრატორის სახელით (ამ შემთხვევაში, ფუნქციების განსხვავებული ნაკრები იქნება ხელმისაწვდომი). როდესაც ცდილობთ ამ პროგრამის გაშვებას AdmiLink-ის გამოყენებით, ის იწყება ნორმალურ რეჟიმში (ადმინისტრაციული პრივილეგიების გარეშე). ხოლო თუ ცდილობთ მონიშნოთ ველი „მეთოდი ნომერი 3. შენარჩუნებულია ავტორის ორიგინალური სტილი.
გსურთ მისცეთ სტანდარტული ანგარიშის მქონე მომხმარებლებს უფლება გაუშვან აპლიკაციები ადმინისტრაციული პრივილეგიებით UAC ან პაროლის მოთხოვნის გარეშე? მაშინ მე გეტყვით როგორ გააკეთოთ ეს. ჩვენ შევქმნით მალსახმობას ბრძანების გამოყენებით runas / შენახული, რომელიც ინახავს პაროლს. მე აღვნიშნავ, რომ ეს შეიძლება ჩაითვალოს უსაფრთხოების ხვრელად - ჩვეულებრივ მომხმარებელს შეეძლება გამოიყენოს runas / savecred ნებისმიერი ბრძანების შესასრულებლად, როგორც ადმინისტრატორი, პაროლის შეყვანის გარეშე. თუმცა, ზოგიერთ სიტუაციაში ეს შეიძლება იყოს სასარგებლო - მაგალითად, თუ გსურთ, რომ თქვენი შვილი იყოს სტანდარტის მიღმა ანგარიშიშეუძლია აპლიკაციების გაშვება, როგორც ადმინისტრატორი, თქვენ უკითხავად.
ადმინისტრატორის ანგარიშის ჩართვა
პირველი ნაბიჯი არის ჩაშენებული ადმინისტრატორის ანგარიშის ჩართვა, რომელიც ნაგულისხმევად გამორთულია. ასე რომ, დააწკაპუნეთ ბრძანების ხაზის მალსახმობზე მარჯვენა ღილაკით და აირჩიეთ "გაშვება როგორც ადმინისტრატორი".
ბრძანების ხაზის ფანჯარაში, რომელიც იხსნება, გაუშვით შემდეგი ბრძანება:
წმინდა მომხმარებლის ადმინისტრატორი /აქტიური: დიახ
ანგარიში ახლა ჩართულია, თუმცა პაროლის გარეშე. პაროლის დასაყენებლად გახსენით პანელი, აირჩიეთ მომხმარებლის ანგარიშები და ოჯახის უსაფრთხოება კატეგორია და შემდეგ გახსენით მომხმარებლის ანგარიშების მენიუ. შემდეგ დააჭირეთ ბმულს "სხვა ანგარიშის მართვა".
აირჩიეთ ადმინისტრატორის ანგარიში, დააწკაპუნეთ ღილაკზე პაროლის შექმნა და შექმენით პაროლი ადმინისტრატორის ანგარიშისთვის.
შექმენით ეტიკეტი
ახლა ჩვენ შევქმნით მალსახმობს, რომელიც გაუშვებს აპლიკაციას ადმინისტრატორის პრივილეგიებით. დააწკაპუნეთ მაუსის მარჯვენა ღილაკით სამუშაო მაგიდაზე, აირჩიეთ "ახალი" და შემდეგ დააჭირეთ "Shortcut".
ფანჯარაში, რომელიც იხსნება, შეიყვანეთ შემდეგი ბრძანება:
runas / მომხმარებელი: კომპიუტერის სახელი\ადმინისტრატორი /შენახული" C:\Path\To\Program.exe“
გთხოვთ გაითვალისწინოთ, რომ თქვენ უნდა შეცვალოთ კომპიუტერის სახელითქვენი კომპიუტერის სახელზე და C:\Path\To\Program.exeპროგრამის სრულ გზაზე, რომლის გაშვებაც გსურთ. მაგალითად, თუ კომპიუტერის სახელია ლეპტოპი და პროგრამა, რომლის გაშვებაც გსურთ არის Auslogics BoostSpeed, თქვენ უნდა შეიყვანოთ შემდეგი გზა:
runas /მომხმარებელი:ლეპტოპი\ადმინისტრატორი /შენახული "C:\Program Files\Auslogics\Auslogics BoostSpeed\BoostSpeed.exe"
შემდეგ ფანჯარაში შეიყვანეთ მალსახმობის სახელი. სურვილისამებრ, შეგიძლიათ აირჩიოთ ხატულა ახალი მალსახმობისთვის - დააწკაპუნეთ მასზე მარჯვენა ღილაკით და აირჩიეთ "თვისებები".
დიალოგურ ფანჯარაში "თვისებები" დააწკაპუნეთ ღილაკზე "Change icon" და აირჩიეთ შესაბამისი.
პირველად, როდესაც ორჯერ დააწკაპუნებთ მალსახმობზე, მოგეთხოვებათ პაროლი, რომელიც ადრე შექმენით ადმინისტრატორის ანგარიშისთვის.
ეს პაროლი შეინახება - პროგრამის შემდეგ გაშვებისას, აღარ მოგიწევთ მისი შეყვანა.
როგორც ზემოთ აღინიშნა, სტანდარტული ანგარიშების პირობებში მომხმარებლებს შეუძლიათ გაუშვან ნებისმიერი პროგრამა ადმინისტრატორის უფლებებით პაროლის შეყვანის გარეშე (runas /savecred ბრძანების გამოყენებით), ასე რომ გაითვალისწინეთ ეს.
ადმინისტრატორის პაროლი ინახება "Credential Manager" -ში - თუ გსურთ შენახული პაროლის წაშლა, შეგიძლიათ ამის გაკეთება იქიდან.
Კარგ დღეს გისურვებ!
ყველაზე მნიშვნელოვანი არ იყო აღწერილი საკმარისად დეტალურად: როგორ უნდა გაუშვათ ეს კოდი რეალურ აპარატურაზე? როგორ შექმნათ საკუთარი ჩატვირთვის დისკი? ამ სტატიაში ჩვენ დეტალურად ვუპასუხებთ ყველა ამ კითხვას (ნაწილობრივ, ეს კითხვები წინა სტატიაში იყო განხილული, მაგრამ წაკითხვის სიმარტივისთვის თავს უფლებას ვაძლევთ მასალის მცირე დუბლირებას).
ინტერნეტში არის უამრავი აღწერილობა და გაკვეთილი იმის შესახებ, თუ როგორ უნდა დაწეროთ თქვენი საკუთარი მინი-OS, არსებობს ასობით მზა პატარა ჰობი OS. ამ თემაზე ერთ-ერთი ყველაზე ღირსეული რესურსი, რომელიც მინდა გამოვყო, არის პორტალი osdev.org. იმისათვის, რომ შევავსოთ წინა სტატია PCI-ს შესახებ (და შემდგომი სტატიების დაწერის შესაძლებლობა სხვადასხვა ფუნქციების შესახებ, რომლებიც წარმოდგენილია ნებისმიერ თანამედროვე OS-ში), ჩვენ აღვწერთ ნაბიჯ ნაბიჯ ინსტრუქციებიჩამტვირთავი დისკის შექმნაზე ნაცნობი C პროგრამით. ჩვენ ვცდილობდით დამეწერა რაც შეიძლება დეტალურად, რათა ყველაფერი დამოუკიდებლად გაერკვია.
ასე რომ, მიზანი: რაც შეიძლება ნაკლები ძალისხმევით შექმენით თქვენი საკუთარი ჩამტვირთავი USB ფლეშ დრაივი, რომელიც უბრალოდ დაბეჭდავს კლასიკურ "Hello World" კომპიუტერის ეკრანზე.
უფრო ზუსტად რომ ვთქვათ, ჩვენ უნდა "შევიდეთ" დაცულ რეჟიმში გამორთული პეიჯინგით და შეფერხებებით - პროცესორის უმარტივესი რეჟიმი ჩვეულებრივი ქცევით მარტივი კონსოლის პროგრამისთვის. ამ მიზნის მისაღწევად ყველაზე ჭკვიანი გზაა მულტიბუტ ბირთვის შექმნა და მისი ჩატვირთვა პოპულარულის გამოყენებით Grub ჩამტვირთავი. ამ გადაწყვეტის ალტერნატივა არის ჩაწეროთ თქვენი საკუთარი მოცულობის ჩატვირთვის ჩანაწერი (VBR), რომელიც ჩატვირთავს თქვენს წერილობით ჩამტვირთველს (ჩამტვირთველს). ღირსეულ ჩამტვირთველს, მინიმუმ, უნდა შეეძლოს დისკთან მუშაობა, ფაილურ სისტემასთან და ელფის სურათების გარჩევა. ეს ნიშნავს, რომ დაწეროთ ბევრი ასამბლეის კოდი და ბევრი C კოდი. მოკლედ, უფრო ადვილია Grub-ის გამოყენება, რომელმაც უკვე იცის როგორ გააკეთოს ყველაფერი, რაც გჭირდებათ.
დავიწყოთ იმით, რომ შემდგენლებისა და კომუნალური საშუალებების გარკვეული ნაკრებია საჭირო შემდგომი მოქმედებებისთვის. უმარტივესი გზაა გამოიყენოთ რამდენიმე Linux (მაგალითად, Ubuntu), რადგან ის უკვე შეიცავს ყველაფერს, რაც გჭირდებათ ჩამტვირთავი ფლეშ დრაივის შესაქმნელად. თუ მიჩვეული ხართ Windows-ში მუშაობას, მაშინ შეგიძლიათ კონფიგურაცია ვირტუალური ხელსაწყო Linux-ით (Virtual Box ან VMware Workstation-ის გამოყენებით).
თუ იყენებთ ლინუქსი უბუნტუ, მაშინ, პირველ რიგში, თქვენ უნდა დააინსტალიროთ რამდენიმე კომუნალური პროგრამა:
1. გრუბი. ამისათვის გამოიყენეთ ბრძანება:
sudo apt-get install grub
2. კემუ. საჭიროა ყველაფერი სწრაფად მოხდეს, ამისათვის ბრძანება მსგავსია:
sudo apt-get install qemu
ახლა ჩვენი გეგმა ასე გამოიყურება:
1. შექმენით C პროგრამა, რომელიც ბეჭდავს ხაზს ეკრანზე.
2. შეაგროვეთ სურათი მისგან (kernel.bin) miniboot ფორმატში, რათა ის ხელმისაწვდომი იყოს ჩატვირთვისთვის GRUB-ის გამოყენებით.
3. შექმენით ჩატვირთვის დისკის გამოსახულების ფაილი და დააფორმატეთ იგი.
4. დააინსტალირეთ Grub ამ სურათზე.
5. დააკოპირეთ შექმნილი პროგრამა (kernel.bin) დისკზე.
6. ჩაწერეთ სურათი ფიზიკური მედიაან გაუშვით კემუში.
და სისტემის ჩატვირთვის პროცესი:
იმისათვის, რომ ის იმუშაოს, თქვენ უნდა შექმნათ რამდენიმე ფაილი და დირექტორია:
ნაბიჯი 1. სამიზნე პროგრამის (კერნელი) კოდის შექმნა:
ჩვენ ვქმნით kernel.c ფაილს, რომელიც შეიცავს შემდეგ კოდს, რომელიც ბეჭდავს შეტყობინებას ეკრანზე:
#include "printf.h" #include "screen.h" #include "types.h" void main(void) (clear_screen(); printf("\n>>> Hello World!\n"); )
აქ ყველაფერი ნაცნობი და მარტივია. printf და clear_screen ფუნქციების დამატება განხილული იქნება შემდეგში. ამასობაში, ჩვენ უნდა შევავსოთ ეს კოდი ყველა საჭიროებით, რათა ის ჩაიტვირთოს Grub-ის მიერ.
იმისთვის, რომ ბირთვი იყოს მრავალ ჩატვირთვის ფორმატში, შემდეგი სტრუქტურა უნდა იყოს ბირთვის გამოსახულების პირველ 8 კილობაიტში:
თუ ყველა მითითებული პირობა დაკმაყოფილებულია, მაშინ Grub გადასცემს მაჩვენებელს multiboot Information სტრუქტურასა და მნიშვნელობას 0x1BADB002, შესაბამისად, % eax და % ebx რეგისტრების მეშვეობით. Multiboot ინფორმაციის სტრუქტურა შეიცავს სხვადასხვა ინფორმაცია, ჩატვირთული მოდულების ჩამონათვალის და მათი მდებარეობის ჩათვლით, რომელიც შეიძლება საჭირო გახდეს სისტემის შემდგომი ჩატვირთვისთვის.
იმისათვის, რომ პროგრამით ფაილი შეიცავდეს საჭირო ხელმოწერებს, შევქმნათ file loader.s შემდეგი შინაარსით:
ტექსტი .global loader # შესვლის წერტილის ხილვადი ლინკერისთვის # Multiboot header-ის დაყენება - დეტალებისთვის იხილეთ GRUB docs .set FLAGS, 0x0 # ეს არის Multiboot "flag" ველი .set MAGIC, 0x1BADB002 # "magic number" საშუალებას აძლევს ჩამტვირთველს მოძებნოს სათაური .set CHECKSUM, -(MAGIC + FLAGS) # checksum საჭირო .align 4 .long MAGIC .long FLAGS .long CHECKSUM # რეზერვი საწყისი ბირთვის სტეკის სივრცე .set STACKSIZE, 0x4000 # ანუ 16k. . movl %eax, magic # Multiboot ჯადოსნური ნომერი movl %ebx, mbd # Multiboot მონაცემთა სტრუქტურის გამოძახება მთავარი # ზარი C კოდი cli hang: hlt # halt მანქანა უნდა დააბრუნოს kernel jmp hang
მოდით განვიხილოთ კოდი უფრო დეტალურად. ეს კოდი აღებულია wiki.osdev.org/Bare_Bones-დან თითქმის უცვლელი. ვინაიდან gcc გამოიყენება კომპილაციისთვის, გამოიყენება GAS სინტაქსი. მოდით უფრო დეტალურად შევხედოთ რას აკეთებს ეს კოდი.
.ტექსტი
ყველა შემდგომი კოდი მოხვდება შესრულებადი .ტექსტის განყოფილებაში.
.გლობალური ჩამტვირთავი
ჩვენ ვაცხადებთ ჩამტვირთველის სიმბოლოს, რომელიც ჩანს ლინკერისთვის. ეს აუცილებელია, რადგან დამაკავშირებელი გამოიყენებს ჩამტვირთველს, როგორც შესვლის წერტილს.
.set FLAGS, 0x0 # set FLAGS = 0x0 .set MAGIC, 0x1BADB002 # set MAGIC = 0x1BADB002 .set CHECKSUM, -(MAGIC + FLAGS) # set CHECKSUM = -(MAGIC + FLAGSquent 4 align) . .long MAGIC # მოათავსეთ MAGIC მნიშვნელობა მიმდინარე მისამართზე .long FLAGS # მოათავსეთ FLAGS მნიშვნელობა მიმდინარე მისამართზე .long CHECKSUM # მოათავსეთ CHECKSUM მნიშვნელობა მიმდინარე მისამართზე
ეს კოდი ქმნის Multiboot ფორმატის ხელმოწერას. .set დირექტივა აყენებს სიმბოლოს მნიშვნელობას მძიმის მარჯვნივ გამოსახულებაში. .align 4 დირექტივა ასწორებს შემდეგ შინაარსს 4 ბაიტით. .long დირექტივა ინახავს მნიშვნელობას მომდევნო ოთხ ბაიტში.
.set STACKSIZE, 0x4000 # set STACKSIZE = 0x4000 .lcomm stack, STACKSIZE # დაჯავშნე STACKSIZE ბაიტი. სტეკი ეხება range.comm mbd, 4 # რეზერვი 4 ბაიტი mdb ცვლადისთვის COMMON ზონაში .comm magic, 4 # რეზერვი 4 ბაიტი ჯადოსნური ცვლადისთვის COMMON ზონაში
ჩატვირთვის პროცესში, grub არ აყენებს სტეკს და პირველი, რაც ბირთვმა უნდა გააკეთოს, არის სტეკის დაყენება, ამისთვის ვიტოვებთ 0x4000 (16Kb) ბაიტს. .lcomm დირექტივა ინახავს .bss განყოფილებაში მძიმის შემდეგ მითითებულ ბაიტების რაოდენობას. სახელების სტეკი მხოლოდ შედგენილ ფაილში იქნება ხილული. .comm დირექტივა აკეთებს იგივეს, რაც .lcomm, მაგრამ სიმბოლოს სახელი გამოცხადდება გლობალურად. ეს ნიშნავს, რომ C კოდში შემდეგი სტრიქონის ჩაწერით შეგვიძლია მისი გამოყენება.
ექსტერნული მაგია
ახლა კი ბოლო ნაწილი:
ჩამტვირთავი: movl $(stack + STACKSIZE), %esp # ინიციალიზაცია stack movl %eax, magic # ჩაწერა %eax to magic movl %ebx, mbd # ჩაწერა %ebx to mbd ზარის მთავარი # ზარის ძირითადი ფუნქცია cli # გამორთვა შეფერხებები ტექნიკის გათიშვადან : hlt # შეაჩერე პროცესორი შეფერხებამდე jmp გათიშეთ # გადახტომა ლეიბლის დაკიდებაზე
პირველი ინსტრუქცია ინახავს სტეკის ზედა ნაწილის მნიშვნელობას %esp რეესტრში. ვინაიდან სტეკი ქვევით იზრდება, დასტაზე გამოყოფილი დიაპაზონის ბოლოს მისამართი იწერება %esp. შემდეგი ორი ინსტრუქცია ინახავს ადრე რეზერვირებულ 4 ბაიტიან მნიშვნელობებს, რომლებსაც Grub გადასცემს %eax, %ebx რეგისტრებში. შემდეგ გამოიძახება მთავარი ფუნქცია, რომელიც უკვე დაწერილია C-ში. თუ ეს პროცედურა დაბრუნდება, პროცესორი ჩაირთვება.
ნაბიჯი 2. პროგრამისთვის დამატებითი კოდის მომზადება (სისტემის ბიბლიოთეკა):
ვინაიდან მთელი პროგრამა დაწერილია ნულიდან, printf ფუნქცია უნდა დაიწეროს ნულიდან. ამისათვის თქვენ უნდა მოამზადოთ რამდენიმე ფაილი.
მოდით შევქმნათ საერთო და შევიტანოთ საქაღალდე:
mkdir საერთო mkdir მოიცავს
შევქმნათ საერთო\printf.c ფაილი, რომელიც შეიცავს ნაცნობი printf ფუნქციის განხორციელებას. ეს ფაილი შეიძლება მთლიანად იქნას აღებული www.bitvisor.org პროექტიდან. ფაილის გზა bitvisor წყაროებში: core/printf.c. bitvisor-დან კოპირებულ printf.c ფაილში, სამიზნე პროგრამაში გამოსაყენებლად, თქვენ უნდა შეცვალოთ ხაზები:
#include "initfunc.h" #include "printf.h" #include "putchar.h" #include "spinlock.h"
ხაზებისკენ:
#include "types.h" #include "stdarg.h" #include "screen.h"
შემდეგ წაშალეთ printf_init_global ფუნქცია და მისი ყველა მითითება ამ ფაილში:
Static void printf_init_global (void) ( spinlock_init (&printf_lock); ) INITFUNC("global0", printf_init_global);
შემდეგ წაშალეთ printf_lock ცვლადი და ყველა მითითება ამ ფაილში:
სტატიკური spinlock_t printf_lock; ... spinlock_lock (&printf_lock); ... spinlock_unlock (&printf_lock);
printf ფუნქცია იყენებს putchar ფუნქციას, რომელიც ასევე უნდა ჩაიწეროს. ამისათვის შევქმნათ საერთო\screen.c ფაილი შემდეგი შინაარსით:
#include "types.h" #define GREEN 0x2 #define MAX_COL 80 // სვეტების მაქსიმალური რაოდენობა #define MAX_ROW 25 // სტრიქონების მაქსიმალური რაოდენობა #define VRAM_SIZE (MAX_COL*MAX_ROW) // ეკრანის ზომა # მოკლედ" განსაზღვრეთ DEF_VRAM_BASE 0xb8000 // ვიდეო მეხსიერების ნაგულისხმევი ბაზა სტატიკური ხელმოუწერელი char curr_col = 0; სტატიკური ხელმოუწერელი char curr_row = 0; // სიმბოლოს ჩაწერა ეკრანის მიმდინარე მდებარეობაზე #define PUT(c) (((ხელმოუწერელი მოკლე *) (DEF_VRA) \M [(curr_row * MAX_COL) + curr_col] = (მწვანე<< 8) | (c))
// Place a character on next screen position
static void cons_putc(int c)
{
switch (c)
{
case "\t":
do
{
cons_putc(" ");
} while ((curr_col % 8) != 0);
break;
case "\r":
curr_col = 0;
break;
case "\n":
curr_row += 1;
if (curr_row >= MAX_ROW) ( curr_row = 0; ) შესვენება; case "\b": if (curr_col > 0) ( curr_col -= 1; PUT(" "); ) break; ნაგულისხმევი: PUT(c); curr_col += 1; if (curr_col >= MAX_COL) ( curr_col = 0; curr_row += 1; if (curr_row >= MAX_ROW) (curr_row = 0; ) ) ); ) void putchar(int c) ( if (c == "\n") cons_putc ("\r"); cons_putc(c); ) void clear_screen (void) (curr_col = 0; curr_row = 0; int i; for (i = 0; i< VRAM_SIZE; i++)
cons_putc(" ");
curr_col = 0;
curr_row = 0;
}
მითითებული კოდი შეიცავს მარტივ ლოგიკას ეკრანზე სიმბოლოების ტექსტის რეჟიმში დასაბეჭდად. ამ რეჟიმში, ორი ბაიტი გამოიყენება სიმბოლოს დასაწერად (ერთი სიმბოლოს კოდით, მეორე თავისი ატრიბუტებით), რომელიც იწერება პირდაპირ ეკრანზე გამოტანილ ვიდეო მეხსიერებაში და იწყება მისამართიდან 0xB8000. ეკრანის გარჩევადობა არის 80x25 სიმბოლო. სიმბოლო პირდაპირ იბეჭდება PUT მაკროს გამოყენებით.
ახლა მხოლოდ რამდენიმე სათაურის ფაილი აკლია:
1. ფაილი მოიცავს\screen.h. აცხადებს putchar ფუნქციას, რომელიც გამოიყენება printf ფუნქციაში. ფაილის შინაარსი:
#ifndef _SCREEN_H #define _SCREEN_H void clear_screen(void); void putchar(int c); #დაასრულე თუ
2. ფაილი მოიცავს\printf.h. აცხადებს printf ფუნქციას, რომელიც გამოიყენება main-ში. ფაილის შინაარსი:
#ifndef _PRINTF_H #define _PRINTF_H int printf (const char *format, ...); #დაასრულე თუ
3. ფაილი მოიცავს\stdarg.h. აცხადებს ფუნქციებს არგუმენტებზე გამეორებისთვის, რომელთა რაოდენობა წინასწარ უცნობია. მთელი ფაილი აღებულია www.bitvisor.org პროექტიდან. ფაილისკენ მიმავალი გზა bitvisor პროექტის კოდში: include\core\stdarg.h.
4. ფაილი მოიცავს\types.h. აცხადებს NULL და size_t. ფაილის შინაარსი:
#ifndef _TYPES_H #define _TYPES_H #define NULL 0 typedef unsigned int size_t; #დაასრულე თუ
ამრიგად, მოიცავს და საერთო საქაღალდეები შეიცავს სისტემის ბიბლიოთეკის მინიმალურ კოდს, რომელიც ნებისმიერ პროგრამას სჭირდება.
ნაბიჯი 3. ლინკერის სკრიპტირება:
ჩვენ ვქმნით linker.ld ფაილს, რომელსაც ლინკერი გამოიყენებს სამიზნე პროგრამის ფაილის გენერირებისთვის (kernel.bin). ფაილი უნდა შეიცავდეს შემდეგს:
ENTRY (ჩამტვირთავი) LMA = 0x00100000; SECTIONS ( . = LMA; .multiboot ALIGN (0x1000) : (loader.o(.text) ) . ტექსტი ALIGN(0x1000) : ( *(.ტექსტი) ) .rodata ALIGN (0x1000) : ( *(.rodata*) ) .data ALIGN (0x1000) : ( *(.მონაცემები) ) .bss: ( *(COMMON) *( .bss) ) /გადაგდება/ : ( *(. კომენტარი) )
ჩაშენებული ENTRY() ფუნქცია საშუალებას გვაძლევს დავაყენოთ შესვლის წერტილი ჩვენი ბირთვისთვის. სწორედ ამ მისამართზე გადასცემს grub კონტროლს ბირთვის ჩატვირთვის შემდეგ. ლინკერი გამოიყენებს ამ სკრიპტს ბინარული ფაილის შესაქმნელად ELF ფორმატში. ELF ფაილი შედგება სეგმენტებისა და განყოფილებებისგან. სეგმენტების სია შეიცავს პროგრამის სათაურის ცხრილში, სექციების სიას სექციის სათაურის ცხრილში. ლინკერი მუშაობს სექციებით, გამოსახულების ჩამტვირთავი (ჩვენს შემთხვევაში, GRUB) სეგმენტებით. 
როგორც ნახატზე ხედავთ, სეგმენტები შედგება მონაკვეთებისგან. ერთ-ერთი ველი, რომელიც აღწერს განყოფილებას, არის ვირტუალური მისამართი, სადაც განყოფილება უნდა იყოს შესრულების დროს. სინამდვილეში, სეგმენტს აქვს 2 ველი, რომელიც აღწერს მის მდებარეობას: სეგმენტის ვირტუალური მისამართი და სეგმენტის ფიზიკური მისამართი. სეგმენტის ვირტუალური მისამართი არის სეგმენტის პირველი ბაიტის ვირტუალური მისამართი კოდის შესრულების მომენტში, სეგმენტის ფიზიკური მისამართი არის ფიზიკური მისამართი, სადაც უნდა ჩაიტვირთოს სეგმენტი. აპლიკაციის პროგრამებისთვის ეს მისამართები ყოველთვის ერთი და იგივეა. Grub ატვირთავს გამოსახულების სეგმენტებს მათი ფიზიკური მისამართით. ვინაიდან Grub არ აყენებს პეიჯინგის დაყენებას, სეგმენტის ვირტუალური მისამართი უნდა ემთხვეოდეს მის ფიზიკურ მისამართს, რადგან ჩვენს პროგრამაში ვირტუალური მეხსიერებაასევე არ არის კონფიგურირებადი.
სექციები
მიუთითებს, რომ სექციები აღწერილია შემდეგში.
. = LMA;
ეს გამოთქმა ეუბნება ლინკერს, რომ ყველა მომდევნო სექცია არის LMA მისამართის შემდეგ.
გასწორება (0x1000)
ზემოთ მოცემული დირექტივა ნიშნავს, რომ განყოფილება გასწორებულია 0x1000 ბაიტით.
.multiboot ALIGN (0x1000) : (loader.o(.ტექსტი))
ცალკე multiboot განყოფილება, რომელიც მოიცავს .text განყოფილებას loader.o ფაილიდან, მზადდება იმისათვის, რომ მულტიბუტ ფორმატის ხელმოწერა მოხვდეს ბირთვის გამოსახულების პირველ 8 კბ-ში.
.bss: ( *(საერთო) *(.bss) )
*(COMMON) არის ტერიტორია, სადაც მეხსიერება დაცულია .comm და .lcomm ინსტრუქციებით. ვათავსებთ .bss განყოფილებაში.
/გაუქმება/ : ( *(.კომენტარი) )
ყველა განყოფილება, რომელიც მონიშნულია როგორც DISCARD, ამოღებულია სურათიდან. ამ შემთხვევაში ვხსნით .comment განყოფილებას, რომელიც შეიცავს ინფორმაციას ლინკერის ვერსიის შესახებ.
ახლა მოდით შევადგინოთ კოდი ორობით ფაილში შემდეგი ბრძანებებით:
როგორც -o loader.o loader.s gcc -Iinclude -Wall -fno-builtin -nostdinc -nostdlib -o kernel.o -c kernel.c gcc -Iinclude -კედელი -fno-builtin -nostdinc -nostdlib -o printf.o -c common/printf.c gcc -Iinclude -Wall -fno-builtin -nostdinc -nostdlib -o screen.o -c common/screen.c ld -T linker.ld -o kernel.bin kernel.o screen.o printf .ო მტვირთავი.ო
objdump-ის გამოყენებით ვნახოთ, როგორ გამოიყურება ბირთვის სურათი დაკავშირების შემდეგ:
objdump -ph ./kernel.bin
როგორც ხედავთ, სურათზე მოცემული სექციები ემთხვევა იმას, რაც ჩვენ აღვწერეთ ლინკერის სკრიპტში. ლინკერმა ჩამოაყალიბა 3 სეგმენტი აღწერილი მონაკვეთებიდან. პირველი სეგმენტი მოიცავს .multiboot, .text, .rodata სექციებს და აქვს ვირტუალური და ფიზიკური მისამართი 0x00100000. მეორე სეგმენტი შეიცავს .data და .bss სექციებს და მდებარეობს 0x00104000-ზე. ასე რომ, ყველაფერი მზად არის ამ ფაილის ჩასატვირთად Grub-ის გამოყენებით.
ნაბიჯი 4 Grub Boot Loader-ის მომზადება:
შექმენით grub საქაღალდე:
mkdir grub
დააკოპირეთ ამ საქაღალდეში Grub-ის რამდენიმე ფაილი, რომელიც საჭიროა სურათზე მის დასაყენებლად (შემდეგი ფაილები არსებობს, თუ Grub დაინსტალირებულია სისტემაში). ამისათვის თქვენ უნდა შეასრულოთ შემდეგი ბრძანებები:
cp /usr/lib/grub/i386-pc/stage1 ./grub/ cp /usr/lib/grub/i386-pc/stage2 ./grub/ cp /usr/lib/grub/i386-pc/fat_stage1_5 ./grub /
შექმენით grub/menu.lst ფაილი შემდეგი შინაარსით:
ვადა 3 ნაგულისხმევი 0 სათაური mini_os root (hd0,0) ბირთვი /kernel.bin
ნაბიჯი 5: ჩატვირთვის სურათის ავტომატიზაცია და შექმნა:
მშენებლობის პროცესის ავტომატიზაციისთვის, ჩვენ გამოვიყენებთ make utility-ს. ამისათვის ჩვენ შევქმნით მაკიაფილს, რომელიც კომპილირებული იქნება წყარო, შექმენით ბირთვი და შექმენით ჩატვირთვის სურათი. Makefile-ს უნდა ჰქონდეს შემდეგი შინაარსი:CC=gcc CFLAGS=-კედელი -fno-builtin -nostdinc -nostdlib LD=ld OBJFILES=\loader.o\common/printf.o\common/screen.o\kernel.o სურათი: @echo "Hdd.img-ის შექმნა. .." @dd if=/dev/zero of=./hdd.img bs=512 count=16065 1>/dev/null 2>&1 @echo "ჩამტვირთავი პირველი FAT32 დანაყოფის შექმნა..." @losetup /dev/ loop1 ./hdd.img @(echo c; echo u; echo n; echo p; echo 1; echo ; echo; echo a; echo 1; echo t; echo c; echo w;) | fdisk /dev/loop1 1>/dev/null 2>&1 || true @echo "დანაყოფის დამონტაჟება /dev/loop2..." @losetup /dev/loop2 ./hdd.img \ --offset `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk "(ბეჭდვა $3)"\`*512 | bc` \ --sizelimit `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk "(ბეჭდვა $4)"\`*512 | bc` @losetup -d /dev/loop1 @echo "დააფორმეთ დანაყოფი..." @mkdosfs /dev/loop2 @echo "დააკოპირეთ ბირთვი და grub ფაილები დანაყოფზე..." @mkdir -p tempdir @mount /dev/loop2 tempdir @mkdir tempdir/boot @cp -r grub tempdir/boot/ @cp kernel.bin tempdir/ @sleep 1 @umount /dev/loop2 @rm -r tempdir @losetup -d /dev/loop2 @echo "GRUB-ის ინსტალაცია. .." @echo "device (hd0) hdd.img \n \ root (hd0,0) \n \ დაყენება (hd0) \n \ გამოსვლა\n" | grub --batch 1>/dev/null @echo "შესრულებულია!" ყველა: kernel.bin rebuild: გაწმენდა ყველა .s.o: როგორც -o [ელფოსტა დაცულია] $< .c.o: $(CC) -Iinclude $(CFLAGS) -o [ელფოსტა დაცულია]-c $< kernel.bin: $(OBJFILES) $(LD) -T linker.ld -o [ელფოსტა დაცულია]$^ სუფთა: rm -f $(OBJFILES) hdd.img kernel.bin
ფაილი აცხადებს ორ მთავარ სამიზნეს: ყველა, რომელიც ადგენს ბირთვს და გამოსახულება, რომელიც ქმნის ჩატვირთვის დისკს. ყველა სამიზნე, როგორც ჩვეულებრივი makefile, შეიცავს ქვესამიზნეებს .s.o და .c.o, რომლებიც აკომპლექტებენ *.s და *.c ფაილებს ობიექტურ ფაილებად (*.o), ასევე სამიზნეს kernel.bin-ის გენერირებისთვის, რომელიც იძახებს. ადრე შექმნილი სკრიპტის დამაკავშირებელი. ეს სამიზნეები ასრულებენ ზუსტად იგივე ბრძანებებს, როგორც მე-3 ნაბიჯში.
ყველაზე დიდი ინტერესი აქ არის შემოქმედება ჩატვირთვის სურათი hdd.img (სურათის სამიზნე). მოდით განვიხილოთ ეტაპობრივად როგორ ხდება ეს.
dd if=/dev/zero of=./hdd.img bs=512 count=16065 1>/dev/null 2>&1
ეს ბრძანება ქმნის სურათს, რომლითაც შემდგომი მუშაობა განხორციელდება. სექტორების რაოდენობა არ არის არჩეული შემთხვევით: 16065 = 255 * 63. ნაგულისხმევად, fdsik ეპყრობა დისკს ისე, თითქოს მას აქვს CHS გეომეტრია, რომელშიც Headers (H) = 255, Sectors (S) = 63 და ცილინდრები (C) დამოკიდებულია დისკის ზომაზე. ამრიგად, მინიმალური ზომადისკი, რომელზეც fdsik-ს შეუძლია მუშაობა ნაგულისხმევი გეომეტრიის შეცვლის გარეშე, არის 512 * 255 * 63 * 1 = 8225280 ბაიტი, სადაც 512 არის სექტორის ზომა და 1 არის ცილინდრების რაოდენობა.
შემდეგი, დანაყოფის ცხრილი იქმნება:
losttup /dev/loop1 ./hdd.img (echo c; echo u; echo n; echo p; echo 1; echo ; echo ; echo a; echo 1; echo t; echo c; echo w;) | fdisk /dev/loop1 1>/dev/null 2>&1 || მართალია
პირველი ბრძანება ამონტაჟებს hdd.img ფაილს /dev/loop1 ბლოკის მოწყობილობაზე, რაც საშუალებას აძლევს ფაილს განიხილოს როგორც მოწყობილობა. მეორე ბრძანება ქმნის დანაყოფის ცხრილს /dev/loop1 მოწყობილობაზე, რომელიც შეიცავს 1 ძირითადს ჩატვირთვის დანაყოფიდისკი, რომელიც იკავებს მთელ დისკს და იარლიყით FAT32.
შემდეგ ვაფორმატებთ შექმნილ დანაყოფს. ამისათვის თქვენ უნდა დააინსტალიროთ იგი ბლოკის მოწყობილობად და დააფორმატოთ.
losttup /dev/loop2 ./hdd.img \ --offset `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk "(ბეჭდვა $3)"\`*512 | bc` \ --sizelimit `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk "(ბეჭდვა $4)"\`*512 | bc` losetup -d /dev/loop1
პირველი ბრძანება ამაგრებს ადრე შექმნილ დანაყოფს /dev/loop2 მოწყობილობაზე. -offset ოფცია განსაზღვრავს განყოფილების დასაწყისის მისამართს და -sizelimit განყოფილების დასასრულის მისამართს. ორივე ვარიანტი მიიღება fdisk ბრძანების გამოყენებით.
mkdosfs /dev/loop2
mkdosfs უტილიტა აფორმატებს დანაყოფს ფაილების სისტემა FAT32.
ბირთვის უშუალო ასაგებად გამოიყენება ადრე განხილული ბრძანებები კლასიკური makefile სინტაქსში.
ახლა ვნახოთ, როგორ დავაყენოთ GRUB დანაყოფზე:
mkdir -p tempdir # ქმნის დროებით დირექტორიას mount /dev/loop2 tempdir # ამონტაჟებს დანაყოფი mkdir დირექტორიაში tempdir/boot # ქმნის /boot დირექტორიას დანაყოფზე cp -r grub tempdir/boot/ # დააკოპირეთ grub საქაღალდე / ჩატვირთვა cp kernel.bin tempdir / # აკოპირებს ბირთვს დანაყოფის ძირში ძილის 1 # დაელოდეთ Ubuntu-ს umount /dev/loop2 # ამოიღეთ დროებითი საქაღალდე rm -r tempdir # წაშალე დროებითი საქაღალდე losttup -d /dev/loop2 # დანაყოფის ამოღება
ზემოაღნიშნული ბრძანებების შესრულების შემდეგ, სურათი მზად იქნება GRUB-ის დასაყენებლად. შემდეგი ბრძანება აყენებს GRUB-ს hdd.img დისკის სურათის MBR-ში.
echo "device (hd0) hdd.img \n \ root (hd0,0) \n \ setup (hd0) \n \ გამოსვლა\n" | grub --batch 1>/dev/null
ყველაფერი მზად არის ტესტირებისთვის!
ნაბიჯი 6 გაშვება:
კომპილაციისთვის გამოიყენეთ ბრძანება:
გააკეთე ყველაფერი
რის შემდეგაც უნდა გამოჩნდეს kernel.bin ფაილი.
ჩამტვირთავი დისკის სურათის შესაქმნელად გამოიყენეთ ბრძანება:
sudo make image
შედეგად, hdd.img ფაილი უნდა გამოჩნდეს.
ახლა თქვენ შეგიძლიათ ჩატვირთოთ hdd.img დისკის სურათიდან. ამის შემოწმება შეგიძლიათ შემდეგი ბრძანებით:
qemu -hda hdd.img -m 32
ან:
qemu-system-i386 -hda hdd.img 
რეალურ მანქანაზე შესამოწმებლად, თქვენ უნდა ჩართოთ ეს სურათი ფლეშ დრაივში და ჩატვირთოთ მისგან. მაგალითად ეს ბრძანება:
sudo dd if=./hdd.img of=/dev/sdb
შეჯამებით, შეგვიძლია ვთქვათ, რომ განხორციელებული მოქმედებების შედეგად მიიღება წყაროს კოდები და სკრიპტები, რომლებიც საშუალებას გაძლევთ ჩაატაროთ სხვადასხვა ექსპერიმენტები სისტემის პროგრამირების სფეროში. პირველი ნაბიჯი სისტემური სისტემის შექმნისკენ პროგრამული უზრუნველყოფაროგორიცაა ჰიპერვიზორები და ოპერაციული სისტემები.
რა მოხდება, თუ გჭირდებათ პროგრამის გაშვება, მაგრამ არ გსურთ მისი ინსტალაცია? ნულოვანი ინსტალაციის დახმარება!
მილიარდობით ადამიანი მთელ მსოფლიოში იყენებს კომპიუტერს ან ლეპტოპს საოპერაციო ოთახში. Windows სისტემა. ჩვეულებრივ, ჩვენ ვაყენებთ პროგრამებს, რის შემდეგაც ისინი იღებენ თავისუფალი ადგილიდისკზე და გამოყენება ოპერატიული მეხსიერება. ეს ამცირებს კომპიუტერის სიჩქარეს.
დღეს ჩვენ გეტყვით, თუ როგორ შეგიძლიათ გაზარდოთ თქვენი კომპიუტერის მუშაობა და შეამციროთ დატვირთვა მეხსიერებაზე. ამისათვის თქვენ უნდა გაუშვათ საჭირო პროგრამები მათი ინსტალაციის გარეშე.
როგორ გავუშვათ პროგრამა ინსტალაციის გარეშე?
1. ჩამოტვირთეთ Zero Install.
პირველ რიგში, ჩამოტვირთეთ Zero Install პროგრამული უზრუნველყოფა, რომელიც საშუალებას მოგცემთ გაუშვათ პროგრამები თქვენს კომპიუტერში დაინსტალირების გარეშე.
2. დააინსტალირეთ Zero Install.
მას შემდეგ რაც ჩამოტვირთავთ Zero Install, ორჯერ დააწკაპუნეთ ფაილზე დასაინსტალირებლად. შემდეგ გაიქეცი ახალი პროგრამათქვენს კომპიუტერში.
3. დააწკაპუნეთქვისა "კატალოგი".
როგორც კი Zero Install ჩაირთვება კომპიუტერზე ან Windows ლეპტოპი, თქვენ უნდა გადახვიდეთ "კატალოგის" ჩანართზე. აქ დააწკაპუნეთ ღილაკზე "განახლების სია" სიის განახლებისთვის ხელმისაწვდომი პროგრამები.
4. აირჩიეთ პროგრამა გასაშვებად.
დააკვირდით სრული სიახელმისაწვდომი პროგრამები. თუ იპოვნეთ თქვენთვის საჭირო პროგრამა, აირჩიეთ ის და დააჭირეთ "Run". ზოგიერთმა პროგრამამ შეიძლება აირჩიოს Firefox ბრაუზერიან Mozilla-ს გასაშვებად. უბრალოდ დაელოდეთ პროგრამული უზრუნველყოფის სრულად ჩამოტვირთვას და შემდეგ შეგიძლიათ გაუშვათ იგი თქვენს კომპიუტერში ინსტალაციის გარეშე.
შეჯამება
თუ თქვენს კომპიუტერს არ აქვს საკმარისი თავისუფალი მეხსიერება ან ენერგია პროგრამის გასაშვებად, შეგიძლიათ გამოიყენოთ Zero Install. მე ვფიქრობ, რომ ეს არის შესანიშნავი გზა, რათა არ გადაიტვირთოთ თქვენი კომპიუტერი იმ პროგრამებით, რომლებიც ერთდროულად გჭირდებათ.
ასევე, თქვენს კომპიუტერს შეიძლება არ ჰქონდეს საკმარისი ენერგია გარკვეული პროგრამების გასაშვებად, როგორიცაა Eclipse IDE, JetBrains, NetBeans და ა.შ. ეს მართლაც მძიმე პროგრამებია დეველოპერებისთვის, რომლებიც მოიხმარენ ბევრ RAM-ს.
Zero Install დაგეხმარებათ ამ და სხვა მრავალი პროგრამის გაშვებაში თქვენს კომპიუტერში ინსტალაციის გარეშე.
