Correct inline assembly code for sys_uname - c

Question

I have written inline assembly code for the system call sys_uname, but it doesn't seem to be correct.
#include <sys/utsname.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/syscalls.h>
#include <string.h>
struct utsname stroj;
__asm__ volatile("pushl $0;"
"pushl %%ebx;"
"pushl $0;"
"int $0x80;"
:
: "a" (SYS_uname), "b" (&stroj)
);
//uname(&stroj); -> when I do this it works, but again, I want to use inline assembly
write(1, stroj.nodename, strlen(stroj.nodename)); // 1 = stdout
Is there some glaring problem that I am not addressing? This write prints out nothing, literally "".

Answer 1

This answer assumes there is a reason why you wish to use system calls directly rather than through C library functions.
A version of the inline assembly that would be correct could look like:
#include <sys/utsname.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <string.h>
#include <unistd.h>
/* SYS_uname has the value 164 */
/* #define SYS_uname 164 */
#define SYS_uname SYS_freebsd4_uname
int main()
{
u_int syscallnum = SYS_uname;
struct utsname stroj;
asm("push %[stroj]\n\t"
"push %%eax\n\t" /* Required dummy value for int 0x80 */
"int $0x80\n\t"
"add $8, %%esp" /* 2*4 bytes removed from stack */
: "+a"(syscallnum) /* error code also returned in syscallnum */
: [stroj]"r"(&stroj)
: "memory");
write(1, stroj.nodename, strlen(stroj.nodename));
return 0;
}
With FreeBSD 32-bit system calls the parameters are pushed on the stack in reverse order. A dummy value (any value) has to be pushed on the stack before issuing int $0x80. You need to adjust the stack pointer ESP after the system call. Any registers that may change need to be dealt with as well. int $0x80 will return an error code in EAX. The code above returns that value back in the syscallnum variable. If you modify a register in inline assembly and don't let GCC know it can cause undefined behaviour that is often hard to hunt down.
If you pass addresses via registers you will need to add memory operands (even if they are dummies) to specify that the data at the pointer in the registers is being read and/or written to. Alternatively you can specify the memory clobber which may be easier to understand although is a more brute force approach.
GCC's inline assembly is powerful but difficult to get right and can cause unexpected behaviour if you get it wrong. You should only use inline assembly as a last resort. FreeBSD has a syscall function that can be used to call most system calls.
You could have written the inline assembly above as:
asm(
"push %[stroj]\n\t"
"push %%eax\n\t" /* Required dummy value for int 0x80 */
"int $0x80\n\t"
"add $8, %%esp" /* 2*4 bytes removed from stack */
: "+a"(syscallnum), /* error code also returned in syscallnum */
"=m"(stroj)
: [stroj]"r"(&stroj));
FreeBSD 2+ doesn't support obsolete SYS_uname
If you try to run the code above you will discover it doesn't return anything. If you use the program TRUSS with a command like truss ./progname you should see something like this in the output:
obs_uname(0xffffc6f8,0x0,0x0,0x0,0x0,0x0) ERR#78 'Function not implemented'
This is because FreeBSD 2+ doesn't support the SYS_uname system call and is now considered obsolete. FreeBSD's libc uname makes calls to SYS___sysctl to populate the fields of the utsname structure. From the command line you can query the nodename using:
sysctl kern.hostname
You can call sysctl through a system call this way:
#include <unistd.h>
#include <sys/syscall.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/sysctl.h>
#define OSNAME_MAX_LEN 256
/* SYS___sysctl has the value 202 */
/* #define SYS___sysctl 202 */
int main(void)
{
char osname[OSNAME_MAX_LEN];
size_t osnamelen = sizeof(osname) - 1;
int name[] = {CTL_KERN, KERN_HOSTNAME};
u_int namelen = sizeof(name) / sizeof(name[0]);
char * old = osname;
size_t * oldlenp = &osnamelen;
u_int syscallnum = SYS___sysctl;
asm("push %[newlen]\n\t"
"push %[new]\n\t"
"push %[oldlenp]\n\t"
"push %[old]\n\t"
"push %[namelen]\n\t"
"push %[name]\n\t"
"push %%eax\n\t" /* Required dummy value */
"int $0x80\n\t"
"add $28, %%esp" /* 7*4=28 bytes to remove from stack */
: "+a"(syscallnum) /* error code also returned in syscallnum */
: [name]"r"(name), [namelen]"r"(namelen),
[old]"r"(old) , [oldlenp]"r"(oldlenp),
[new]"i"(NULL), [newlen]"i"(0)
: "memory");
if (syscallnum) {
return EXIT_FAILURE;
}
osname[osnamelen]='\0'; /* Ensure the OS Name is Null terminated */
printf("This machine's node name is %s\n", osname);
return EXIT_SUCCESS;
}
When inline assembly adjusts ESP (push etc) it can cause memory operands generated by GCC and passed via a constraint to point at the wrong memory locations. This is especially true if any of the data is placed on the stack. To avoid this problem it is easiest to pass the addresses via registers.
Using the syscall function rather than inline assembly it could have also been written this way:
#include <unistd.h>
#include <sys/syscall.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/sysctl.h>
#define OSNAME_MAX_LEN 256
/* SYS___sysctl has the value 202 */
/* #define SYS___sysctl 202 */
int main(void)
{
char osname[OSNAME_MAX_LEN];
size_t osnamelen = sizeof(osname) - 1;
int name[] = {CTL_KERN, KERN_HOSTNAME};
u_int namelen = sizeof(name) / sizeof(name[0]);
char * old = osname;
size_t * oldlenp = &osnamelen;
if (syscall(SYS___sysctl, name, namelen, old, oldlenp, NULL, 0) == -1) {
perror("sysctl");
return EXIT_FAILURE;
}
osname[osnamelen]='\0'; /* Ensure the OS Name is Null terminated */
printf("This machine's node name is %s\n", osname);
return EXIT_SUCCESS;
}