Emulating Linus Torvalds: Cruthaigh do chóras oibriúcháin féin ón tús (III)

Leanaimid leis an tsraith post seo ar conas ár gcóras oibriúcháin a chruthú. Nílimid chun díriú ar ábhar amháin inniu ach táimid chun roinnt feidhmeanna úsáideacha a shainiú as seo amach. Ar dtús táimid chun 3 fheidhm a shainiú a chomhlíonann feidhm memcpy, memset y memcmp:

void* ND::Memory::Set(void* buf, int c, size_t len)
{
unsigned char* tmp=(unsigned char*)buf;
while(len--)
{
*tmp++=c;
}
return buf;
}
void* ND::Memory::Copy(void* dest,const void* src, size_t len)
{
const unsigned char* sp=(const unsigned char*)src;
unsigned char* dp=(unsigned char*)dest;
for(;len!=0;len--) *dp++=*sp++;
return dest;
}
int ND::Memory::Compare(const void* p1, const void* p2, size_t len)
{
const char* a=(const char*)p1;
const char* b=(const char*)p2;
size_t i=0;
for(;i<len;i++)
{
if(a[i] < b[i]) return -1; else if(a[i] > b[i])
return 1;
}
return 0;
}

Tá gach ceann acu féin-chur i bhfeidhm. Na feidhmeanna seo a thóg mé ó leabharlann bheag C, is gnách go mbíonn an cur chun feidhme cosúil i ngach córas oibriúcháin. Anois táimid chun 3 fheidhm insamhalta a dhéanamh ach teaghráin a ionramháil. Chomhlíonfaidís feidhm strcpy, strcat y strcmp.

size_t ND::String::Length(const char* src)
{
size_t i=0;
while(*src--)
i++;
return i;
}
int ND::String::Copy(char* dest, const char* src)
{
int n = 0;
while (*src)
{
*dest++ = *src++;
n++;
}
*dest = '';
return n;
}
int ND::String::Compare(const char *p1, const char *p2)
{
int i = 0;
int failed = 0;
while(p1[i] != '' && p2[i] != '')
{
if(p1[i] != p2[i])
{
failed = 1;
break;
}
i++;
}
if( (p1[i] == '' && p2[i] != '') || (p1[i] != '' && p2[i] == '') )
failed = 1;
return failed;
}
char *ND::String::Concatenate(char *dest, const char *src)
{
int di = ND::String::Length(dest);
int si = 0;
while (src[si])
dest[di++] = src[si++];
dest[di] = '';
return dest;
}

Táimid ag dul anois le roinnt feidhmeanna suimiúla. Leis na feidhmeanna seo is féidir linn na calafoirt crua-earraí a léamh agus a scríobh. De ghnáth déantar é seo le ASM agus comhfhreagraíonn sé (ar x86) do na treoracha in y amach. Chun ASM a ghlaoch go héasca ó C, bain úsáid as an treoir asm, leis an gcontúirt go mbaineann sé leis nach bhfuil sé iniompartha. Leis an abairt seo cuirimid an so-ghalaithe ionas nach ndéanfaidh GCC iarracht an téacs sin a bharrfheabhsú. Ar an láimh eile, tá bealach aisteach ag an treoir asm chun paraiméadair a ghlacadh, ach is dóigh liom go dtuigtear níos fearr é sin trí fhéachaint ar na samplaí.

void ND::Ports::OutputB(uint16_t port, uint8_t value)
{
asm volatile("outb %1, %0" : : "dN"(port), "a"(value));
}
uint8_t ND::Ports::InputB(uint16_t _port)
{
unsigned char rv;
asm volatile("inb %1, %0" : "=a"(rv) : "dN"(_port));
return rv;
}

Agus go dtí seo tar éis 3, inniu níl aon rud gleoite déanta againn ach tá feidhmeanna sainithe againn a thiocfaidh chun leasa don todhchaí. Fógra d’úsáideoirí 64-giotán go bhfuilim ag obair ar shocrú a bug a choisceann tiomsú i gceart i 64 ghiotán. Sa chéad phost eile feicfimid comhpháirt thábhachtach d’ailtireacht x86, an GDT.


Cloíonn ábhar an ailt lenár bprionsabail eitic eagarthóireachta. Chun earráid a thuairisciú cliceáil anseo.

9 trácht, fág mise

Fág do thrácht

Ní thabharfar do sheoladh r-phoist a fhoilsiú. Réimsí riachtanacha atá marcáilte le *

*

*

  1. Freagrach as na sonraí: Miguel Ángel Gatón
  2. Cuspóir na sonraí: SPAM a rialú, bainistíocht trácht.
  3. Legitimation: Do thoiliú
  4. Na sonraí a chur in iúl: Ní chuirfear na sonraí in iúl do thríú páirtithe ach amháin trí oibleagáid dhlíthiúil.
  5. Stóráil sonraí: Bunachar sonraí arna óstáil ag Occentus Networks (EU)
  6. Cearta: Tráth ar bith is féidir leat do chuid faisnéise a theorannú, a aisghabháil agus a scriosadh.

  1.   ainm a dúirt

    A ligean ar a fheiceáil má dhéanann tú trácht ar conas an fabht a réiteach, mar níor tháinig mé ar aghaidh ón gcéad chuid.

    1.    O_Pixote_O a dúirt

      Sílim go ndearna siad trácht ar an mbotún i dtuairimí phost 2. Shíl siad gur rud éigin ón grub a bhí ann más cuimhin liom i gceart

  2.   Claigeann gorm a dúirt

    Cóipeáil beannacht le slán?

    1.    Claigeann gorm a dúirt

      Beart byte ar ndóigh ..., ní éiríonn le 2 theip as a chéile, dearbhaithe.

  3.   ruby232 a dúirt

    Go raibh míle maith agat as an bpost an-mhaith agus táim á leanúint, tá roinnt ceisteanna agam:
    1. Nuair a deir tú ‘ASM a ghlaoch go héasca ó C úsáidtear an treoir asm, agus an baol ann go mbeidh sé iniompartha’, cad a chiallaíonn tú nuair a deir tú ‘leis an gcontúirt go bhfuil sé iniompartha nach bhfuil sé iniompartha '?

    2. Dá ndéanfaí córas oibriúcháin ‘gairmiúil’ (mar a déarfá) dhéanfaí an chuid seo de rochtain a fháil ar an gCrua-earraí in Assembler.

    3. Conas a dhéanfaí in Assembler?

    1.    AdrianArroyoStreet a dúirt

      Go raibh maith agat as é a leanúint, freagróidh mé na ceisteanna ceann ar cheann:
      1- Bhuel, is í an fhadhb leis an treoir asm ná nach bhfuil sé ann in aon chaighdeán C, mar sin cuireann gach tiomsaitheoir i bhfeidhm é ar a bhealach féin (má chuireann sé i bhfeidhm é). Sa chás seo is féidir é a thiomsú le GCC agus Clang (tá an chuma air go bhfuil sé cosúil le GCC ina leith seo) ach ní bheidh tú in ann i dtiomsaitheoirí eile cosúil le Intel C (úsáideann sé seo Comhréir Intel i ASM).
      2- Go gairmiúil, ba cheart ailtireacht agus cuid eile a bheith scartha go soiléir ó chuid amháin agus ó chuid eile. Ní gá é a dhéanamh i gcóimeálaí (tá taobh istigh de C ag Linux)
      3- Maidir le cóimeálaí tá sé an-simplí freisin, ach tá sé agat i gcomhad ar leithligh. Ar an láimh eile, má bhíonn argóintí againn ní mór dúinn é a chur ar aghaidh chuig na cláir ar dtús agus is féidir leis sin beagán níos mó a dhéanamh, ansin tugtar outb nó inb agus dearbhaítear go bhfuil an fheidhm infheicthe ar fud an domhain. Ansin ó C caithfidh tú ceanntásc a dhéanamh a dhearbhaíonn feidhm “sheachtrach”. Rud mar seo a bheadh ​​i NASM (Comhréir Intel):
      outb:
      ebp a bhrú
      mov ebp, esp

      mov eax, [ebp + 12]
      mov edx, [ebp + 8]

      amach dx, al

      mov esp, ebp
      pop ebp
      dhiúltú

  4.   Max a dúirt

    Ceist, cén chomhréir a úsáideann tú? Ní thuigim cén fáth a bhfuil an oiread sin asm xD MASM, FASM, NASM, AT & T ...
    Agus má tá am agat, an bhféadfá an líne a mhíniú:
    asm luaineach ("outb% 1,% 0" :: "dN" (port), "a" (luach));

    Go dtí go raibh "asm luaineach" thuig mé xD "outbyte 1,0?"
    Nó an é 1 -> »dN» (port), 0 -> «a» (luach)?
    Más é an dara ceann é, ní thuigim cad is "dn" ann agus cad is "a" ...

    Go raibh míle maith agat as do chuid ranníocaíochtaí! Dochreidte !!

    1.    AdrianArroyoStreet a dúirt

      Is í an chomhréir a úsáidim ná AT&T agus is é sin a úsáideann GCC go hinmheánach cé gur féidir é a dhéanamh gan fadhbanna i NASM (an chomhréir a oiriúnú). Maidir leis an ráiteas casta sin asm luaineach ní féidir liom a rá leat ach go bhfuil sé amhlaidh mar gheall ar an GCC ós rud é go n-úsáideann sé roinnt paraiméadair chun a fháil amach conas ba cheart na sonraí a rith. Mar shampla, is ceoltóir speisialta x86 é "a" a úsáidtear chun an clár a léiriú. Tá an liosta iomlán anseo: http://gcc.gnu.org/onlinedocs/gcc/Constraints.html#Constraints

  5.   charizardfire52 a dúirt

    bhuel, teastaíonn cúnamh uaim i ndáiríre, is rud nua dom é seo agus níl an smaoineamh is lú agam cad atá le déanamh leis an méid atá scríofa sa chríochfort, an féidir le duine cabhrú liom?