[assembly] syscall

[Teo@Unix]

ciao, ho una domanda semplice...

in assembly quando utilizzo le syscall per sistemare gli argomenti in molti casi vedo che devo sistemare questi nei registri, altre volte nello stack.... con push

con che criterio alcune volte nei registri altre nello stack? dipende dalla syscall?
mi chiarite un attimo le idee?

grazie.

[Teo@Unix]

mi pare di aver capito che se sono in user mode è necessario che io li passi nei registri, invece in kernelmode vanno passati nello stack...

quindi... io posso scrivere un listato assembly dove gli argomenti li passo nello stack?

[cdimauro]

Dipende esclusivamente dal sistema operativo e dall'architettura del processore.

Ad esempio, con AmigaOS alle chiamate di sistema si passavano tutti gli argomenti nei registri del 68000 (ne aveva 16).

[Teo@Unix]

a ecco grazie!

difatti...
sto programmando su un debian... e stavo scrivendo passando gli argomenti nello stack.... li ho sempre passati nei registri... quindi deduco che il codice non funzionerà..... nè?

[cdimauro]

Chiaro. Se li aspetta nello stack, vedrai i fuochi d'artificio.

[Teo@Unix]

... ... però trovo esempi dove vengono usati registri e argomenti nello stack, ad esempio questo dovrebbe utilizzare la syscall socketcall che è la numero 102.

push	byte	0x0
push	byte	0x1
push	byte	0x2

mov	eax, 	0x66
mov	ebx, 	0x1
mov	ecx, 	esp
int 	0x80

percè ci sono quei push??

se volessi usare i registri la farei così: (perdona la sintassi )

movl $0x6, %edx	         // 3° argomento
movl $0x1, %ecx	         // 2° argomento 
movl $0x2, %ebx	         // 1° argomento
mov $0x66, %al		// Sistemo 102 (_NR_socketcall) in AL
int $0x80		// socket()

difatti la mia per ora mi pare che non funziona....
che mi sfugge?

[Teo@Unix]

a ok, ho capito.... ........ leggersi la doc. serve a qualcosa...

socketcall ha la sintassi seguente:
int socketcall(int call, unsigned long *args);

quindi a seconda di call chiamo la funzione della famiglia che voglio (socket(), bind() ecc...) e gli argomenti me li metto da qualche parte e faccio riferimento ad essi con un puntatore che passo a socketcall().

... dovrebbe essere così... ora provo a riscrivermi il tutto ..... mi confermate?

[Teo@Unix]

ok.... quindi dovrei aver risolto....

mi rimane un solo problema... la syscall dup2()... che non so perchè non ne vuole sapere di andare...

ma non vedo proprio che ci può essere di sbagliato...

questo è il pezzo di codice che mi da problemi:

[ .............]
       int $0x80		// accept()

	xorl %ebx, %ebx		// effettuo un controllo sul risultato di accept()
	cmpl %eax, %ebx
	jb end
	movl %eax, %ebx         // Nuovo socket, sarà il 1° argomento di dup2

	xorl %eax, %eax
        movl %edx, %ebx    	// socket
        movb $6, %al	     	// Sistemo 6 (_NR_close) in AL
        int $0x80		// close()

	xorl %eax, %eax		// Azzero EAX
	xorl %ecx, %ecx		// Azzero ECX, il 2° argomento di dup2 (stdin)
	movb $0x3f, %al		// Sistemo 63 (_NR_dup2) in AL
	int $0x80		// dup2()

	xorl %eax, %eax		// Azzero EAX
	incl %ecx		// ora stdout
	movb $0x3f, %al		// Sistemo 63 (_NR_dup2) in AL
	int $0x80		// dup2()

	xorl %eax, %eax		// Azzero EAX
	incl %ecx		// ora stderr
	movb $0x3f, %al		// Sistemo 63 (_NR_dup2) in AL
	int $0x80		// dup2()

	xorl %eax, %eax		//Azzero eax
[......................]

se bypasso le chiamate a dup2 il programma funziona, altrimenti termina inspiegabilmente.... c'è qualcosa che mi impedisce di effettuare queste chiamate?

ci sto impazzendo grazie mille!

[cdimauro]

Da quel che leggo, dup2 vuole come primo parametro il vecchio fd e come secondo il nuovo fd da utilizzare.

Nel tuo codice vedo che il primo argomento (il vecchio fd) è sempre 63, mentre il secondo (il nuovo fd) è 0, 1 e 1 rispettivamente (quest'ultimo dovrebbe essere 2 per stderr, quindi già qui ci sarebbe un errore).

Non mi suona bene. Esattamente cosa vorresti ottenere con quel pezzo di codice?

Inoltre potresti provare intanto con una sola dup2, e vedere cosa ti restituisce in uscita.

[Teo@Unix]

praticamente dovrei redirigere i canali standard di comunicazione sul socket,

dup2 è la syscall numero 63, che infatti metto in AL, non centra nulla con gli argomenti.

Poi il primo argomento è in EBX, che sarebbe il socket ritornato da accept.
E il secondo argomento sono gli fd 0, 1 ,2 stdin, stdout e stderr.

l'equivalente in C:

cli=accept(soc,0,0);		//#define __NR_socketcall	102
dup2(cli,0);			//#define __NR_dup2	63
dup2(cli,1);
dup2(cli,2);

ho tolto la close() per ora perchè ho visto che vi era un errore.

ho provato anche ad eliminare le ultime due dup2 ma anche la prima sembra provocare l'errore.

...... ma aspetta! ti sembra corretto il controllo del valore di ritorno di accept?

[Teo@Unix]

sembrerebbe sia la accept ora a darmi problemi...

ti posto il codice con la accept:

	xorl %eax, %eax		// Azzero EAX
	incl %eax
	pushl %eax		// 1 nello stack
	pushl %edx		// socket
	movl %esp, %ecx
	movb $0x4, %bl		// n° socketcall listen
        movb $0x66, %al         // Sistemo 102 (_NR_socketcall) in AL	
	int $0x80		// listen()

	xorl %eax, %eax		// Azzero...
        xorl %ebx, %ebx
        pushl %eax		// 0 nello stack, 2° arg. di accept()
        pushl %eax		// 0 nello stack, 3° arg. di accept()
	pushl %edx        	// socket, 1° arg.
        movl  %esp, %ecx	// *args
        movb $0x5, %bl     	// n° socketcall accept
        movb $0x66, %al    	// Sistemo 102 (_NR_socketcall) in AL	
        int $0x80		// accept()

	xorl %ebx, %ebx		// effettuo un controllo sul risultato di accept()
	cmpl %eax, %ebx
	jb end
	movl %eax, %ebx         // Nuovo socket, sarà il 1° argomento di dup2

	xorl %eax, %eax		// Azzero EAX
	xorl %ecx, %ecx		// Azzero ECX, il 2° argomento di dup2 (stdin)
	push $0x3f
	pop %eax		// Sistemo 63 (_NR_dup2) in AL
	int $0x80		// dup2()

	xorl %eax, %eax		// Azzero EAX
	incl %ecx		// ora stdout
	push $0x3f
	pop %eax		// Sistemo 63 (_NR_dup2) in AL
	int $0x80		// dup2()

	xorl %eax, %eax		// Azzero EAX
	incl %ecx		// ora stderr
	push $0x3f
	pop %eax		// Sistemo 63 (_NR_dup2) in AL
	int $0x80		// dup2()

[cdimauro]

Francamente non riesco a vedere dove potrebbe essere il problema.

[Teo@Unix]

alla fine sono risalito al problema...

era il controllo del valore di ritorno di accept. Non ho capito però esattamente. Come se il salto non fosse corretto, ma non credo sia nemmeno questo perché anche se inteso come salto corto doveva funzionare... fatto sta che ora funziona con questa versione:

..............
        xorl %eax, %eax		// Azzero...
        xorl %ebx, %ebx
        pushl %eax		// 0 nello stack, 2° arg. di accept()
        pushl %eax		// 0 nello stack, 3° arg. di accept()
	pushl %edx        	// socket, 1° arg.
        movl  %esp, %ecx	// Posiziono puntatore arg.
        movb $0x5, %bl     	// n° socketcall accept
        movb $0x66, %al    	// Sistemo 102 (_NR_socketcall) in AL	
        int $0x80		// interrupt accept()

	movl %eax, %ebx		// New socket
	
	// int dup2(int oldfd, int newfd);

	xorl %eax, %eax		// Azzero EAX
	xorl %ecx, %ecx		// Azzero ECX, il 2° argomento di dup2 (stdin)
	push $0x3f		//
	pop %eax		// Sistemo 63 (_NR_dup2) in AL
	int $0x80		// interrupt dup2()
.............

grazie. Ciao.