Pubblicità

Come BASE.EXE inizializza lo stack driver: il firmware bring-up del CMU200

Nell’articolo sul native loader vi avevo lasciato con init_communication() che restava appeso in DOSBox-X e generava un invalid opcode sull’hardware reale, oltre a tre bug del loader prontamente corretti. Qui riprendo quel filone per spiegare perché, anche alla luce di quelle correzioni, l’esperimento fosse strutturalmente condannato: mancava l’intero rituale di bring-up che BASE.EXE esegue tassativamente prima di toccare cmudrv.dl0. Vale la premessa già fatta: questo percorso è stato accantonato, TRACK.EXE pilota l’hardware in modo diretto e nessuno dei moduli descritti in queste righe (fw_module.c, pl_shim.c, il pool TLSF da 8 MiB) fa parte dell’albero dei sorgenti attuale, trattandosi di codice sperimentale scritto da me. Ciò che ho appreso su come BASE.EXE inizializza lo stack driver resta però valido a prescindere, e la parte finale chiarisce il punto esatto in cui il tentativo si arresta. Ho ricostruito la sequenza mediante analisi statica su BASE.EXE, base.dll e cmudrv.dl0. Tutti gli indirizzi indicati sono Virtual Address (VA) con image base 0x00400000.

Perché l’esperimento era spacciato

La funzione pmgr_get_correction_processor(0) restituisce &DAT_006219A0. Quell’indirizzo risiede nella sezione .bss di CMUDRV (0x00611000–0x00680FFF, non inizializzata): non si tratta quindi di un’istanza statica già pronta, ma di un oggetto che deve essere istanziato a runtime da un costruttore statico C++. Invocare init_communication() su memoria azzerata, in totale assenza di vtable e senza i sub-oggetti SIP_C_SIP, TSK_C_TASK e LOG_C_LOG, conduce inevitabilmente a blocchi (hang) e fault di esecuzione, a prescindere dai bug del loader.

L’entry point standard entry() non esegue affatto i costruttori statici: di questo compito si occupa un install hook separato.

Il ciclo di vita delle DLL in BASE.EXE

Il loader interno di BASE.EXE (FUN_00490441, che referenzia la stringa "dllcontrol_initDll" a 0x00490CD8) esegue, per ciascun modulo, la seguente trafila:

  1. Caricamento Phar Lap + chiamata a entry(hinst, 1) — che per entrambe le DLL si limita a richiamare dllreg_register_dll(hinst, code_marker, DGROUP_start).
  2. Risoluzione tramite GetProcAddress("dllcontrol_initDll") e successiva chiamata a dllcontrol_initDll(-4, desc).
  3. Successivamente, la funzione di dispatch (FUN_00497867, che chiamo informalmente “callInstallFunctions”) scandisce la lista dei moduli per livelli di priorità da 0 a 12 e ne invoca l’install hook; la controparte speculare per la rimozione (FUN_00497C1A) richiama invece il remove hook in ordine rigorosamente inverso.

La funzione dllcontrol_initDll invoca a sua volta __InitRtns(0x22), ossia il dispatcher Watcom per le inizializzazioni statiche: questo scandisce gli elementi della tabella XI {state, priority, fn} in ordine crescente di priorità, ma elaborando soltanto le voci con priorità <= limit. Impostando il limite a 0x22 vengono eseguiti unicamente gli initializer della libreria standard C (priorità 0x00, 0x13, 0x16, 0x20), mentre i costruttori C++ veri e propri (priorità 0x40) rimangono in attesa. L’install hook, al contrario, richiama __InitRtns(0xFF) (eseguendo tutti i costruttori rimanenti) all’interno di un contesto protetto da _setjmp/feh_push_return_jmp_env, impostando infine state = 2.

L’indirizzo dell’install hook viene estratto direttamente dal descrittore del modulo (offset +0xB7 per l’install hook, +0xBB per il remove hook; 0xFFFFFFFE indica l’assenza di hook). Per CMUDRV l’indirizzo corrisponde a 0x004012C9, mentre per BASE.DLL si trova a 0x0044DC75. Nel mio file fw_module.c ho quindi implementato la lettura dinamica degli hook direttamente dal record, evitando di cablarli staticamente.

Cosa fanno i costruttori di CMUDRV

La routine FUN_0050817D (registrata con priorità XI 0x40) si occupa di costruire l’intero sottosistema RXTX nel seguente ordine: LOG_C_LOG, il primo controller C331_C_CTRL, le classi facade RX/TX/DIAG, il secondo C331_C_CTRL, le risorse DDC, i DSP dedicati a TX/AUDIO, SMU_C_SMU, DIV_C_CLKDIV, IQIF_C_IQIF e infine i moduli AUXTX_C_AUXTX.

Gli argomenti passati al costruttore di C331_C_CTRL (all’indirizzo 0x0042CB7A) sono una miniera di informazioni sull’architettura interna:

C331_C_CTRL(0x6219A0, "PMGR_RXTX_1", 500, 3, 0xD4000, "rxtx1", 0, 5)
C331_C_CTRL(0x64EB20, "PMGR_RXTX_2", ..., 0xD5000, "rxtx2", 1, 6)

La firma dei parametri corrisponde a: this, task_name, dimensione stack/coda (500), priorità (3), indirizzo fisico DPRAM, nome del log, indice della scheda, linea IRQ. Il costruttore istanzia la macchina a stati SIP_C_SIP all’offset +0x32, l’oggetto TSK_C_TASK a +0x65, registra le callback di avvio legate alle varie fasi STU (fase 6: c331_stu_register_irq, fase 9: c331_stu_hw_reset, fase 0xC: c331_static_driver_test), verifica lo stato di emulazione richiamando simulation = sys_is_hardware_simulation() (che risulta vera a meno che la variabile CMU_HW_PRESENT non sia definita) e, se il test di presenza della DPRAM va a buon fine, invoca infine init_communication().

Il protocollo DPRAM del COR

La dual-port RAM del processore COR occupa 2 KB effettivi mappati all’interno di una finestra di 4 KB. La mappatura dei registri chiave è la seguente:

Offset DPRAMUso
+0x000Stato del COR: 0 = idle / pronto per il comando host successivo
+0x001Message flag: 0xFF = messaggio pendente da COR verso host; l’host vi scrive 0 come acknowledge
+0x7EF, +0x7F0Byte di scratch utilizzati dal test di presenza
+0x7FCLettura = interrupt acknowledge / clear
+0x7FELetto da interrupt_quit e inoltrato al metodo di acknowledge dell’oggetto IRQ
+0x7FFL’host vi scrive 0 = trigger doorbell verso il COR
+0x800…Area mirror speculare di +0x000…

La routine di verifica hardware (rxtx_option_poll a 0x0042D551) salva il contenuto originale di +0x7F0/+0x7EF, vi scrive il pattern 0x55/0xAA, ne verifica la corrispondenza nell’area mirror a +0xFF0/+0xFEF, scrive la sequenza invertita 0xAA/0x55, la rilegge e infine ripristina i valori iniziali. La scheda viene considerata presente solo se entrambi i riscontri sull’area speculare coincidono. Se il test fallisce, il C331 forza automaticamente il funzionamento in modalità simulazione. È esattamente la medesima sequenza di polling che ho poi integrato nella mia funzione cmu_dpram_probe().

La HAL dipende dai selettori Phar Lap, incompatibili con DOS/32A

Qui risiede uno dei nodi critici più rilevanti.

La routine sys_read_isa_mem_byte (a 0x00485FA9) carica un puntatore far eseguendo MOV FS, sel seguito da MOV AL, FS:[off]. Il segmento 0x34 rappresenta la convenzione di Phar Lap TNT per indicare che “l’offset corrisponde a un indirizzo fisico reale”, ed è il selettore predefinito assegnato al primo megabyte di memoria. Questa gestione non è supportata nativamente sotto DOS/32A; per questo motivo, TRACK.EXE risolve internamente le dieci funzioni HAL che CMUDRV importa da BASE.DLL agganciandosi a routine proprietarie (raccolte in cmu_hal.c).

L’ostacolo principale risiede nelle chiamate di sistema Phar Lap eseguite in linea: BASE.DLL incapsula i servizi TNT all’interno di stub in convenzione __cdecl che terminano con la sequenza MOV AX, 25xxh / INT 21h. Tuttavia, sotto DOS/32A la chiamata con AH=25h corrisponde alla funzione standard DOS “Set Interrupt Vector”: richiamarla alla cieca avrebbe l’effetto disastroso di sovrascrivere silenziosamente i vettori di interrupt. La contromisura adottata nell’esperimento è stata lo sviluppo di pl_shim.c: intercettando il vettore in modalità protetta di INT 21h, le chiamate con AH=25h generate dal firmware venivano tradotte ed emulate mediante le corrispondenti funzioni DPMI (servizi 0200h, 0201h, 0202h, 0205h, 0800h, ecc.), mentre tutte le restanti INT 21h venivano inoltrate normalmente a DOS/32A. Grazie a questo shim trasparente, le routine pci_init e la HAL di BASE.DLL hanno potuto funzionare senza modifiche su selettori DPMI autentici.

Per quanto riguarda l’hardware: la verifica per l’architettura FMR7 (FUN_0048591D) controlla se (CPUID(1).EAX & 0xFF0) == 0x6D0, identificando la presenza di un Pentium M su chipset i855. Le CPU precedenti come FMR5 (AMD K6-2) e FMR6 (Intel Celeron Mobile, family 6 model 8/0xB — montata sulla mia unità) adottano invece il percorso legacy: accessi diretti tramite istruzioni inp/outp per ogni porta, memoria ISA da 0xD3000 a 0xFFFFF gestita come memoria fisica lineare e totale assenza di PCI bridge. In questo scenario ho ricreato il selettore 0x34 ricorrendo alla funzione DPMI 000Dh, configurando base 0 e limit fissato a 0x0010FFFF.

L’architettura degli interrupt a tre livelli

Comprendere la gestione degli interrupt è essenziale, poiché le linee indicate come “IRQ 5/6” per il C331 non corrispondono a ciò che si potrebbe dare per scontato:

  • ISR_C_HWIRQ (in BASE.DLL): gestisce gli interrupt hardware fisici del controller 8259. Soltanto le linee IRQ da 8 a 12 e la 15 sono contrassegnate come utilizzabili.
  • ISRB_C_HWIRQ (in CMUDRV, solo su hardware FMR7): si occupa del demultiplexing attraverso il bridge PCI.
  • ISRX_C_HWIRQ (in CMUDRV): gestisce i cosiddetti “IRQ virtuali” da 0 a 27 mappati sui registri dell’FPGA alle porte di I/O 0x178–0x17B. Per configurare la maschera di abilitazione si scrive un valore con bit 7 impostato a 0; per inviare l’acknowledge di interrupt si scrive con bit 7 a 1, mentre la lettura restituisce i bit delle richieste pendenti. I segnali “IRQ 5” e “IRQ 6” del controller C331 corrispondono in realtà ai bit 5 e 6 mappati sulla porta 0x178.

La gestione dell’heap e la sua risoluzione

Il primo vero scoglio è stato l’allocatore di memoria: all’interno del costruttore XI a priorità 0x24, BASE.DLL tenta di ridimensionare e limitare l’heap interrogando l’offset c_main + 0x0C per conoscere i limiti reali della memoria. Eseguendo una semplice mappatura statica dell’immagine binaria, tali variabili globali rimanevano a zero, provocando il fallimento immediato del costruttore con il messaggio d’errore heap: can't restrict. Ho aggirato l’ostacolo creando un pool di memoria isolato da 8 MiB gestito tramite TLSF: le implementazioni di malloc, free e realloc del firmware, le relative funzioni di query e la struttura c_main + 0x0C puntavano tutte a questa regione coerente, mentre TRACK.EXE manteneva separato il proprio heap CRT. In questo modo le asserzioni di validità dell’heap venivano superate con successo e senza dover neutralizzare il codice di controllo.

L’ordine sequenziale con cui vengono inizializzati i servizi di BASE, verificato a disassemblatore, è il seguente: requestor backend (0x004E09FE), objectset (0x004F887D), pool di messaggi in RAM (0x0050E7C7), translator (0x004DCA43), timer di sistema (0x00501CAC), agency (0x004149CC), code di messaggi (0x0041C64F), dispatcher (0x00418EB6) e infine userbase (0x0041F07D). Registrare manualmente ogni record di agency o coda in maniera arbitraria si rivela fallimentare: i servizi proprietari rifiutano categoricamente le istanze duplicate.

Dove si è arrestata l’esecuzione

In modalità simulazione il loader riusciva a completare entrambi gli install hook e la fase sincrona dello STU group 0; il dword di task-ready all’indirizzo 0x004EFA98 commutava regolarmente a 1 e l’ultima sessione convalidata aveva gestito con successo 28 chiamate ai servizi Phar Lap senza alcun rifiuto. Fino a questo stadio l’approccio sembrava vincente.

Il blocco definitivo si è manifestato durante la diagnostica STU, che restituiva costantemente il codice di stato 0x044D durante la fase di dispatch del costruttore del task. L’origine del problema è chiara: la chiamata a Parameter::Write_show (a 0x0043A781) viene respinta perché il ciclo di vita dell’oggetto Parameter rimane bloccato alla fase 0. Le tracce del meccanismo di overlay evidenziano che, caricando la sequenza CMU.DL1 → AUDIO.DL2 → RF.DL2, si riesce a raggiungere i costruttori RF; tuttavia, il modulo RF va in errore richiamando Userbase::GetReference con codice di stato 0x1DB1 prima ancora di effettuare qualsiasi transizione di fase in Parameter. Di conseguenza, il ramo di caricamento a cascata (CMU/AUDIO/wrapper/RF) è stato abbandonato; l’inizializzazione diretta del modulo wrapper restituisce d’altronde il codice 0x0528, che segnala un’istanza Translator non valida (codice -2).

Due codici di ritorno specifici permettono di risparmiare ore di reverse engineering: l’assenza dell’inizializzazione della memoria RAM produce l’errore 0x057A da parte di Userbase::ChangeValue; se invece a mancare è l’inizializzazione del Translator, il Dispatcher risponde con il codice 0x0514. Per quanto riguarda il sottosistema Parameter, le routine Parameter::Install (a 0x00439BF6) e parameter_installMachine (a 0x00451347) sono responsabili della transizione alla fase 3; tuttavia, le sonde diagnostiche in sola lettura indicavano costantemente active=-1 phase=0 installing=0. Nello specifico, la chiamata Write_show che fallisce riceve come quinto parametro un valore non valido, con la successiva chiamata verso il Dispatcher che assume argomenti (-2, -1).

I nodi aperti

Il tassello mancante è la registrazione formale della macchina e delle reference all’interno di Userbase, procedura strettamente legata al contesto dei feature group gestito dall’overlay manager originale. Le funzioni responsabili sono state individuate: Overlay::Init (0x0048F793), Overlay::InitFgrpInstall (0x00492893) e Overlay::InstallCurrFgrp (0x00492BCE). Tuttavia, Overlay::Init fa affidamento sul servizio Phar Lap 2543h per gestire l’accounting dei page fault, una funzionalità che il mio shim DPMI minimale non emula.

Per completare quel filone sarebbe stato necessario implementare e validare l’emulazione del servizio 2543h con il relativo conteggio dei page fault. Ho escluso deliberatamente la forzatura statica dell’istanza del Translator: aggirare quel passaggio avrebbe invalidato il senso dell’intero esperimento di emulazione dell’ambiente host.

Un singolo modulo descrive alla perfezione la complessità che ha portato all’abbandono del ramo: rf____aa.dll è un file binario costituito unicamente da descrittori, con entry point PE impostato a RVA 0. Saltare all’indirizzo RVA 0 comporterebbe l’esecuzione casuale dei byte dell’header MZ. La sua funzione dllcontrol_initDll presuppone che la word 0 del descrittore sia pre-inizializzata con il puntatore alla callback che l’overlay loader di BASE.EXE recupera dall’indirizzo 0x00A1263E (ossia Translator::CallSubroutine a 0x004DF300, deputata a inoltrare la richiesta 0x1603). Senza questo aggancio la catena si arresta sul nascere, e nessuna modifica alla sequenza temporale dei caricamenti è in grado di compensarlo.

A ciò si sommano due anomalie intrinseche scoperte nel firmware simulato: la funzione C331 get_version (a 0x00431235) richiede un payload di 48 byte ma ne prevede solo 46 all’interno del buffer di test da 50 byte allocato a 0x0059F818, mentre il task per la lettura delle info scheda RXTX (a 0x00520950) scarta qualunque messaggio STU che non sia di tipo INIT (rxtx_bic.cpp:173). Quest’ultimo punto rimane irrisolto, non essendo mai stato registrato il completamento dello STU group 1.

In sintesi: la scrittura sui registri del C331, l’erogazione del segnale RF, la misura calibrata con l’analizzatore e l’esecuzione su hardware reale non sono mai state convalidate attraverso questo percorso. Il backend software falliva intenzionalmente le sue fasi di bring-up, un esito corretto e prevedibile: non rappresentava una soluzione di tracking pronta all’uso né tanto meno distribuibile.

L’architettura effettivamente funzionante a bordo dello strumento segue una logica del tutto differente: nessun riutilizzo delle DLL proprietarie, ma codice scritto da zero a basso livello per gestire il download dei bitstream negli FPGA, la mailbox del processore COR, l’interfaccia I2C bit-banged e il bootstrap del DSP. Richiede una mole di reverse engineering notevolmente superiore, ma offre il pieno controllo dell’hardware ed è pienamente operativa.

Post Disclaimer

Creative common license BY-NC_SA

Informazioni Importanti

Note generali: Le informazioni contenute in questo articolo sono di carattere informativo e rispecchiano le opinioni personali del autore. Tutte le guide nel sito vengono proposte "as it is" puramente a scopo didattico. L'utente che accetta di seguirne i passaggi si assume ogni responsabilità in caso di guasto/malfunzionamento o altro problema come conseguenza della modifica.

Link di affiliazione e contenuti promozionali: Nei post di iu2frl.it posso includere collegamenti a rivenditori. Posso ricevere una piccola commissione dal rivenditore se effettui un acquisto dopo aver fatto clic su uno di questi link. I post non sono espressamente sponsorizzati da rivenditori, editori, promotori o produttori, se non diversamente specificato chiaramente e tutte le decisioni editoriali sono prese esclusivamente dagli autori dei singoli articoli.

Contenuti riguardanti regolamenti e/o normative: Eventuali riferimenti a normative non costituiscono valore legale, si tratta di libere interpretazioni ed estratti di circolari corredate da eventuali commenti, si invitano tutti gli utenti a verificare la veridicità di tali informazioni sugli organi ufficiali di riferimento, nessuna colpa o responsabilità può essere data agli autori degli articoli.

Licenza di utilizzo: Tutti i contenuti vengono condivisi con licenza CC BY-NC-SA 4.0: Questa licenza consente ad altri di remixare, adattare e sviluppare i contenuti in modo non commerciale, purché accreditino l'autore originale e concedano in licenza le loro nuove creazioni con gli stessi termini. Per maggiori informazioni visitare il sito Creative Commons.

Important Informations

General notes: The information contained in this article is of an informative nature and reflects the personal opinions of the author. All the guides/tutorial on the website are offered "as it is" for educational purposes only. The user who agrees to follow the steps assumes all responsibility in case of failure/malfunctioning or other problem as a result of the modification.

Affiliate links and promotional products: In some posts of iu2frl.it I can include links to resellers. I can get a small commission from the reseller if you make a purchase after clicking on one of these links. The posts are not expressly sponsored by resellers, publishers, promoters or producers, unless otherwise clearly specified and all editorial decisions are made solely by the authors of the individual articles.

Contents about rules and laws: Some articles may contain portions or whole laws or rules regarding specific areas, these kind of content are meant to be indicative only, no responsability can be given to the authors. Always refer to official sources when looking for rules or laws.

Contents licenses: All the contents are published as CC BY-NC-SA 4.0: This license lets others remix, adapt, and build upon your work non-commercially, as long as they credit you and license their new creations under the identical terms.. For more informations please visit Creative Commons website.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *