[fano]

Originariamente inviato da tomminno

Quando si parla di compilare in nativo in questo caso si parla di un qualcosa tipo MSIL o di vero e proprio codice macchina?

Codice macchina, puro e semplice!

Originariamente inviato da tomminno

Nel secondo caso, se tutto gira in ring 0 cosa impedisce di andare ad eseguire istruzioni x86 privilegiate e fare danni in giro?

I livelli (che sono un'implementazione software dei ring) non ti permetteranno di fare questo:

https://github.com/CosmosOS/Cosmos/b...rnel/Levels.md

un'applicazione sarà sempre a livello 3 e quindi non potrà chiamare nessuna istruzione privilegiata (non puoi scrivere codice assembler a livello 3 e nemmeno codice unsafe probabilmente).
Certo uno "monello" potrebbe scrivere un SO "malvagio" che è un virus, ma questo cosa ti garantisce che una distribuzione Linux non possa fare lo stesso?

Originariamente inviato da tomminno

Per quanto riguarda la scrittura del .Net in C# (che è un linguaggio .Net) come si gestisce deterministicamente la memoria in C#?

Perché dovresti gestirla "deterministicamente" c'è il garbage collector una nostra versione (non quello classico di .NET).

Originariamente inviato da tomminno

Perchè il runtime gestisce la memoria in maniera deterministica, differentemente da un programma scritto per girare nel runtime.

Beh nei casi in cui sia necessario anche C# permette di allocare nello stack usando stackalloc.

Originariamente inviato da tomminno

Infine come si fa da C# ad accedere ai registri? Se sei un OS l'accesso ai registri è pane quotidiano. A maggior ragione se devi fare tutti i controlli sui permessi di accesso lato software senza basarti sulle funzionalità hardware.

Infatti tra quadre ho messo anche X# che il nostro High Level assembler per X86:

https://en.wikipedia.org/wiki/X_Sharp

qui siamo molto a basso livello (debug su porta seriale):
https://github.com/CosmosOS/Cosmos/b...ub/SerialIO.xs

dobbiamo ancora studiare come embeddare X# dentro C# per ora facciamo così, ma non ci soddisfa affatto:

https://github.com/CosmosOS/Cosmos/b...2CPU/IL/Add.cs

(tutto quello che inizia con XS è codice X# dentro C#)

probabilmente in futuro useremo qualcosa di simile a GCC:

inline X# = {
      ESI = 12345              // assign 12345 to ESI
      EDX = #constantForEDX    // assign #ConstantForEDX to EDX
      EAX = EBX                // move EBX to EAX              => mov ebx, eax
      EAX--                    // decrement EAX                => dec eax
      EAX++                    // increment EAX                => inc eax
      EAX + 2                  // add 2 to eax                 => add eax, 2
      EAX - $80                // subtract 0x80 from eax       => sub eax, 0x80
      BX * CX                  // multiply BX by CX            => mul cx      -- division, multiplication and modulo should preserve registers
      CX / BX                  // divide CX by BX              => div bx
      CX mod BX                // remainder of CX/BX to BX     => div bx
}

Per esempio quando ho implementato Conv.R.Un non mi ha soddisfatto come dichiarare le costanti questo dovrebbe essere più semplice, molto più semplice di come è ora... è anche molto difficile passare un valore da C# a X#.
Abbiamo ancora un po' da lavorare su questo.