გსურთ დაუშვათ სტანდარტული ანგარიშის მქონე მომხმარებლებმა განახორციელონ პროგრამები ადმინისტრატორის პრივილეგიით UAC– ს გარეშე ან პაროლის მოთხოვნის გარეშე? შემდეგ გეტყვით, როგორ უნდა გავაკეთოთ. ჩვენ შევქმნით მალსახმობას ბრძანების გამოყენებით runas / savecredრომელიც პაროლს ინახავს. მე აღვნიშნავ, რომ ეს შეიძლება ჩაითვალოს უსაფრთხოების ხვრელად - რიგითი მომხმარებელი შეძლებს გამოიყენოთ Runas / savecred, ადმინისტრატორის სახელით ნებისმიერი ბრძანების შესასრულებლად, პაროლის შეყვანის გარეშე. ამასთან, ზოგიერთ სიტუაციაში ეს გამოსადეგია - მაგალითად, თუ გსურთ, რომ თქვენს შვილს სტანდარტული ანგარიშიდან შეუძლია შეეძლოს პროგრამის ადმინისტრატორი აწარმოოს ადმინისტრაციის ადმინისტრატორის გარეშე.
ადმინისტრაციული ანგარიშის ჩართვა
პირველ რიგში, თქვენ უნდა ჩართოთ ჩამონტაჟებული ადმინისტრატორის ანგარიში, რომელიც გამორთულია. ასე რომ, დააჭირეთ ღილაკს ბრძანების მალსახმობი და აირჩიეთ "აწარმოე როგორც ადმინისტრატორი".
ბრძანების ფანჯარაში, რომელიც იხსნება, გაუშვით შემდეგი ბრძანება:
მომხმარებლების წმინდა ადმინისტრატორი / აქტიური: კი
ანგარიში ახლა ჩართულია, თუმცა პაროლის გარეშე. პაროლის დასადგენად, გახსენით პანელი, შეარჩიეთ მომხმარებელთა ანგარიშები და ოჯახის უსაფრთხოების კატეგორია და შემდეგ გახსენით მომხმარებელთა ანგარიშების მენიუ. შემდეგი, დააჭირეთ ბმულს „სხვა ანგარიშის მართვა“.
შეარჩიეთ ადმინისტრატორის ანგარიში, დააჭირეთ ღილაკს "შექმნა პაროლი" და შექმენით პაროლი ადმინისტრატორის ანგარიშზე.
შექმენით მალსახმობი
ახლა ჩვენ შევქმნით მალსახმობს, რომელიც პროგრამას ადმინისტრატორის პრივილეგიით გამოაქვეყნებს. დააჭირეთ ღილაკს მარჯვენა ღილაკით, აირჩიეთ "შექმნა" და შემდეგ დააჭირეთ "მალსახმობი".
ფანჯარაში, რომელიც იხსნება, შეიყვანეთ შემდეგი ტიპის ბრძანება:
runas / user: გამოთვლის სახელი\\ ადმინისტრატორი / შენახული ” C: \\ ბილიკი \\ To \\ Program.exe“
გთხოვთ გაითვალისწინოთ, რომ შეცვლა გჭირდებათ გამოთვლის სახელი თქვენი კომპიუტერის სახელით და C: \\ ბილიკი \\ To \\ Program.exe პროგრამის სრულ ბილიკზე, რომლის გაშვებაც გსურთ. მაგალითად, თუ კომპიუტერის სახელი არის Laptop, და პროგრამა, რომლის გაშვებაც გსურთ, არის Auslogics BoostSpeed, თქვენ უნდა შეიყვანოთ შემდეგი გზა:
runas / user: Laptop \\ Administrator / savecred “C: \\ პროგრამის ფაილები \\ Auslogics \\ Auslogics BoostSpeed \u200b\u200b\\ BoostSpeed.exe”
შემდეგ ფანჯარაში მიუთითეთ მალსახმობის სახელი. თუ სასურველია, შეგიძლიათ შეარჩიოთ ხატი ახალი მალსახმობისთვის - დააჭირეთ მასზე მარჯვენა ღილაკს და აირჩიეთ "თვისებები".
დიალოგში "თვისებები" დააჭირეთ ღილაკს "შეცვლა ხატი" და შეარჩიეთ შესაბამისი.
როდესაც პირველად დააჭირეთ მალსახმობას, თქვენ მოგეთხოვებათ შეიყვანოთ პაროლი ადმინისტრატორის ანგარიშზე, რომელიც ადრე შექმენით.
ეს პაროლი შეინახება - შემდეგ პროგრამას დაასრულებთ, აღარ გჭირდებათ მისი შეყვანა ისევ.
როგორც ზემოთ აღინიშნა, სტანდარტული ანგარიშების პირობებში, მომხმარებლებს შეუძლიათ აწარმოონ ნებისმიერი პროგრამა ადმინისტრატორის უფლებებით, პაროლის შეყვანის გარეშე (ასლის გამოყენებით / savecred ბრძანების გამოყენებით), ასე რომ გაითვალისწინეთ.
ადმინისტრატორის პაროლი ინახება "სერთიფიკატის მენეჯერში" - თუ გსურთ შეინახოთ შენახული პაროლი, შეგიძლიათ ამის გაკეთება იქიდან.
მშვენიერი დღე გისურვებთ!
ზოგი Windows პროგრამა მოითხოვს ამაღლებულ ნებართვებს და საჭიროა მათი ადმინისტრატორი. შეკითხვა " მომხმარებლის ანგარიშის კონტროლი"(მომხმარებლის ანგარიშის კონტროლი ან Uac), რომელშიც სისტემა ითხოვს თქვენს თანხმობას განაცხადის დაწყების შესახებ.
ბევრი მომხმარებელი არასწორედ მიიჩნევს, რომ "მომხმარებლის ანგარიშის კონტროლი" მხოლოდ მას ერევა და გამორთავს. ამავე დროს, კომპიუტერის უსაფრთხოება სერიოზულად იმოქმედებს. მომხმარებლების თანხმობა განაცხადების წამოწყებაზე აღარ არის საჭირო, და ნებისმიერ მავნე პროგრამას შეუძლია შეუშალოს და გაუშვას ხელი შეუზღუდავად. ანტივირუსის არსებობა ასევე ვერ უზრუნველყოფს 100% კომპიუტერის უსაფრთხოებას.
ამ სტატიაში მე გეტყვით, თუ როგორ უნდა გამარტივდეს ადმინისტრაციის სახელით არჩეული განაცხადების წამოწყების პროცესი UAC- ის გამორთვის გარეშე (მთლიანად ან ნაწილობრივ) და უსაფრთხოების კომპრომისის გარეშე.
პროგრამის, როგორც ადმინისტრატორის, გაშვების რამდენიმე გზა არსებობს:
როგორც მაგალითად, ჩვენ ვიქნებით ბრძანების სტრიქონი (სმდ) ადმინისტრატორის სტატუსით.
მეთოდი ნომერი 1 (ნორმალური) - დაიწყეთ მაუსის მარჯვენა ღილაკით (UAC მოთხოვნა ნაჩვენებია)
მაუსის მარჯვენა ღილაკით სასურველი პროგრამა და აირჩიეთ " იმუშავეთ როგორც ადმინისტრატორი":
მეთოდი ნომერი 2 - დაიწყეთ გამოყენება " Ctrl + Shift + Enter"(UAC მოთხოვნა ნაჩვენებია)
დააჭირეთ დაწყება, საძიებო ზოლში ჩაწერეთ სასურველი ბრძანება და დააჭირეთ ღილაკს Ctrl + Shift + Enter.
მეთოდი 33 - პარამეტრების პარამეტრების ადმინისტრატორად მითითება (UAC მოთხოვნა ნაჩვენებია)
დააჭირეთ ღილაკს სასურველი მალსახმობი და აირჩიეთ " თვისებები".
გადადით " მალსახმობი"დააჭირეთ" სურვილისამებრ"ყუთის შემოწმება" იმუშავეთ როგორც ადმინისტრატორი":
ან წასვლა " თავსებადობა"და შეამოწმეთ ყუთი" განახორციელეთ ეს პროგრამა ადმინისტრატორად":
მეთოდი ნომერი 4 - გაამარტივეთ დაწყებული შერჩეული პროგრამებისთვის დავალების სქემის გამოყენებით (UAC მოთხოვნა არ არის ნაჩვენები)
მნიშვნელოვანია! ეს მეთოდი მხოლოდ ჯგუფში მუშაობს ანგარიშებისთვის. ადმინისტრატორები. At ჩვეულებრივი მომხმარებლები ეს არ იმუშავებს, რადგან მათი უფლებები ჭერზე შეზღუდულია.
ჩვენ მივდივართ ყველაზე საინტერესო გზაზე. თუ არსებობს პროგრამა, რომელსაც მუდმივად აწარმოებთ და ის მიიღება საიმედო პროგრამული უზრუნველყოფის მწარმოებლისგან, მაგალითად, windows პროგრამა - შეგიძლიათ გაამარტივოთ დაწყება. შექმენით მალსახმობი სასურველი პროგრამა 2 წელზე მეტი დრო არ სჭირდება და ეს მომავალში თავიდან აიცილებთ ზედმეტი მოქმედებებისგან. ჩვენ ვიწყებთ დავალების გრაფიკი (დაწყება---> ყველა პროგრამა ---> სტანდარტული---> ოფისი---> სამუშაო გრაფიკი) და დააჭირეთ " დავალების შექმნა":
მიუთითეთ სახელიახალი ამოცანისთვის და შეამოწმეთ ყუთი " შეასრულეთ უმაღლესი უფლებები":
ჩანართზე გადასვლა მოქმედებებიდააჭირეთ " შექმნა", შემდეგ ფანჯარაში დააჭირეთ" მიმოხილვა":
მიუთითეთ სასურველი განაცხადის გზა და დააჭირეთ " გახსნა":
სურათის გაფართოება
დააყენებს " კარგი":
დახურეთ გრაფიკი და გადადეთ მალსახმობების შესაქმნელად.
დესკტოპზე მალსახმობის შესაქმნელად, დააწკაპუნეთ ღილაკით მარჯვნივ, აირჩიეთ " შექმნა" ---> "მალსახმობი":
მინდორში ობიექტის ადგილმდებარეობა შედი:
Schtasks / run / tn cmd_admin
სად cmd_admin - ჩვენ შექმნილ დავალების სახელს. თუ სახელი შეიცავს ადგილებს, მას უნდა დაურთოს ბრჭყალებში.
დააყენეთ ეტიკეტის სახელი:
სურათის გაფართოება
მალსახმობი შეიქმნა და გამოსაყენებელი.
ხატის შესაცვლელად - მალსახმობებით დააწკაპუნეთ კლავიშზე, აირჩიეთ " თვისებები":
გადადით " მალსახმობი"და დააჭირეთ" ხატის შეცვლა":
"მიმოხილვა..."
მიუთითეთ პროგრამის გზა:
სურათის გაფართოება
აირჩიეთ სასურველი ხატი და დახურეთ ორივე ფანჯარა "" კარგი":
ახლა, ადმინისტრატორისთვის სასურველი პროგრამის ამოქმედება ხორციელდება შექმნილ მალსახმზე ორჯერ დაჭერით, ხოლო UAC მოთხოვნა არ არის ნაჩვენები და დაცვა ხელუხლებელი რჩება.
პროგრამა ავტომატიზაციისთვის "მეთოდი ნომერი 4"
იმ შემთხვევაში, თუ თქვენ გჭირდებათ შექმნათ მალსახმობები დიდი რაოდენობით პროგრამებისთვის, მოსახერხებელია კომუნალური გამოიყენოთ.
კომუნალურთან მუშაობა ორ მარტივ ნაბიჯზე გადადის:
- ინსტალაცია
- შესრულებადი ფაილი (* .exe, * .bat, * .cmd) გადაიტანეთ კომერციულ მალსახმზე:
ავტო ფოკუსირება გაშვებულ პროგრამაზე
გრაფიკული პროგრამიდან პროგრამების დაწყების სპეციფიკა არის ის, რომ ფანჯარაზე ფოკუსირება არ არის თარგმნილი და, მაგალითად, ბრძანების აკრეფაზე ბრძანების აკრეფაზე, დამატებით უნდა დააჭიროთ ფანჯარას. ამგვარი ქცევა შეიძლება დაეხმაროს რუტინული დაგეგმილი ოპერაციების ავტომატიზაციას, მაგრამ "მეთოდი 44" -სთვის ეს ყოველთვის არ არის მოსახერხებელი.
გარშემო უამრავი მეთოდია. ისინი ცოტათი განსხვავებულად მუშაობენ, ამიტომ შეარჩიეთ შესაფერისი. პირველი უფრო მოსახერხებელია პროგრამების გაშვებისთვის, ხოლო მეორე - სკრიპტების გაშვებისთვის.
დავალების შექმნისას დაამატეთ:
საწყისი ბრძანების გამოყენებით
პროგრამა ან სცენარი:
არგუმენტები:
/ c დაწყება / დ "program_path" file_name.exe
/ c დაწყება / დ "C: \\ Windows \\ System32 \\" cmd.exe
გამოყენებით NirCmd კომუნალური
პროგრამა ან სცენარი:
Path_k_nircmd \\ nircmd.exe
არგუმენტები:
შეასრულეთ შოუ "program_path \\ file_name.exe"
Exec შოუ "C: \\ Windows \\ System32 \\ cmd.exe"
Run დიალოგის ადმინისტრატორი
ბრძანების ხაზის გაშვების მსგავსი, შეგიძლიათ დააკონფიგურიროთ "" გარბოდა", და მასში შეტანილი ბრძანებები ასევე ამოქმედდება ადმინისტრატორის სახელით. ამ მიდგომის ხელსაყრელია ის, რომ ადრე გამოყენებული ბრძანებების სია არის შენახული, ხოლო სიიდან შეგიძლიათ აირჩიოთ სასურველი.
გრაფიკში ამოცანის შექმნისას, " მოქმედების შექმნა"მიუთითეთ:
მინდორში " პროგრამა ან სცენარი":
რუნდლ32
მინდორში " დაამატეთ არგუმენტები":
Shell32.dll, # 61
ჩამოტვირთეთ კომუნალური პროგრამა, გახსენით ის. ჩვენ ვიყენებთ ბრძანების ხაზს, შეიყვანეთ სასურველი ბრძანება, სინტაქსი საკმაოდ მარტივია:
<путь к утилите> <путь к нужному приложению>
ნაჩვენებია UAC მოთხოვნა და პროგრამა იწყება ადმინისტრატორად.
შენიშვნა: კონტექსტში windows მენიუ ფაილის ბედის კოპირება ძალიან მოსახერხებელი ფუნქციაა: გამართავს ცვლა, დააწკაპუნეთ მარჯვენა ღილაკზე, აირჩიეთ " კოპირება, როგორც ბილიკი".
პროგრამების გაშვება ადმინისტრატორის მიერ პაროლის შეყვანის გარეშე
მნიშვნელოვანია! ეს მეთოდი არასაიმედოა, რადგან ის მომხმარებელს შეზღუდული უფლებებით აძლევს საშუალებას მართოს კოდი სრული უფლებით. Cunning მომხმარებლის ან malware შეუძლია ისარგებლოს ამ და კომპრომისი სისტემის.
მოდით განვიხილოთ კიდევ ერთი საინტერესო ამოცანა: თქვენი ანგარიში windows ჩანაწერი განეკუთვნება ადმინისტრატორთა ჯგუფს, არის ერთი ან რამდენიმე ანგარიშებიშედის მომხმარებელთა ჯგუფში. მომხმარებელს უნდა აწარმოოს პროგრამა, რომელიც მოითხოვს პრივილეგიების ამაღლებას. ჩვეულებრივ, ასე გამოიყურება: მომხმარებელი მარჯვენა ღილაკით დააჭერს ფაილს და ირჩევს "აწარმოებს როგორც ადმინისტრატორი", ხოლო ადმინისტრატორის პაროლზე შესვლის მოთხოვნა ნაჩვენებია:
რა თქმა უნდა, მომხმარებლის ადმინისტრაციული პაროლის მიცემა არ არის კარგი იდეა. ამის გასარკვევად, ჩვენ გამოვიყენებთ ალექსი ალური კურიაკინის AdmiLink კომუნალურ პროგრამას. მისი დახმარებით, ადმინისტრატორს შეუძლია შექმნას მალსახმობი, რომ მომხმარებელმა დაიწყოს აუცილებელი პროგრამა, ხოლო ადმინისტრატორის პაროლში შესვლისას საჭიროა მხოლოდ 1 დრო - მალსახმობის შექმნისას. როდესაც მომხმარებელი იწყებს პროგრამას, პაროლი გადაეცემა დაშიფრული ფორმით.
ეს მეთოდი იმუშავებს იმ შემთხვევაში, თუ პროგრამის დაწყება შესაძლებელია მხოლოდ ადმინისტრატორის სახელით, ხოლო დეველოპერმა არ დაივიწყა ამ მდგომარეობის მითითება მანიფესტში. თუმცა, ის რჩება დიდი რაოდენობით ძველი პროგრამები ან პროგრამები, რომლებიც შეიძლება დაიწყოს როგორც In ნორმალური რეჟიმიდა ადმინისტრატორის სახელით (ამ შემთხვევაში, ფუნქციების სხვადასხვა პაკეტი იქნება შესაძლებელი). როდესაც ცდილობთ ამ პროგრამის გაშვებას AdmiLink გამოყენებით, ის ნორმალურ რეჟიმში იწყება (ადმინისტრაციული შეღავათების გარეშე). და თუ შეეცდებით დააყენოთ პუნქტი "მეთოდი ნომერი 3. ავტორის ორიგინალური სტილი შენახულია.
რა მოხდება, თუ პროგრამის გაშვება გჭირდებათ, მაგრამ მისი ინსტალაცია არ გსურთ? ნულოვანი დაყენება სამაშველო რეჟიმში!
მილიარდობით ადამიანი მთელ მსოფლიოში იყენებს კომპიუტერებს ან ლეპტოპებს ოპერაციულ ოთახში. windows სისტემა. ჩვეულებრივ, ჩვენ ვაყენებთ პროგრამებს, რის შემდეგაც ისინი იღებენ თავისუფალი ადგილი დისკზე და გამოიყენეთ შემთხვევითი წვდომის მეხსიერება. ეს ამცირებს კომპიუტერის სიჩქარეს.
დღეს ჩვენ გეტყვით, თუ როგორ შეგიძლიათ გაზარდოთ კომპიუტერის შესრულება და შეამციროთ მეხსიერების დატვირთვა. ამისათვის თქვენ უნდა აწარმოოთ საჭირო პროგრამები მათი ინსტალაციის გარეშე.
როგორ გავუშვათ პროგრამა ინსტალაციის გარეშე?
1. ჩამოტვირთეთ Zero Install.
პირველი, გადმოწერეთ Zero Install პროგრამა, რომელიც საშუალებას გაძლევთ პროგრამები გაუშვათ, თქვენს კომპიუტერში მათ ინსტალაციის გარეშე.
2. დააინსტალირეთ ნულოვანი ინსტალაცია.
Zero Install– ს \u200b\u200bჩამოტვირთვის შემდეგ დააჭირეთ ორჯერ დააჭირეთ ფაილს მისი ინსტალაციისთვის. შემდეგ გაიქეცი ახალი პროგრამა თქვენს კომპიუტერში.
3. დააჭირეთქვისა "კატალოგი".
როგორც კი ნულოვანი ინსტალაცია დაიწყება კომპიუტერში ან windows ლეპტოპი, უნდა წავიდეთ "კატალოგის" ჩანართზე. აქ დააჭირეთ ღილაკს "განახლების სია", რათა განახლდეთ ხელმისაწვდომი პროგრამების სიაში.
4. შეარჩიეთ პროგრამა გასაშვებად.
კარგად დააკვირდით სრული სია ხელმისაწვდომი პროგრამები. თუ თქვენთვის საჭირო პროგრამა იპოვნეთ, შეარჩიეთ იგი და დააჭირეთ ღილაკს "აწარმოებს". ზოგიერთი პროგრამა შეიძლება აირჩიოს firefox ბრაუზერი ან Mozilla გასაშვებად. უბრალოდ დაელოდეთ სრულ ჩამოტვირთვად. პროგრამაამის შემდეგ შეგიძლიათ თქვენი კომპიუტერის გაშვება ინსტალაციის გარეშე.
შეჯამება
თუ თქვენს კომპიუტერს არ აქვს საკმარისი უფასო მეხსიერება ან პროგრამა პროგრამის გასაშვებად, შეგიძლიათ გამოიყენოთ Zero Install. მე ვფიქრობ, რომ ეს შესანიშნავი მეთოდია იმისათვის, რომ არ გამოიყენოთ თქვენი კომპიუტერი ერთ დროს საჭირო პროგრამებით.
ასევე, თქვენს კომპიუტერს შეიძლება არ ჰქონდეს საკმარისი ძალა გარკვეული პროგრამების განსახორციელებლად, მაგალითად, Eclipse IDE, JetBrains, NetBeans და ა.შ. ეს ნამდვილად მძიმე პროგრამებია დეველოპერებისთვის, რომლებიც მოიხმარენ დიდ რაოდენობას ოპერატიული მეხსიერება.
ნულოვანი ინსტალაცია ხელს შეუწყობს ამ და სხვა მრავალი პროგრამების ამოქმედებას კომპიუტერში მათი ინსტალაციის გარეშე.
ყველაზე მნიშვნელოვანი რამ არ იყო აღწერილი საკმარისად დეტალებში: როგორ გავუშვათ ეს კოდი რეალურ აპარატზე? როგორ შექმნათ საკუთარი ჩატვირთვის დისკი? ამ სტატიაში, ჩვენ ყველა ამ კითხვას დეტალურად გავცემთ პასუხს (ეს კითხვები წინა სტატიაში ნაწილობრივ იყო განხილული, მაგრამ კითხვის მოხერხებულობისთვის ჩვენ თავს ვუშვებთ მასალის მცირე დუბლირებას).
ინტერნეტში უამრავი აღწერილობა და გაკვეთილია იმის შესახებ, თუ როგორ უნდა დაწეროთ საკუთარი მინი – ოპერაცია, თუნდაც ასობით მზა პატარა ჰობი OS. ამ თემაზე ერთ-ერთი ყველაზე ღირებული რესურსი, რომელსაც მინდა აღვნიშნო, არის osdev.org პორტალი. PCI- ს შესახებ წინა სტატიის შესავსებად (და შემდგომი სტატიების დაწერის შესაძლებლობა სხვადასხვა ფუნქციების შესახებ, რომლებიც წარმოდგენილია ნებისმიერ თანამედროვე ოპერაციულ სისტემაში), ჩვენ აღწერს ეტაპობრივი ინსტრუქციები ჩოხის დისკის ჩამოსაყალიბებლად ჩვეულებრივი პროგრამით C.- ში. ჩვენ შევეცადეთ მაქსიმალურად დაწერეთ ეს ყველაფერი, რომ ეს ყველაფერი საკუთარი თავის საშუალებით გამოგვექვეყნა.
ამრიგად, მიზანი: რაც შეიძლება ნაკლები ძალისხმევა დახარჯეთ, შექმენით თქვენი საკუთარი bootable USB flash drive, რომელიც უბრალოდ ბეჭდავს კლასიკურ "Hello World" კომპიუტერის ეკრანზე.
უფრო ზუსტად რომ ვთქვათ, ჩვენ უნდა შევიტანოთ დაცულ რეჟიმში ინვალიდი გვერდის მისამართით და შეფერხებით - მარტივი პროცესორის რეჟიმში ჩვეულებრივი ქცევის მარტივი რეჟიმში. ამ მიზნის მისაღწევად ყველაზე გონივრული გზაა ბირთვის აგება, რომელიც მხარს უჭერს მულტიბუდის ფორმატს და ჩატვირთვას იგი პოპულაციის გამოყენებით boot loader grub. ამ გადაწყვეტის ალტერნატივაა თქვენი საკუთარი მოცულობის ჩამტვირთავის ჩანაწერის ჩაწერა (VBR), რომელიც ატვირთავს თქვენს წერილობით bootloader (loader). ყოველ შემთხვევაში, ღირსეულმა ჩატვირთვისას უნდა შეეძლოს დისკზე მუშაობა, ფაილური სისტემით და პალპური ელფების გამოსახულებებით. ეს ნიშნავს, რომ თქვენ უნდა დაწეროთ მრავალი ასამბლეის კოდი და ბევრი C კოდი. მოკლედ რომ ვთქვათ, უფრო ადვილია გამოიყენოთ Grub, რომელმაც უკვე იცის, თუ როგორ უნდა გააკეთოს ყველაფერი საჭირო.
დასაწყისისთვის, შემდგენლების და კომუნალური პროგრამების გარკვეული ნაკრები საჭიროა შემდგომი მოქმედებებისთვის. უმარტივეს გზას წარმოადგენს Linux– ის გარკვეული სახის გამოყენება (მაგალითად, Ubuntu), რადგან ის უკვე შეიცავს ყველაფერს, რაც თქვენ გჭირდებათ ბოთიანი დისკის შესაქმნელად. თუ Windows- ში მუშაობთ მიჩვეული, შეგიძლიათ კონფიგურაცია გაუკეთოთ ვირუსულ კომპიუტერს Linux– ით (ვირტუალური ყუთის ან VMware Workstation– ის გამოყენებით).
თუ იყენებთ Linux Ubuntuპირველ რიგში, თქვენ უნდა დააინსტალიროთ რამდენიმე კომუნალური პროგრამა:
1. გრუბი. ამისათვის გამოიყენეთ ბრძანება:
Sudo apt-install install grub
2. ქემუ. საჭიროა ყველაფრის სწრაფად გამოცდა და გამოსწორება (ბმული debugger- ის შესახებ სტატიის ბმული), ამისათვის ბრძანება მსგავსია:
Sudo apt-get install qemu
ახლა ჩვენი გეგმა ასე გამოიყურება:
1. შექმენით C პროგრამა, რომელიც ბეჭდავს ხაზს ეკრანზე.
2. შეადგინეთ ეს სურათი (kernel.bin) მიკროავტობუსის ფორმატით, ისე რომ ის ჩამოტვირთვა შესაძლებელია GRUB.
3. შექმენით boot დისკის სურათის ფაილი და დააფორმატეთ იგი.
4. დააინსტალირეთ Grub ამ სურათზე.
5. დააკოპირეთ შექმნილი პროგრამა (kernel.bin) დისკზე.
6. დაწვით სურათი ფიზიკური მედია ან გაუშვი მას qemu- ში.
და სისტემის ჩატვირთვის პროცესი:
იმისათვის, რომ ის მუშაობდეს, თქვენ უნდა შექმნათ რამდენიმე ფაილი და დირექტორია:
ნაბიჯი 1. მიზნობრივი პროგრამის (ბირთვის) კოდის შექმნა:
შექმენით kernel.c ფაილი, რომელიც შეიცავს შემდეგ კოდს, რომელიც ბეჭდავს შეტყობინებას ეკრანზე:
#include "printf.h" #include "screen.h" #include "types.h" ძალადაკარგული ძირითადი (ძალადაკარგულად) (clear_screen (); printf ("n \u003e\u003e\u003e Hello World! n");)
აქ ყველაფერი ნაცნობი და მარტივია. Printf და cle_screen ფუნქციების დამატება მოგვიანებით იქნება განხილული. იმავდროულად, თქვენ უნდა შეავსოთ ეს კოდი ყველაფრისთვის საჭირო, რომ ის დატვირთული იყოს გრუბის მიერ.
იმისთვის, რომ ბირთვი მრავალფუნქციურ ფორმატში იყოს, თქვენ გჭირდებათ შემდეგი სტრუქტურა ბირთვის გამოსახულების პირველ 8 კილობიტში:
თუ ყველა ეს პირობა დაკმაყოფილებულია, მაშინ Grub გადის% eax და% ebx აფიქსირებს მაჩვენებელს მულტიმედიანი ინფორმაციის სტრუქტურაში და შესაბამისად 0x1BADB002 მნიშვნელობას. მრავალმხრივი ინფორმაციის სტრუქტურა შეიცავს სხვადასხვა ინფორმაციადატვირთული მოდულების ჩამონათვალის ჩათვლით, მათი ადგილმდებარეობის ჩათვლით, რაც შეიძლება საჭირო გახდეს სისტემის შემდგომი დატვირთვისთვის.
იმისათვის, რომ პროგრამულმა ფაილმა შეიტანოს საჭირო ხელმოწერები, შექმენით loader.s ფაილი შემდეგი შინაარსით:
ტექსტი .გლობალური მტვირთავი # შესასვლელი წერტილი ხილულია ლინკერისთვის # მრავალფუნქციური თავსართის დასაყენებლად - იხილეთ GRUB დოკუმენტები დეტალებისთვის .set FLAGS, 0x0 # ეს არის მრავალფუნქციური "დროშის" ველი .დაყენება MAGIC, 0x1BADB002 # "ჯადოსნური ნომერი" საშუალებას გაძლევთ მოძებნოთ header .set CHECKSUM, - (MAGIC + FLAGS) # ჩეკი საჭირო .სწორედ 4. გრძელი MAGIC. გრძელი FLAGS. გრძელი CHECKSUM # ნაკრძალის საწყისი ბირთვის დასტის ადგილი .set STACKSIZE, 0x4000 # ეს არის, 16k. .lcomm დასტის, STACKSIZE # სარეზერვო 16k დასტის .comm mbd, 4 # ჩვენ გამოვიყენებთ ამ kmain .comm Magic, 4 # ჩვენ გამოვიყენებთ ამ კაუზერის loader: movl $ (stack + STACKSIZE),% esp # დააყენეთ დასტის movl% eax, Magic # Multiboot ჯადოსნური ნომერი movl% ebx, mbd # მონაცემთა მრავალ სტრუქტურა დარეკეთ მთავარ # ზარის C კოდი
განვიხილოთ კოდი უფრო დეტალურად. ეს კოდი, თითქმის უცვლელი, აღებულია ვიკიდან .osdev.org/Bare_Bones. მას შემდეგ, რაც gcc გამოიყენება კომპილაციისთვის, გამოიყენება GAS სინტაქსი. მოდით უფრო დეტალურად განვიხილოთ რას აკეთებს ეს კოდი.
ყველა შემდგომი კოდი მოხვდება შესრულებულ განყოფილებაში .text.
გლობალური მტვირთავი
ჩვენ ვაცხადებთ ამტვირთავს სიმბოლოს, რომელიც ჩანს ლინკზე. ეს საჭიროა მას შემდეგ, რაც ბმულები გამოიყენებს loader- ს შესასვლელ წერტილად.
დააყენეთ FLAGS, 0x0 # მიანიჭეთ FLAGS \u003d 0x0 .set MAGIC, 0x1BADB002 # მიანიჭეთ MAGIC \u003d 0x1BADB002 .set CHECKSUM, - (MAGIC + FLAGS) # დაავალეთ CHECKSUM \u003d - (MAGIC + FLAGS). გრძელი MAGIC # ადგილი მიმდინარე მნიშვნელობა MAGIC. გრძელი FLAGS # ადგილი მიმდინარე ღირებულება FLAGS. გრძელი CHECKSUM # ადგილი მიმდინარე ღირებულება CHECKSUM
ეს კოდი ქმნის Multiboot ფორმატის ხელმოწერას. .Set დირექტივა ასახავს პერსონაჟის მნიშვნელობას და გამონათქვამს მარჯვნივ მძიმით. .Align 4 დირექტივა უერთდება შემდგომ შინაარსს 4 ბაიტს. The.long დირექტივა ინახავს მნიშვნელობას ოთხ მომდევნო ბაიტიში.
დააყენეთ STACKSIZE, 0x4000 # დაავალეთ STACKSIZE \u003d 0x4000 .lcomm დასტის, STACKSIZE # სარეზერვო STACKSIZE ბაიტი. stack ეხება range.comm mbd, 4 # სარეზერვო 4 ბაიტს mdb ცვლადისთვის COMMON- ის არეალში.
ჩატვირთვის პროცესის დროს გრუბი არ ახდენს დასტის კონფიგურაციას და პირველი რაც ბირთვის უნდა გააკეთოს დასტის კონფიგურაციაა, ამისათვის ჩვენ ვიტოვებთ 0x4000 (16Kb) ბაიტს. .Lcomm დირექტივის რეზერვები .bss განყოფილებაში ათობითი წერტილების შემდეგ მითითებული ბაიტი. სახელის დასტა მხოლოდ ჩანს შედგენილ ფაილში. .Comm დირექტივა იგივეა, რაც .com, მაგრამ სიმბოლოს სახელი გამოცხადდება გლობალურად. ეს ნიშნავს, რომ შემდეგი სტრიქონის C კოდში ჩაწერით, მისი გამოყენება შეგვიძლია.
extern int Magic
ახლა კი ბოლო ნაწილი:
მტვირთავი: movl $ (stack + STACKSIZE),% esp # საწყისიზაცია stack movl% eax, Magic # ჩაწერა% eax to magy მისამართი movl% ebx, mbd # ჩაწერის% ebx to mbd ზარის მთავარ # ზარის მთავარ cli ფუნქციას # გათიშეთ აპარატურა გათიშეთ: hlt # გაჩერების პროცესორი სანამ შეფერხება მოხდება jmp გათიშეთ # გადახტომა ეტიკეტის დასაკიდებლად
პირველი ინსტრუქცია ინახავს დასტის ზედა მნიშვნელობას% esp რეესტრში. როგორც დასტის იზრდება, დასტისათვის გამოყოფილი დიაპაზონის ბოლოს მისამართი იწერება% esp. ორი შემდეგი ინსტრუქცია ინახავს ადრე დაცულ რიგებში 4 ბაიტი იმ მნიშვნელობებს, რომელსაც Grub გადის% eax,% ebx- ის რეგისტრებში. შემდეგ ეწოდება მთავარ ფუნქციას, რომელიც უკვე წერია C- ში. თუ ამ პროცედურიდან დაბრუნდებით, პროცესორი გამოდის.
ნაბიჯი 2. პროგრამისთვის დამატებითი კოდის მომზადება (სისტემის ბიბლიოთეკა):
რადგან მთელი პროგრამა ნულიდან არის დაწერილი, ბეჭდვის ფუნქცია უნდა დაიწეროს ნულიდან. ამისათვის მოამზადეთ რამდენიმე ფაილი.
შექმენით საერთო და მოიცავს საქაღალდე:
Mkdir ჩვეულებრივი mddir მოიცავს
შექმენით commonprintf.c ფაილი, რომელიც შეიცავს ნაცნობ printf ფუნქციის შესრულებას. ამ მთელი ფაილის აღება შესაძლებელია www.bitvisor.org/ პროექტისგან. ბილიტორის წყაროებში ფაილის ბილიკი: ბირთვი / printf.c. Bititor- ის მიერ გადაწერილი printf.c ფაილში, სამიზნე პროგრამაში გამოსაყენებლად, თქვენ უნდა შეცვალოთ ხაზები:
#include "initfunc.h" #include "printf.h" #include "putchar.h" #include "spinlock.h"
თითო სტრიქზე:
# ჩაწერეთ "types.h" # შევა "stdarg.h" # შევა "screen.h"
შემდეგ, ამოიღეთ ამ ფაილზე printf_init_global ფუნქცია და მისი ყველა მითითება:
სტატიკური void printf_init_global (ბათილად) (spinlock_init (& printf_lock);) INITFUNC ("global0", printf_init_global);
შემდეგ წაშალეთ ამ ფაილში printf_lock ცვლადი და მისი ყველა მითითება:
სტატიკური spinlock_t printf_lock; ... spinlock_lock (& \u200b\u200bprintf_lock); ... spinlock_unlock (& \u200b\u200bprintf_lock);
Printf ფუნქცია იყენებს putchar ფუნქციას, რომელიც ასევე უნდა დაიწეროს. ამისათვის შექმენით Commonscreen.c ფაილი შემდეგი შინაარსით:
# მითითება "types.h" #define GREEN 0x2 #define MAX_COL 80 // სვეტების მაქსიმალური რაოდენობა # განსაზღვრული MAX_ROW 25 // მწკრივების მაქსიმალური რაოდენობა # განსაზღვრული VRAM_SIZE (MAX_COL * MAX_ROW) // ეკრანის ზომა, მოკლედ "s # განსაზღვრე DEF_VRAM_BASE 0xb8000 // ნაგულისხმევი ბაზა ვიდეო მეხსიერების სტატიკური დაუსაბუთებელი char curr_col \u003d 0; სტატიკური დაუსუფთავებელი char curr_row \u003d 0; // ჩაწერეთ სიმბოლო მიმდინარე ეკრანზე მდებარე ადგილას # განსაზღვრება PUT (c) (((ხელმოწერილი მოკლედ *) (DEF_VRAM_BASE)) [ (curr_row * MAX_COL) + curr_col] \u003d (GREEN<< 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 >\u003d MAX_ROW) (curr_row \u003d 0;) შესვენება; შემთხვევაში "ბ": თუ (curr_col\u003e 0) (curr_col - \u003d 1; PUT ("");) შესვენება; ნაგულისხმევი: PUT (c); curr_col + \u003d 1; if (curr_col\u003e \u003d MAX_COL) (curr_col \u003d 0; curr_row + \u003d 1; if (curr_row\u003e \u003d MAX_ROW) (curr_row \u003d 0;))); ) void putchar (int c) (if (c \u003d\u003d "n") cons_putc ("r"); cons_putc (c);) void clear_screen (ბათილი) (curr_col \u003d 0; curr_row \u003d 0; int i; for (i) \u003d 0; ი< VRAM_SIZE; i++) cons_putc(" "); curr_col = 0; curr_row = 0; }
მითითებული კოდი შეიცავს მარტივ ლოგიკას სიმბოლოების ეკრანზე დასაბეჭდად ტექსტის რეჟიმში. ამ რეჟიმში, ორი ბაიტი გამოიყენება ჩაწერის პერსონაჟის ჩასაწერად (ერთი პერსონაჟის კოდით, მეორე - მისი ატრიბუტით), რომელიც პირდაპირ ეკრანზე გამოსახული ვიდეოკამერისთვის არის დაწერილი და იწყება მისამართით 0xB8000. ეკრანის გარჩევადობა 80x25 სიმბოლოა. პერსონაჟი პირდაპირ იბეჭდება PUT მაკრო გამოყენებით.
ახლა მხოლოდ რამდენიმე სათაურის ფაილი აკლია:
1. ფაილი მოიცავს creen.h. აცხადებს putchar ფუნქციას, რომელიც გამოიყენება printf ფუნქციისთვის. ფაილის შინაარსი:
#ifndef _SCREEN_H # განსაზღვრეთ _SCREEN_H ბათილად დატოვეთ_ ეკრანი (ბათილია); void putchar (int c); #endif
2. ფაილი მოიცავსeprintf.h. აცხადებს printf ფუნქციას, რომელსაც ძირითადად იყენებენ. ფაილის შინაარსი:
#ifndef _PRINTF_H # განსაზღვრება _PRINTF_H int printf (const char * ფორმატი, ...); #endif
3. ფაილი, რომელიც მოიცავსestestdarg.h. აცხადებს არგუმენტების ჩამოთვლის ფუნქციებს, რომელთა რაოდენობა წინასწარ არ არის ცნობილი. მთელი ფაილი აღებულია www.bitvisor.org/ პროექტისგან. ფაილის ბიტუტერის პროექტის კოდი:.
4. ფაილი .ასევე.ეს. აცხადებს NULL და size_t. ფაილის შინაარსი:
#ifndef _TYPES_H # განსაზღვრება _TYPES_H #define NULL 0 typedef დაუწერელი int size_t; #endif
ამრიგად, მოიცავს და საერთო საქაღალდეებს შეიცავს მინიმალური სისტემის ბიბლიოთეკის კოდი, რომელსაც ნებისმიერი პროგრამა სჭირდება.
ნაბიჯი 3. ბმულისთვის სცენარის შექმნა:
ჩვენ ვქმნით linker.ld ფაილს, რომელსაც ლინკერი გამოიყენებს სამიზნე პროგრამის ფაილის (kernel.bin) გენერირებისთვის. ფაილი უნდა შეიცავდეს შემდეგს:
ENTRY (მტვირთავი) LMA \u003d 0x00100000; სექციები (. \u003d LMA; .multiboot ALIGN (0x1000): (loader.o (.text)) .text ALIGN (0x1000): (* (. ტექსტი)) .rodata ALIGN (0x1000): (* (. Rodata *) ) .data ALIGN (0x1000): (* (. მონაცემები)) .bss: (* (COMMON) * (. bss)) / DISCARD /: (* ((კომენტარი))))
ჩამონტაჟებული ფუნქცია ENTRY () საშუალებას გაძლევთ დანიშნოთ ჩვენი ბირთვის შესასვლელი წერტილი. ამ მისამართით grub გაივლის კონტროლს ბირთვის ჩექმის შემდეგ. ამ სკრიპტის გამოყენებით, ლინკერი შექმნის ბინარულ ფაილს ELF ფორმატში. ELF ფაილი შედგება სეგმენტებისა და მონაკვეთების მთელი რიგისგან. სეგმენტების ჩამონათვალი მოცემულია პროგრამის სათაურის ცხრილში, სექციების ჩამონათვალი სექციების სათაურის ცხრილში. დამაკავშირებელი მოქმედებს განყოფილებებით, გამოსახულების მტვირთავი (ჩვენს შემთხვევაში, GRUB) სეგმენტებით.
როგორც ფიგურაში ხედავთ, სეგმენტები შედგება სექციებისგან. განყოფილების აღწერის ერთ-ერთი სფეროა ვირტუალური მისამართი, რომლის განყოფილებაც უნდა იყოს შესრულების დროს. სინამდვილეში, სეგმენტს აქვს 2 ველი, რომელიც აღწერს მის ადგილმდებარეობას: სეგმენტის ვირტუალური მისამართი და სეგმენტის ფიზიკური მისამართი. სეგმენტის ვირტუალური მისამართი არის კოდის შესრულების დროს სეგმენტის პირველი ბაიტის ვირტუალური მისამართი, სეგმენტის ფიზიკური მისამართი არის ფიზიკური მისამართი, რომლის დროსაც უნდა მოხდეს სეგმენტის დატვირთვა. პროგრამებისთვის, ეს მისამართები ყოველთვის ემთხვევა. Grub ჩამოტვირთავს სურათების სეგმენტებს მათ ფიზიკურ მისამართზე. ვინაიდან Grub არ ახდენს კონფიგურაციას გვერდის მისამართით, სეგმენტის ვირტუალური მისამართი უნდა შეესაბამებოდეს მის ფიზიკურ მისამართს, რადგან ჩვენს პროგრამაში ასევე არ არის კონფიგურირებული ვირტუალური მეხსიერება.
LMA
ეს გამოთქმა აცნობებს ბმულს, რომ ყველა მომდევნო მონაკვეთი არის LMA მისამართის შემდეგ.
ALIGN (0x1000)
ზემოთ მოყვანილი დირექტივა ნიშნავს, რომ მონაკვეთი შეესაბამება 0x1000 ბაიტს.
Multiboot ALIGN (0x1000): (loader.o (.text))
ცალკეული მრავალფუნქციური განყოფილება, რომელიც მოიცავს loader.o ფაილიდან .text განყოფილებას, შექმნილია იმისთვის, რომ მრავალუჯრედიანი ფორმატის ხელმოწერა მოხვდეს ბირთვის გამოსახულების პირველ 8 კგ-ში.
Bss: (* (საერთო) * (. Bss))
* (COMMON) არის ის სფერო, სადაც მეხსიერება დაცულია ინსტრუქციებით .com და.lcomm. ჩვენ ვათავსებთ მას .bss განყოფილებაში.
/ DISCARD /: (* ((კომენტარი)))
ყველა განყოფილება, რომელიც აღინიშნება DISCARD ამოღებულია სურათიდან. ამ შემთხვევაში, ჩვენ ვხსნით სექციას .comment, რომელიც შეიცავს ინფორმაციას ბმულის ვერსიის შესახებ.
ახლა შეაკეთეთ კოდი ორობითი ფაილი შემდეგი ბრძანებებით:
As -o loader.o loader.s gcc -Iinclude -Wall -fno-buildin -nostdinc -nostdlib -o kernel.o -c kernel.c gcc -Iinclude -Wall -fno-buildin -nostdinc-nostdlib -o printf.o -c ჩვეულებრივი / printf.c gcc -მისი ჩართვა -Wall-fno-buildin -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 bootloader- ის მომზადება:
შექმენით 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. ავტომატიზაცია და შექმენით ჩატვირთვის სურათი:
მშენებლობის პროცესის ავტომატიზაციისთვის, ჩვენ გამოვიყენებთ სასარგებლო პროგრამას. ამისათვის შექმენით მაკიაჟი, რომელიც აპირებს შედგენას წყაროს კოდი, ააშენეთ ბირთვის და შექმენით ჩატვირთვის სურათი. მაკიაჟს უნდა ჰქონდეს შემდეგი შინაარსი:
CC \u003d gcc CFLAGS \u003d -Wall -fno-buildin -nostdinc -nostdlib LD \u003d ld OBJFILES \u003d loader.o საერთო / printf.o საერთო / screen.o kernel.o სურათი: @echo "შექმნა hdd.img ..." @ dd if \u003d / dev / zero of \u003d. / hdd.img bs \u003d 512 count \u003d 16065 1\u003e / dev / null 2\u003e & 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\u003e / dev / null 2\u003e & 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 "დააკოპირეთ ბირთვის და გრაფის ფაილები გაყოფაზე ..." @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" მოწყობილობა (hd0) hdd.img n root (hd0,0) n setup (hd0) n quitn "| grub --batch 1\u003e / dev / null @echo "შესრულებულია!" ყველა: kernel.bin აღვადგინოთ: გაწმინდეთ ყველაფერი .ო: როგორც -ო [ელ.ფოსტა დაცულია] $< .c.o: $(CC) -Iinclude $(CFLAGS) -o [ელ.ფოსტა დაცულია] c $< kernel.bin: $(OBJFILES) $(LD) -T linker.ld -o [ელ.ფოსტა დაცულია] $ ^ სუფთა: rm -f $ (OBJFILES) hdd.img kernel.bin
ფაილში ორი ძირითადი მიზანი არის გამოცხადებული: ყველა - ადგენს ბირთვის, და გამოსახულებას - რაც ქმნის boot disk. სამიზნე ყველა, როგორც ჩვეულებრივი მაკიაჟი, შეიცავს subgoals.s.o და.c.o, რომ შეადგინონ * .s და * .c ფაილები ობიექტურ ფაილებში (* .o), ასევე kernel.bin წარმოქმნის სამიზნე, რომელსაც ბმულს უწოდებს ადრე შექმნილი სკრიპტით. ეს მიზნები ასრულებენ ზუსტად იმავე ბრძანებებს, რომლებიც მოცემულია მე –3 ეტაპზე.
აქ ყველაზე დიდი ინტერესი არის შექმნა ჩატვირთვის სურათი hdd.img (სამიზნე სურათი). მოდით განვიხილოთ ეტაპად, თუ როგორ ხდება ეს.
Dd if \u003d / dev / zero of \u003d. / Hdd.img bs \u003d 512 რაოდენობა \u003d 16065 1\u003e / dev / null 2\u003e & 1
ეს ბრძანება ქმნის სურათს, რომელთანაც მოხდება შემდგომი მუშაობა. სექტორების რაოდენობა შემთხვევით არ შეირჩა: 16065 \u003d 255 * 63. სტანდარტულად, fdsik მუშაობს დისკზე, თითქოს მას ჰქონდეს CHS გეომეტრია, რომელშიც ჰედერები (H) \u003d 255, Sectors (S) \u003d 63 და ცილინდრები © დამოკიდებულია დისკის ზომაზე . ამრიგად, დისკის მინიმალური ზომა, რომელთანაც შეუძლია fdsik შეძლოს ნაგულისხმევი გეომეტრიის შეცვლის გარეშე, არის 512 * 255 * 63 * 1 \u003d 8225280 ბაიტი, სადაც 512 არის სექტორის ზომა და 1 არის ცილინდრების რაოდენობა.
შემდეგი, იქმნება დანაყოფი ცხრილი:
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\u003e / dev / null 2\u003e & 1 || მართალია
პირველი ბრძანება დამონტაჟებს hdd.img ფაილს ბლოკის მოწყობილობაში / dev / loop1, რაც საშუალებას გაძლევთ იმუშაოთ ფაილთან, როგორც მოწყობილობად. მეორე ბრძანება ქმნის დანაყოფების ცხრილს მოწყობილობაზე / dev / loop1, რომელშიც არის 1 პირველადი boot დანაყოფი დისკი, რომელიც მოიცავს მთელ დისკს FAT32 ფაილური სისტემის იარლიყით.
შემდეგ ჩვენ ვქმნით შექმნილ განყოფილებას. ამისათვის დაამონტაჟეთ ის, როგორც ბლოკის მოწყობილობა და შეასრულეთ ფორმატირება.
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
პირველი ბრძანება ადგენს ადრე შექმნილ დანაყოფს მოწყობილობას / dev / loop2. –ფოსტის პარამეტრი მიუთითებს განყოფილების დასაწყისის მისამართს და განზომილების განყოფილების ბოლოს. ორივე პარამეტრი მიიღება fdisk ბრძანების გამოყენებით.
Mkdosfs / dev / loop2
Mkdosfs– ის კომუნალური ფორმატის დანაყოფი ქმნის ფაილური სისტემა FAT32.
ბირთვის უშუალო შეკრებისთვის გამოიყენება კლასიკური მაკიაჟის სინტაქსის ადრე განხილული ბრძანებები.
ახლა განვიხილოთ, თუ როგორ უნდა დააინსტალიროთ GRUB დანაყოფი:
Mkdir -p tempdir # ქმნის დროებითი მთა / dev / loop2 დირექტორია tempdir # დანაყოფს დანაყოფს mkdir დირექტორიაში tempdir / boot # ქმნის / boot დირექტორია cp -r განყოფილებაში grub tempdir / boot / # კოპირება grub საქაღალდეზე / boot cp kernel.bin tempdir / # ასლები ბირთვის ძილის დანაყოფის ფესვს 1 # დაელოდეთ Ubuntu umount / dev / loop2 # გაუქმებას დროებითი საქაღალდე rm -r tempdir # წაშლა დროებითი საქაღალდე losetup -d / dev / loop2 # გაუქმება დანაყოფი
ზემოხსენებული ბრძანებების შესრულების შემდეგ, სურათი მზად იქნება GRUB'- ს დაყენების მიზნით. შემდეგი ბრძანება დააინსტალირებს GRUB- ს hdd.img დისკის სურათის MBR- ში.
ექო "მოწყობილობა (hd0) hdd.img n root (hd0,0) n setup (hd0) n quitn" | grub --batch 1\u003e / dev / null
ყველაფერი მზად არის ტესტირებისთვის!
ნაბიჯი 6. დაწყება:
შედგენისთვის გამოიყენეთ ბრძანება:
გააკეთე ყველა
რის შემდეგაც უნდა გამოჩნდეს kernel.bin ფაილი.
ჩატვირთვის დისკის სურათის შესაქმნელად გამოიყენეთ ბრძანება:
Sudo გააკეთე სურათი
შედეგად, გამოჩნდება hdd.img ფაილი.
ახლა შეგიძლიათ ჩატვირთოთ hdd.img დისკის სურათიდან. ამის გადამოწმება შეგიძლიათ შემდეგი ბრძანებით:
ქემუ –დედა hdd.img –m 32
Qemu-system-i386 -hda hdd.img
ნამდვილ აპარატზე შესამოწმებლად, თქვენ უნდა გააკეთოთ ამ სურათის dd flash drive- ზე და აიტანოთ მისგან. მაგალითად, ამ ბრძანებით:
Sudo dd if \u003d. / Hdd.img of \u003d / dev / sdb
შეჯამებით, შეგვიძლია ვთქვათ, რომ განხორციელებული ქმედებების შედეგად, ჩვენ ვიღებთ წყაროების და სკრიპტების ერთობლიობას, რაც საშუალებას გვაძლევს გავატაროთ სხვადასხვა ექსპერიმენტები სისტემის პროგრამირების სფეროში. პირველი ნაბიჯი გადადგა სისტემის პროგრამული უზრუნველყოფის შექმნისკენ, როგორიცაა ჰიპერვიზორები და ოპერაციული სისტემები.
