🥇Raganosis katės viduje – paleiskite programinę-aparatinę įrangą Kopycat emuliatoriuje

Kaip susitikimo dalis 0x0A DC7831 DEF CON Nižnij Novgorodas Vasario 16 dieną pristatėme pranešimą apie pagrindinius dvejetainio kodo emuliavimo principus ir savo kūrimą – aparatinės platformos emuliatorių. Copycat.

Šiame straipsnyje aprašysime, kaip paleisti įrenginio programinę-aparatinę įrangą emuliatoriuje, pademonstruosime sąveiką su derinimo priemone ir atliksime nedidelę dinaminę programinės aparatinės įrangos analizę.

priešistorė

Seniai tolimoje galaktikoje

Prieš porą metų mūsų laboratorijoje iškilo poreikis ištirti įrenginio programinę-aparatinę įrangą. Programinė įranga buvo suglaudinta ir išpakuota naudojant įkrovos įkroviklį. Jis tai padarė labai sudėtingai, kelis kartus perkeldamas duomenis atmintyje. Tada pati programinė įranga aktyviai bendravo su periferiniais įrenginiais. Ir visa tai MIPS branduolyje.

Dėl objektyvių priežasčių turimi emuliatoriai mums netiko, bet mes vis tiek norėjome paleisti kodą. Tada nusprendėme sukurti savo emuliatorių, kuris padarytų minimumą ir leistų išpakuoti pagrindinę programinę-aparatinę įrangą. Išbandėme ir pavyko. Pagalvojome, kas būtų, jei pridėtume periferinius įrenginius, kad atliktume ir pagrindinę programinę-aparatinę įrangą. Labai neskaudėjo – ir pasiteisino. Dar kartą pagalvojome ir nusprendėme sukurti visavertį emuliatorių.

Rezultatas buvo kompiuterių sistemų emuliatorius Copycat.

Kodėl Kopycat?

Vyksta žodžių žaismas.

Copycat (anglų k., daiktavardis [ˈkɒpɪkæt]) – imitatorius, imitatorius
kaip (anglų k., daiktavardis [ˈkæt]) - katė, katė - mėgstamiausias vieno iš projekto kūrėjų gyvūnas
Raidė „K“ yra iš Kotlin programavimo kalbos

Copycat

Kuriant emuliatorių buvo nustatyti labai konkretūs tikslai:

galimybė greitai sukurti naujus periferinius įrenginius, modulius, procesoriaus branduolius;
galimybė surinkti virtualų įrenginį iš įvairių modulių;
galimybė įkelti bet kokius dvejetainius duomenis (firmware) į virtualaus įrenginio atmintį;
gebėjimas dirbti su momentinėmis nuotraukomis (sistemos būsenos momentinėmis nuotraukomis);
galimybė bendrauti su emuliatoriumi per integruotą derintuvą;
graži moderni kalba tobulėjimui.

Dėl to Kotlin buvo pasirinktas įgyvendinimui, magistralės architektūra (tai yra, kai moduliai bendrauja tarpusavyje per virtualias duomenų magistrales), JSON kaip įrenginio aprašymo formatas ir GDB RSP kaip sąveikos su derintuvu protokolas.

Plėtra vyksta šiek tiek daugiau nei dvejus metus ir aktyviai vyksta. Per šį laiką buvo įdiegti MIPS, x86, V850ES, ARM ir PowerPC procesorių branduoliai.

Projektas auga ir pats laikas jį pristatyti platesnei visuomenei. Išsamų projekto aprašymą pateiksime vėliau, tačiau kol kas daugiausia dėmesio skirsime Kopycat naudojimui.

Nekantriesiems galima atsisiųsti reklaminę emuliatoriaus versiją iš nuoroda.

Rhino emuliatoriuje

Prisiminkime, kad anksčiau SMARTRHINO-2018 konferencijai buvo sukurtas testavimo prietaisas „Raganosis“, skirtas atvirkštinės inžinerijos įgūdžių mokymui. Statinės programinės įrangos analizės procesas buvo aprašytas Šis straipsnis.

Dabar pabandykime pridėti „garsiakalbius“ ir paleiskite programinę-aparatinę įrangą emuliatoriuje.

Mums reikės:
1) Java 1.8
2) Python ir modulis Džepas naudoti Python emuliatoriaus viduje. Galite sukurti WHL modulį Jep, skirtą „Windows“. atsisiųskite čia.

„Windows“:
1) com0com
2) PuTTY

„Linux“:
1) socat

Kaip GDB klientą galite naudoti Eclipse, IDA Pro arba radare2.

Kaip tai veikia?

Norint emuliatoriuje atlikti programinę-aparatinę įrangą, reikia „surinkti“ virtualų įrenginį, kuris yra tikrojo įrenginio analogas.

Tikrasis prietaisas („raganosis“) gali būti parodytas blokinėje diagramoje:

Emuliatorius turi modulinę struktūrą, o galutinis virtualus įrenginys gali būti aprašytas JSON faile.

JSON 105 eilutės

{
  "top": true,

  // Plugin name should be the same as file name (or full path from library start)
  "plugin": "rhino",

  // Directory where plugin places
  "library": "user",

  // Plugin parameters (constructor parameters if jar-plugin version)
  "params": [
    { "name": "tty_dbg", "type": "String"},
    { "name": "tty_bt", "type": "String"},
    { "name": "firmware", "type": "String", "default": "NUL"}
  ],

  // Plugin outer ports
  "ports": [  ],

  // Plugin internal buses
  "buses": [
    { "name": "mem", "size": "BUS30" },
    { "name": "nand", "size": "4" },
    { "name": "gpio", "size": "BUS32" }
  ],

  // Plugin internal components
  "modules": [
    {
      "name": "u1_stm32",
      "plugin": "STM32F042",
      "library": "mcu",
      "params": {
        "firmware:String": "params.firmware"
      }
    },
    {
      "name": "usart_debug",
      "plugin": "UartSerialTerminal",
      "library": "terminals",
      "params": {
        "tty": "params.tty_dbg"
      }
    },
    {
      "name": "term_bt",
      "plugin": "UartSerialTerminal",
      "library": "terminals",
      "params": {
        "tty": "params.tty_bt"
      }
    },
    {
      "name": "bluetooth",
      "plugin": "BT",
      "library": "mcu"
    },

    { "name": "led_0",  "plugin": "LED", "library": "mcu" },
    { "name": "led_1",  "plugin": "LED", "library": "mcu" },
    { "name": "led_2",  "plugin": "LED", "library": "mcu" },
    { "name": "led_3",  "plugin": "LED", "library": "mcu" },
    { "name": "led_4",  "plugin": "LED", "library": "mcu" },
    { "name": "led_5",  "plugin": "LED", "library": "mcu" },
    { "name": "led_6",  "plugin": "LED", "library": "mcu" },
    { "name": "led_7",  "plugin": "LED", "library": "mcu" },
    { "name": "led_8",  "plugin": "LED", "library": "mcu" },
    { "name": "led_9",  "plugin": "LED", "library": "mcu" },
    { "name": "led_10", "plugin": "LED", "library": "mcu" },
    { "name": "led_11", "plugin": "LED", "library": "mcu" },
    { "name": "led_12", "plugin": "LED", "library": "mcu" },
    { "name": "led_13", "plugin": "LED", "library": "mcu" },
    { "name": "led_14", "plugin": "LED", "library": "mcu" },
    { "name": "led_15", "plugin": "LED", "library": "mcu" }
  ],

  // Plugin connection between components
  "connections": [
    [ "u1_stm32.ports.usart1_m", "usart_debug.ports.term_s"],
    [ "u1_stm32.ports.usart1_s", "usart_debug.ports.term_m"],

    [ "u1_stm32.ports.usart2_m", "bluetooth.ports.usart_m"],
    [ "u1_stm32.ports.usart2_s", "bluetooth.ports.usart_s"],

    [ "bluetooth.ports.bt_s", "term_bt.ports.term_m"],
    [ "bluetooth.ports.bt_m", "term_bt.ports.term_s"],

    [ "led_0.ports.pin",  "u1_stm32.buses.pin_output_a", "0x00"],
    [ "led_1.ports.pin",  "u1_stm32.buses.pin_output_a", "0x01"],
    [ "led_2.ports.pin",  "u1_stm32.buses.pin_output_a", "0x02"],
    [ "led_3.ports.pin",  "u1_stm32.buses.pin_output_a", "0x03"],
    [ "led_4.ports.pin",  "u1_stm32.buses.pin_output_a", "0x04"],
    [ "led_5.ports.pin",  "u1_stm32.buses.pin_output_a", "0x05"],
    [ "led_6.ports.pin",  "u1_stm32.buses.pin_output_a", "0x06"],
    [ "led_7.ports.pin",  "u1_stm32.buses.pin_output_a", "0x07"],
    [ "led_8.ports.pin",  "u1_stm32.buses.pin_output_a", "0x08"],
    [ "led_9.ports.pin",  "u1_stm32.buses.pin_output_a", "0x09"],
    [ "led_10.ports.pin", "u1_stm32.buses.pin_output_a", "0x0A"],
    [ "led_11.ports.pin", "u1_stm32.buses.pin_output_a", "0x0B"],
    [ "led_12.ports.pin", "u1_stm32.buses.pin_output_a", "0x0C"],
    [ "led_13.ports.pin", "u1_stm32.buses.pin_output_a", "0x0D"],
    [ "led_14.ports.pin", "u1_stm32.buses.pin_output_a", "0x0E"],
    [ "led_15.ports.pin", "u1_stm32.buses.pin_output_a", "0x0F"]
  ]
}

Atkreipkite dėmesį į parametrą mikroprograma skyrius parametrai yra failo, kurį galima įkelti į virtualų įrenginį kaip programinę įrangą, pavadinimas.

Virtualus įrenginys ir jo sąveika su pagrindine operacine sistema gali būti pavaizduoti šioje diagramoje:

Dabartinis bandomasis emuliatoriaus egzempliorius apima sąveiką su pagrindinės OS COM prievadais (derinti UART ir UART „Bluetooth“ moduliui). Tai gali būti tikri prievadai, prie kurių prijungti įrenginiai, arba virtualūs COM prievadai (tam jums tereikia com0com/socat).

Šiuo metu yra du pagrindiniai būdai, kaip sąveikauti su emuliatoriumi iš išorės:

GDB RSP protokolas (atitinkamai, šį protokolą palaikantys įrankiai yra Eclipse / IDA / radare2);
vidinio emuliatoriaus komandų eilutė (Argparse arba Python).

Virtualūs COM prievadai

Norėdami sąveikauti su virtualiojo įrenginio UART vietiniame kompiuteryje per terminalą, turite sukurti porą susietų virtualių COM prievadų. Mūsų atveju vieną prievadą naudoja emuliatorius, o antrąjį - terminalo programa (PuTTY arba ekranas):

Naudojant com0com

Virtualūs COM prievadai sukonfigūruojami naudojant sąrankos priemonę iš com0com rinkinio (konsolės versija - C: Program Files (x86)com0comsetupс.exe, arba GUI versija - C: Program Files (x86)com0comsetupg.exe):

Pažymėkite langelius įjungti buferio viršijimą visiems sukurtiems virtualiems prievadams, kitaip emuliatorius lauks atsakymo iš COM prievado.

Naudojant socat

UNIX sistemose virtualius COM prievadus automatiškai sukuria emuliatorius, naudodamas socat įrankį, paleidžiant emuliatorių tiesiog nurodykite priešdėlį prievado pavadinime socat:.

Vidinė komandų eilutės sąsaja (Argparse arba Python)

Kadangi Kopycat yra konsolės programa, emuliatorius teikia dvi komandų eilutės sąsajos parinktis, skirtas sąveikauti su objektais ir kintamaisiais: Argparse ir Python.

Argparse yra CLI, integruota į Kopycat ir visada prieinama visiems.

Alternatyvus CLI yra Python interpretatorius. Norint juo naudotis, reikia įdiegti Jep Python modulį ir sukonfigūruoti emuliatorių, kad jis veiktų su Python (bus naudojamas pagrindinėje vartotojo sistemoje įdiegtas Python interpretatorius).

Python modulio Jep diegimas

Linux sistemoje Jep galima įdiegti per pip:

pip install jep

Norėdami įdiegti „Jep“ sistemoje „Windows“, pirmiausia turite įdiegti „Windows“ SDK ir atitinkamą „Microsoft Visual Studio“. Mes jums tai šiek tiek palengvinome ir WHL stato JEP dabartinėms Python for Windows versijoms, todėl modulį galima įdiegti iš failo:

pip install jep-3.8.2-cp27-cp27m-win_amd64.whl

Norėdami patikrinti „Jep“ diegimą, turite paleisti komandų eilutę:

python -c "import jep"

Atsakant turėtų būti gautas toks pranešimas:

ImportError: Jep is not supported in standalone Python, it must be embedded in Java.

Jūsų sistemos emuliatoriaus paketiniame faile (copycat.bat - „Windows“, kopijavimas - Linux) į parametrų sąrašą DEFAULT_JVM_OPTS pridėti papildomą parametrą Djava.library.path — jame turi būti kelias į įdiegtą Jep modulį.

„Windows“ rezultatas turėtų būti tokia eilutė:

set DEFAULT_JVM_OPTS="-XX:MaxMetaspaceSize=256m" "-XX:+UseParallelGC" "-XX:SurvivorRatio=6" "-XX:-UseGCOverheadLimit" "-Djava.library.path=C:/Python27/Lib/site-packages/jep"

Paleidžiamas Kopycat

Emuliatorius yra konsolės JVM programa. Paleidimas vykdomas naudojant operacinės sistemos komandinės eilutės scenarijų (sh/cmd).

Komanda paleisti naudojant „Windows“:

binkopycat -g 23946 -n rhino -l user -y library -p firmware=firmwarerhino_pass.bin,tty_dbg=COM26,tty_bt=COM28

Komanda paleisti naudojant „Linux“ naudojant „socat“ įrankį:

./bin/kopycat -g 23946 -n rhino -l user -y library -p firmware=./firmware/rhino_pass.bin, tty_dbg=socat:./COM26,tty_bt=socat:./COM28

-g 23646 — TCP prievadas, kuris bus atviras prieigai prie GDB serverio;
-n rhino — pagrindinio sistemos modulio (surinkto įrenginio) pavadinimas;
-l user — bibliotekos pavadinimas pagrindiniam moduliui ieškoti;
-y library — įrenginyje esančių modulių paieškos kelias;
firmwarerhino_pass.bin - kelias į programinės įrangos failą;
COM26 ir COM28 yra virtualūs COM prievadai.

Dėl to bus rodomas raginimas Python > (Arba Argparse >):

18:07:59 INFO [eFactoryBuilder.create ]: Module top successfully created as top
18:07:59 INFO [ Module.initializeAndRes]: Setup core to top.u1_stm32.cortexm0.arm for top
18:07:59 INFO [ Module.initializeAndRes]: Setup debugger to top.u1_stm32.dbg for top
18:07:59 WARN [ Module.initializeAndRes]: Tracer wasn't found in top...
18:07:59 INFO [ Module.initializeAndRes]: Initializing ports and buses...
18:07:59 WARN [ Module.initializePortsA]: ATTENTION: Some ports has warning use printModulesPortsWarnings to see it...
18:07:59 FINE [ ARMv6CPU.reset ]: Set entry point address to 08006A75
18:07:59 INFO [ Module.initializeAndRes]: Module top is successfully initialized and reset as a top cell!
18:07:59 INFO [ Kopycat.open ]: Starting virtualization of board top[rhino] with arm[ARMv6Core]
18:07:59 INFO [ GDBServer.debuggerModule ]: Set new debugger module top.u1_stm32.dbg for GDB_SERVER(port=23946,alive=true)
Python >

Sąveika su IDA Pro

Norėdami supaprastinti testavimą, mes naudojame Rhino programinę įrangą kaip šaltinio failą analizei IDA formoje ELF failas (ten saugoma meta informacija).

Taip pat galite naudoti pagrindinę programinę įrangą be metainformacijos.

Paleidę Kopycat programoje IDA Pro, Debugger meniu eikite į elementą "Perjungti derintuvą…“ ir pasirinkite „Nuotolinis GDB deriklis“. Tada nustatykite ryšį: meniu Derinimo priemonė – proceso parinktys…

Nustatykite reikšmes:

Taikymas – bet kokia vertė
Pagrindinio kompiuterio pavadinimas: 127.0.0.1 (arba nuotolinio kompiuterio, kuriame veikia Kopycat, IP adresas)
Prievadas: 23946

Dabar pasiekiamas derinimo mygtukas (F9 klavišas):

Spustelėkite jį, kad prisijungtumėte prie derinimo modulio emuliatoriuje. IDA pereina į derinimo režimą, atsiranda papildomų langų: informacija apie registrus, apie krūvą.

Dabar galime naudoti visas standartines derinimo priemonės funkcijas:

žingsnis po žingsnio instrukcijų vykdymas (Įžengti и Peržengti — klavišai F7 ir F8 atitinkamai);
vykdymo pradžia ir pristabdymas;
lūžio taškų kūrimas tiek kodui, tiek duomenims (F2 klavišas).

Prisijungimas prie derinimo priemonės nereiškia, kad paleidžiamas programinės įrangos kodas. Dabartinė vykdymo vieta turi būti adresas 0x08006A74 - funkcijos pradžia Reset_Handler. Jei slinksite sąrašu žemyn, pamatysite funkcijos iškvietimą pagrindinis. Galite įdėti žymeklį ant šios eilutės (adresas 0x08006ABE) ir atlikti operaciją Vykdykite iki žymeklio (F4 klavišas).

Tada galite paspausti F7, kad įeitumėte į funkciją pagrindinis.

Jei paleisite komandą Tęsti procesą (F9 klavišas), tada vienu mygtuku pasirodys langas „Prašome palaukti“. Sustabdyti:

Kai paspausite Sustabdyti programinės aparatinės įrangos kodo vykdymas sustabdomas ir gali būti tęsiamas nuo to paties adreso kode, kuriame jis buvo nutrauktas.

Jei ir toliau vykdysite kodą, terminaluose, prijungtuose prie virtualių COM prievadų, pamatysite šias eilutes:

„Būsenos apėjimo“ eilutės buvimas rodo, kad virtualusis „Bluetooth“ modulis persijungė į duomenų gavimo iš vartotojo COM prievado režimą.

Dabar Bluetooth terminale (nuotraukoje COM29) galite įvesti komandas pagal Rhino protokolą. Pavyzdžiui, komanda „MEOW“ grąžins eilutę „mur-mur“ į „Bluetooth“ terminalą:

Imituoti mane ne visiškai

Kurdami emuliatorių galite pasirinkti konkretaus įrenginio detalumo / emuliacijos lygį. Pavyzdžiui, Bluetooth modulis gali būti imituojamas įvairiais būdais:

įrenginys visiškai emuliuojamas su visu komandų rinkiniu;
AT komandos yra emuliuojamos, o duomenų srautas gaunamas iš pagrindinės sistemos COM prievado;
virtualus įrenginys užtikrina visišką duomenų peradresavimą į realų įrenginį;
kaip paprastas šaknis, kuris visada grąžina „OK“.

Dabartinė emuliatoriaus versija naudoja antrąjį metodą - virtualus „Bluetooth“ modulis atlieka konfigūraciją, o po to persijungia į duomenų „tarpinio serverio perdavimo“ režimą iš pagrindinės sistemos COM prievado į emuliatoriaus UART prievadą.

Panagrinėkime paprasto kodo instrumentavimo galimybę, jei kuri nors periferijos dalis nebūtų įgyvendinta. Pavyzdžiui, jei nebuvo sukurtas laikmatis, atsakingas už duomenų perdavimo į DMA valdymą (patikrinimas atliekamas funkcijoje ws2812b_laukti, raspolojennoy po adresu 0x08006840), tada programinė įranga visada lauks, kol vėliavėlė bus nustatyta iš naujo užimtasesantis adresu 0x200004C4kuris rodo DMA duomenų linijos užimtumą:

Šią situaciją galime apeiti rankiniu būdu iš naujo nustatę vėliavėlę užimtas iškart po jo įdiegimo. „IDA Pro“ galite sukurti „Python“ funkciją ir iškviesti ją pertraukos taške, o į kodą įrašyti patį lūžio tašką, įvedę vėliavėlės reikšmę 1 užimtas.

Lūžio taško tvarkytuvas

Pirmiausia sukurkime Python funkciją IDA. Meniu Failas – scenarijaus komanda...

Įtraukite naują fragmentą į kairėje esantį sąrašą, suteikite jam pavadinimą (pvz., BPT),
Dešinėje esančiame teksto laukelyje įveskite funkcijos kodą:

def skip_dma():
    print "Skipping wait ws2812..."
    value = Byte(0x200004C4)
    if value == 1:
        PatchDbgByte(0x200004C4, 0)
return False

Po to spustelėkite paleisti ir uždarykite scenarijaus langą.

Dabar pereikime prie kodo adresu 0x0800688A, nustatykite pertraukos tašką (F2 klavišas), redaguokite jį (kontekstinis meniu Redaguoti pertraukos tašką...), nepamirškite scenarijaus tipo nustatyti į Python:

Jei esama vėliavos reikšmė užimtas lygus 1, tuomet turėtumėte vykdyti funkciją skip_dma scenarijaus eilutėje:

Jei paleisite programinę-aparatinę įrangą, kad būtų galima vykdyti, IDA lange galite pamatyti lūžio taško tvarkyklės kodo suaktyvinimą produkcija pagal eilutę Skipping wait ws2812.... Dabar programinė įranga nelauks, kol vėliavėlė bus nustatyta iš naujo užimtas.

Sąveika su emuliatoriumi

Vargu ar emuliacija dėl emuliacijos sukels malonumo ir džiaugsmo. Daug įdomiau, jei emuliatorius padeda tyrėjui matyti duomenis atmintyje arba nustatyti gijų sąveiką.

Parodysime, kaip dinamiškai užmegzti sąveiką tarp RTOS užduočių. Pirmiausia turėtumėte pristabdyti kodo vykdymą, jei jis veikia. Jei einate į funkciją bluetooth_task_entry į „LED“ komandos apdorojimo šaką (adresas 0x080057B8), tada galite pamatyti, kas pirmiausia sukuriama ir siunčiama į sistemos eilę ledControlQueueHandle kažkokia žinutė.

Norėdami pasiekti kintamąjį, turėtumėte nustatyti pertraukos tašką ledControlQueueHandle, raspolojennoy po adresu 0x20000624 ir tęskite kodo vykdymą:

Dėl to sustojimas pirmiausia įvyks adresu 0x080057CA prieš iškviesdami funkciją osMailAlloc, tada adresu 0x08005806 prieš iškviesdami funkciją osMailPut, tada po kurio laiko – adresu 0x08005BD4 (prieš iškviečiant funkciją osMailGet), kuri priklauso funkcijai leds_task_entry (LED užduotis), tai yra, užduotys buvo perjungtos, o dabar LED užduotis gavo valdymą.

Šiuo paprastu būdu galite nustatyti, kaip RTOS užduotys sąveikauja viena su kita.

Žinoma, iš tikrųjų užduočių sąveika gali būti sudėtingesnė, tačiau naudojant emuliatorių šios sąveikos stebėjimas tampa ne toks sudėtingas.

Čia Galite žiūrėti trumpą vaizdo įrašą apie emuliatoriaus paleidimą ir sąveiką su IDA Pro.

Paleiskite su Radare2

Negalite ignoruoti tokio universalaus įrankio kaip Radare2.

Norėdami prisijungti prie emuliatoriaus naudojant r2, komanda atrodys taip:

radare2 -A -a arm -b 16 -d gdb://localhost:23946 rhino_fw42k6.elf

Paleisti galima dabar (dc) ir pristabdykite vykdymą (Ctrl+C).

Deja, šiuo metu r2 turi problemų dirbant su aparatūros gdb serveriu ir atminties išdėstymu, dėl to neveikia lūžio taškai ir žingsniai (komanda ds). Tikimės, kad tai greitai bus ištaisyta.

Bėgimas su Eclipse

Viena iš emuliatoriaus naudojimo galimybių yra derinti kuriamo įrenginio programinę-aparatinę įrangą. Aiškumo dėlei taip pat naudosime Rhino programinę įrangą. Galite atsisiųsti programinės įrangos šaltinius taigi.

Naudosime Eclipse iš rinkinio kaip IDE Sistemos darbo stalas, skirtas STM32.

Kad emuliatorius galėtų įkelti programinę-aparatinę įrangą, tiesiogiai sudarytą „Eclipse“, turite pridėti parametrą firmware=null į emuliatoriaus paleidimo komandą:

binkopycat -g 23946 -n rhino -l user -y modules -p firmware=null,tty_dbg=COM26,tty_bt=COM28

Derinimo konfigūracijos nustatymas

Programoje Eclipse pasirinkite meniu Vykdyti – derinti konfigūracijas... Atsidariusiame lange skiltyje GDB aparatinės įrangos derinimas turite pridėti naują konfigūraciją, tada skirtuke „Pagrindinis“ nurodykite dabartinį projektą ir derinimo programą:

Skirtuke „Debugger“ turite nurodyti GDB komandą:
${openstm32_compiler_path}arm-none-eabi-gdb

Taip pat įveskite prisijungimo prie GDB serverio parametrus (host ir prievadas):

Skirtuke „Paleistis“ turite nurodyti šiuos parametrus:

įjungti žymimąjį laukelį Įkelti vaizdą (kad surinktas programinės įrangos vaizdas būtų įkeltas į emuliatorių);
įjungti žymimąjį laukelį Įkelti simbolius;
pridėti paleidimo komandą: set $pc = *0x08000004 (nustatykite kompiuterio registro reikšmę iš atminties adresu 0x08000004 - ten saugomas adresas ResetHandler).

Обратите внимание, jei nenorite atsisiųsti programinės įrangos failo iš Eclipse, tada parinktys Įkelti vaizdą и Vykdyti komandas nurodyti nereikia.

Spustelėję Debug galite dirbti derinimo režimu:

žingsnis po žingsnio kodo vykdymas
sąveikauja su lūžio taškais

Atkreipti dėmesį. Užtemimas turi, hmm... tam tikrų keistenybių... ir tu turi su jomis gyventi. Pavyzdžiui, jei paleidžiant derintuvą pasirodo pranešimas „Nėra šaltinio prieinamo „0x0“, tada vykdykite komandą Step (F5)

Vietoj išvados

Natūralaus kodo imitavimas yra labai įdomus dalykas. Įrenginio kūrėjas gali derinti programinę-aparatinę įrangą be tikro įrenginio. Mokslininkui tai galimybė atlikti dinaminę kodo analizę, kuri ne visada įmanoma net ir turint įrenginį.

Mes norime specialistams suteikti patogų, vidutiniškai paprastą įrankį, kurio nustatymas ir paleidimas nereikalauja daug pastangų ir laiko.

Parašykite komentaruose apie savo patirtį naudojant aparatūros emuliatorius. Kviečiame diskutuoti ir mielai atsakysime į klausimus.

Apklausoje gali dalyvauti tik registruoti vartotojai. Prisijungti, Prašau.

Kam naudoji emuliatorių?

Kuriu (derinu) programinę įrangą
Aš tyrinėju programinę-aparatinę įrangą
Pradedu žaidimus (Dendi, Sega, PSP)
dar kažkas (rašyk komentaruose)

Balsavo 7 vartotojų. 2 vartotojai susilaikė.

Kokią programinę įrangą naudojate vietiniam kodui emuliuoti?

QEMU
Vienaragis variklis
Nepastovus žmogus
dar kažkas (rašyk komentaruose)

Balsavo 6 vartotojų. 2 vartotojai susilaikė.

Ką norėtumėte patobulinti jūsų naudojamame emuliatoriuje?

Noriu greičio
Noriu lengvesnės sąrankos/paleidimo
Noriu daugiau galimybių bendrauti su emuliatoriumi (API, kabliukai)
Esu viskuo patenkinta
dar kažkas (rašyk komentaruose)

Balsavo 8 vartotojai. 1 vartotojas susilaikė.

Šaltinis: www.habr.com

Raganosis katės viduje – paleiskite programinę-aparatinę įrangą Kopycat emuliatoriuje