Newsgroup: it.comp.os.linux.development
Titolo: Chiamate di sistema...

Ciao a tutti, mi sono da poco avvicinato alla programmazione Linux (provengo
da sigh... WinZozz...) e ho alcuni dubbi.
In particolare non mi è molto chiaro il funzionamento delle cosiddette
"chiamate di sistema": sono per caso l'analogo dell'interrupt DOS in M$-DOS?
Ovvero: vediamo se ho capito qualcosa: quando io scrivo "fork" in un mio
programma C, esiste una libreria che contiene una funzione "fork", la cui
implementazione consiste praticamente nel chiamare una funzione del Sistema
Operativo, probabilmente con un interrupt software. E' giusto?
Esiste qualche sito dove posso imparare queste cose?
GRAZIE
Daniele.

Esiste qualche sito dove posso imparare queste cose?
ftp://ftp.redhat.com/home/johnsonm/khg.tar.gz
Se non lo trovi (non ho controllato il link), fai una ricerca di
"Linux Kernel Hackers' Guide"
-- 
Lorenzo
"Given enough eyeballs, all bugs are shallow", Linus'Law
(per rispondere via email fai un rot13 dell'indirizzo)
(apply a rot13 to reply)

 potrebbero offrire alcuna protezione.
Ti ringrazio per la risposta, ma mi potresti fare un semplice esempio di
cosa accade quando in un mio programma scrivo "fork"? Cioč: al momento della
compilazione / linkaggio cosa viene sostituito a "fork"?
Durante l'esecuzione, cosa avviene? (Nel senso di cosa capita al program
counter, non cosa fa il fork!)
GRAZIE
Daniele.


#include <unistd.h>
int main(int argc, char *argv[])
{
        fork();	
        return 0;
}
Vediamo un po`...
(gdb) disassemble main
Dump of assembler code for function main:
0x8048300 <main>:       pushl  %ebp
0x8048301 <main+1>:     movl   %esp,%ebp
0x8048303 <main+3>:     call   0x804826c <fork>  <==============
0x8048308 <main+8>:     xorl   %eax,%eax
0x804830a <main+10>:    jmp    0x8048310 <main+16>
0x804830c <main+12>:    leal   0x0(%esi,1),%esi
0x8048310 <main+16>:    movl   %ebp,%esp
0x8048312 <main+18>:    popl   %ebp
0x8048313 <main+19>:    ret
End of assembler dump.
(gdb) disassemble fork
Dump of assembler code for function fork:
0x804826c <fork>:       jmp    *0x80493a4  <==============
0x8048272 <fork+6>:     pushl  $0x0
0x8048277 <fork+11>:    jmp    0x804825c <_init+44>
End of assembler dump.
(gdb) disassemble 0x80493a4
Dump of assembler code for function _GLOBAL_OFFSET_TABLE_:
0x8049398 <_GLOBAL_OFFSET_TABLE_>:      movb   $0x93,%al
0x804939a <_GLOBAL_OFFSET_TABLE_+2>:    addb   $0x8,%al
0x804939c <_GLOBAL_OFFSET_TABLE_+4>:    addb   %al,(%eax)
0x804939e <_GLOBAL_OFFSET_TABLE_+6>:    addb   %al,(%eax)
0x80493a0 <_GLOBAL_OFFSET_TABLE_+8>:    addb   %al,(%eax)
0x80493a2 <_GLOBAL_OFFSET_TABLE_+10>:   addb   %al,(%eax)
0x80493a4 <_GLOBAL_OFFSET_TABLE_+12>:   jb     0x8049328  <============
0x80493a6 <_GLOBAL_OFFSET_TABLE_+14>:   addb   $0x8,%al
0x80493a8 <_GLOBAL_OFFSET_TABLE_+16>:   (bad)
0x80493a9 <_GLOBAL_OFFSET_TABLE_+17>:   (bad)
0x80493aa <_GLOBAL_OFFSET_TABLE_+18>:   addb   $0x8,%al
0x80493ac <_GLOBAL_OFFSET_TABLE_+20>:   addb   %al,(%eax)
0x80493ae <_GLOBAL_OFFSET_TABLE_+22>:   addb   %al,(%eax)
End of assembler dump.
Quello che segue e` tratto da KHG e valeva per Linux 0.99.x
Forse ora e` cambiato, non so.
Under Linux the execution of a system call is invoked by a maskable
interrupt or exception class transfer, caused by the instruction int
0x80. We use vector 0x80 to transfer control to the kernel. This
interrupt vector is initialized during system startup, along with
other important vectors like the system clock vector.
ps. int 0x80 e` eseguito in protect-mode, non ha nulla a che vedere
    con gli interrupt dell'msdos.


 potrebbero offrire alcuna protezione.
Se non erro anche in Linux (come in NT) a basso livello le chiamate di
sistema si risolvono proprio con una chiamata a un interrupt.
Chiaramente il funzionamento non e` semplice come sotto al DOS, ma la
similitudine mi sembra corretta.
---
Bye! Lorenzo Lutti
http://www.geocities.com/SiliconValley/Peaks/6258/


Si, anch'io credevo cosi` all'inizio pero` poi vedendo questo codice
mi e` venuto il dubbio...
ENTRY(system_call)
        pushl %eax                      # save orig_eax
        SAVE_ALL
        GET_CURRENT(%ebx)
        cmpl $(NR_syscalls),%eax
        jae badsys
        testb $0x20,flags(%ebx)         # PF_TRACESYS
        jne tracesys
        call *SYMBOL_NAME(sys_call_table)(,%eax,4)  <============ !!!
        movl %eax,EAX(%esp)             # save the return value
Immagino che int 0x80 venga eseguito in userspace dal processo
chiamante ma diassemblando il codice con la fork() che ho usato
come esempio non ho trovato niente di simile.
(gdb) disassemble main
Dump of assembler code for function main:
0x8048300 <main>:       pushl  %ebp
0x8048301 <main+1>:     movl   %esp,%ebp
0x8048303 <main+3>:     call   0x804826c <fork>  <==========
0x8048308 <main+8>:     xorl   %eax,%eax
0x804830a <main+10>:    jmp    0x8048310 <main+16>
0x804830c <main+12>:    leal   0x0(%esi,1),%esi
0x8048310 <main+16>:    movl   %ebp,%esp
0x8048312 <main+18>:    popl   %ebp
0x8048313 <main+19>:    ret
End of assembler dump.
(gdb) disassemble fork
Dump of assembler code for function fork:
0x804826c <fork>:       jmp    *0x80493a4  <==========
0x8048272 <fork+6>:     pushl  $0x0
0x8048277 <fork+11>:    jmp    0x804825c <_init+44>
End of assembler dump.
(gdb) disassemble 0x80493a4
Dump of assembler code for function _GLOBAL_OFFSET_TABLE_:
0x8049398 <_GLOBAL_OFFSET_TABLE_>:      movb   $0x93,%al
0x804939a <_GLOBAL_OFFSET_TABLE_+2>:    addb   $0x8,%al
0x804939c <_GLOBAL_OFFSET_TABLE_+4>:    addb   %al,(%eax)
0x804939e <_GLOBAL_OFFSET_TABLE_+6>:    addb   %al,(%eax)
0x80493a0 <_GLOBAL_OFFSET_TABLE_+8>:    addb   %al,(%eax)
0x80493a2 <_GLOBAL_OFFSET_TABLE_+10>:   addb   %al,(%eax)
0x80493a4 <_GLOBAL_OFFSET_TABLE_+12>:   jb     0x8049328  <=========
0x80493a6 <_GLOBAL_OFFSET_TABLE_+14>:   addb   $0x8,%al
0x80493a8 <_GLOBAL_OFFSET_TABLE_+16>:   (bad)
0x80493a9 <_GLOBAL_OFFSET_TABLE_+17>:   (bad)
0x80493aa <_GLOBAL_OFFSET_TABLE_+18>:   addb   $0x8,%al
0x80493ac <_GLOBAL_OFFSET_TABLE_+20>:   addb   %al,(%eax)
0x80493ae <_GLOBAL_OFFSET_TABLE_+22>:   addb   %al,(%eax)
End of assembler dump.
(gdb) disassemble 0x8049328
No function contains specified address.
0x8049328 non sembra appartenere all'address space del processo...
... e non c'e` traccia di int 0x80.
Boh :-)


Ciao,
per il meccanismo d'invocazione di un system call si veda
/usr/include/i386/syscall.h
in particolare INT 80h è invocato in user mode. La reale differenza con
l'utilizzo che viene fatto degli interrupts nel DOS è nell'handling. In
linux abbiamo il passaggio al kernel mode in risposta ad INT 80h (trap).
l'invocazione di una syscall a 2 argomenti, effettua (si veda appunto
syscall.h):
push ebx
mov ebx, edx
int 0x80
pop ebx
niente di speciale...
ciao.

come esempio non ho trovato niente di simile.
Ma hai linkato staticamente il programma? Altrimenti non credo che
tu possa trovare INT 80h nel codice.
Leonardo
".signature": bad command or file name

 ... e non c'e` traccia di int 0x80.
Forse dovevi "addentrarti" di piu` nel disassemblaggio... ad esempio in
NT prima dell'INT vengono fatte diverse chiamate "intermedie", anche in
kernel mode.


tu possa trovare INT 80h nel codice.
Giusto, tutto torna.
