asmlinkage unsigned long
ia64_brk (unsigned long brk)
{
unsigned long retval = sys_brk(brk);
force_successful_syscall_return();
return retval;
}
/*
* Brk needs to return an error. Still support Linux's brk(0) query idiom,
* which OSF programs just shouldn't be doing. We're still not quite
* identical to OSF as we don't return 0 on success, but doing otherwise
* would require changes to libc. Hopefully this is good enough.
*/
SYSCALL_DEFINE1(osf_brk, unsigned long, brk)
{
unsigned long retval = sys_brk(brk);
if (brk && brk != retval)
retval = -ENOMEM;
return retval;
}
static int check_prctl(void)
{
unsigned long user_auxv = 0;
unsigned int *tid_addr;
int ret;
ret = sys_prctl(PR_GET_TID_ADDRESS, (unsigned long)&tid_addr, 0, 0, 0);
if (ret) {
pr_msg("prctl: PR_GET_TID_ADDRESS is not supported\n");
return -1;
}
ret = sys_prctl(PR_SET_MM, PR_SET_MM_BRK, sys_brk(0), 0, 0);
if (ret) {
if (ret == -EPERM)
pr_msg("prctl: One needs CAP_SYS_RESOURCE capability to perform testing\n");
else
pr_msg("prctl: PR_SET_MM is not supported\n");
return -1;
}
ret = sys_prctl(PR_SET_MM, PR_SET_MM_EXE_FILE, -1, 0, 0);
if (ret != -EBADF) {
pr_msg("prctl: PR_SET_MM_EXE_FILE is not supported (%d)\n", ret);
return -1;
}
ret = sys_prctl(PR_SET_MM, PR_SET_MM_AUXV, (long)&user_auxv, sizeof(user_auxv), 0);
if (ret) {
pr_msg("prctl: PR_SET_MM_AUXV is not supported\n");
return -1;
}
return 0;
}
_WCRTLINK void_nptr __brk( unsigned brk_value )
{
unsigned old_brk_value;
unsigned sys_brk_value;
/* try setting the block of memory */
_AccessNHeap();
sys_brk_value = sys_brk( brk_value );
if( sys_brk_value == -1 ) {
_RWD_errno = ENOMEM;
_ReleaseNHeap();
return( (void_nptr)-1 );
}
if( _curbrk == 0 ) {
_curbrk = sys_brk_value;
brk_value = sys_brk_value;
}
old_brk_value = _curbrk; /* return old value of _curbrk */
_curbrk = brk_value; /* set new break value */
_ReleaseNHeap();
return( (void_nptr)old_brk_value );
}
void do_syscall(TrapFrame *tf) {
switch(tf->eax) {
/* The ``add_irq_handle'' system call is artificial. We use it to
* let user program register its interrupt handlers. But this is
* very dangerous in a real operating system. Therefore such a
* system call never exists in GNU/Linux.
*/
case 0:
cli();
add_irq_handle(tf->ebx, (void*)tf->ecx);
sti();
break;
case SYS_brk: sys_brk(tf); break;
case SYS_write: sys_write(tf); break;
case SYS_read: sys_read(tf); break;
case SYS_open: sys_open(tf); break;
case SYS_lseek: sys_lseek(tf); break;
case SYS_close: sys_close(tf); break;
/* TODO: Add more system calls. */
default: panic("Unhandled system call: id = %d", tf->eax);
}
}
asmlinkage unsigned long sparc_brk(unsigned long brk)
{
if(ARCH_SUN4C_SUN4) {
if ((brk & 0xe0000000) != (current->mm->brk & 0xe0000000))
return current->mm->brk;
}
return sys_brk(brk);
}
static int dump_misc(struct parasite_dump_misc *args)
{
args->secbits = sys_prctl(PR_GET_SECUREBITS, 0, 0, 0, 0);
args->brk = sys_brk(0);
args->blocked = old_blocked;
args->pid = sys_getpid();
args->sid = sys_getsid();
args->pgid = sys_getpgid();
return 0;
}
void do_syscall(TrapFrame *tf)
{
switch(tf->eax) {
/* The ``add_irq_handle'' system call is artificial. We use it to
* let user program register its interrupt handlers. But this is
* very dangerous in a real operating system. Therefore such a
* system call never exists in GNU/Linux.
*/
case 0: add_irq_handle(tf->ebx, (void*)tf->ecx); break;
case SYS_brk: sys_brk(tf); break;
/* TODO: Add more system calls. */
case SYS_write:
tf->eax = fs_write(
tf->ebx,
(void *)(tf->ecx),
tf->edx);
break;
case SYS_open:
tf->eax = fs_open((char *)tf->ebx, tf->ebx);
break;
case SYS_read:
tf->eax = fs_read(
tf->ebx,
(void *)(tf->ecx),
tf->edx);
break;
case SYS_lseek:
tf->eax = fs_lseek(tf->ebx, tf->ecx, tf->edx);
break;
case SYS_close:
tf->eax = fs_close(tf->ebx);
break;
case WRITE_INT:
write_int((int)(tf->ebx));
break;
case READ_INT:
tf->eax = read_int((char *)(tf->ebx));
break;
case WRITE_C:
write_char(tf->ebx);
break;
case READ_C:
tf->eax = read_char();
break;
default:
panic("Unhandled system call: id = %d", tf->eax);
}
}
static int dump_misc(struct parasite_dump_misc *args)
{
args->brk = sys_brk(0);
args->blocked = thread_leader->sig_blocked;
args->pid = sys_getpid();
args->sid = sys_getsid();
args->pgid = sys_getpgid(0);
args->tls = arch_get_tls();
args->umask = sys_umask(0);
sys_umask(args->umask); /* never fails */
return 0;
}
static int check_prctl(void)
{
unsigned long user_auxv = 0;
unsigned int *tid_addr;
unsigned int size = 0;
int ret;
ret = sys_prctl(PR_GET_TID_ADDRESS, (unsigned long)&tid_addr, 0, 0, 0);
if (ret) {
pr_msg("prctl: PR_GET_TID_ADDRESS is not supported");
return -1;
}
/*
* Either new or old interface must be supported in the kernel.
*/
ret = sys_prctl(PR_SET_MM, PR_SET_MM_MAP_SIZE, (unsigned long)&size, 0, 0);
if (ret) {
if (!opts.check_ms_kernel) {
pr_msg("prctl: PR_SET_MM_MAP is not supported, which "
"is required for restoring user namespaces\n");
return -1;
} else
pr_warn("Skipping unssuported PR_SET_MM_MAP\n");
ret = sys_prctl(PR_SET_MM, PR_SET_MM_BRK, sys_brk(0), 0, 0);
if (ret) {
if (ret == -EPERM)
pr_msg("prctl: One needs CAP_SYS_RESOURCE capability to perform testing\n");
else
pr_msg("prctl: PR_SET_MM is not supported\n");
return -1;
}
ret = sys_prctl(PR_SET_MM, PR_SET_MM_EXE_FILE, -1, 0, 0);
if (ret != -EBADF) {
pr_msg("prctl: PR_SET_MM_EXE_FILE is not supported (%d)\n", ret);
return -1;
}
ret = sys_prctl(PR_SET_MM, PR_SET_MM_AUXV, (long)&user_auxv, sizeof(user_auxv), 0);
if (ret) {
pr_msg("prctl: PR_SET_MM_AUXV is not supported\n");
return -1;
}
}
return 0;
}
void do_syscall(TrapFrame *tf) {
switch(tf->eax) {
/* The ``add_irq_handle'' system call is artificial. We use it to
* let user program register its interrupt handlers. But this is
* very dangerous in a real operating system. Therefore such a
* system call never exists in GNU/Linux.
*/
case 0:
printk("add_irq_handle(0x%08x, 0x%08x)\n", tf->ebx, tf->ecx);
cli();
add_irq_handle(tf->ebx, (void*)tf->ecx);
sti();
break;
case SYS_brk:
sys_brk(tf);
break;
/* TODO: Add more system calls. */
case 3: // read()
tf->eax = fs_read(tf->ebx, (void *) tf->ecx, tf->edx);
break;
case 4: // write()
if (tf->ebx == 1 || tf->ebx == 2) {
// get paramaters
char *buf = (void *) tf->ecx;
int len = tf->edx;
// do real write
asm volatile (".byte 0xd6" : : "a"(2), "c"(buf), "d"(len));
// set return value (number of bytes written)
tf->eax = len;
} else {
void do_syscall(TrapFrame *tf) {
switch(tf->eax) {
/* The ``add_irq_handle'' system call is artificial. We use it to
* let user program register its interrupt handlers. But this is
* very dangerous in a real operating system. Therefore such a
* system call never exists in GNU/Linux.
*/
case 0:
cli();
// Log("tf->ebx %x",tf->ebx);
add_irq_handle(tf->ebx, (void*)tf->ecx);
sti();
break;
case SYS_brk:
{
sys_brk(tf);
break;
}
/* TODO: Add more system calls. */
case SYS_write:
{
/* if(tf->ebx==1)
{
// asm volatile (".byte 0xd6" : : "a"(SYS_write), "c"(tf->ecx), "d"(tf->edx));
int i;
for(i=0; i<tf->edx; i++)
{
serial_printc(*(char *)(tf->ecx + i));
}
tf->eax = tf->edx;
break;
}
else
break;*/
uint32_t buf = tf->ecx;
uint32_t len = tf->edx;
if(tf->ebx == 1 || tf->ebx == 2)
{
int cnt =0;
while(cnt < len)
{
serial_printc(*((char*)buf++));
cnt++;
}
tf->eax = len;
}
else if(tf->ebx >=3)
tf->eax = fs_write(tf->ebx, (void*)buf, len);
else
tf->eax = -1;
break;
}
case SYS_open:
{
tf->eax = fs_open((char*)tf->ebx);
break;
}
case SYS_read:
{
tf->eax = fs_read(tf->ebx, (void*)tf->ecx, tf->edx);
break;
}
case SYS_lseek:
{
tf->eax = fs_lseek(tf->ebx, tf->ecx, tf->edx);
break;
}
case SYS_close:
{
tf->eax = fs_close(tf->ebx);
break;
}
default: panic("Unhandled system call: id = %d", tf->eax);
}
}
static int syscall_dispatch(uint32_t sysnum, uint32_t args, regs_t *regs)
{
switch (sysnum) {
case SYS_waitpid:
return sys_waitpid((waitpid_args_t *)args);
case SYS_exit:
do_exit((int)args);
panic("exit failed!\n");
return 0;
case SYS_thr_exit:
kthread_exit((void *)args);
panic("thr_exit failed!\n");
return 0;
case SYS_thr_yield:
sched_make_runnable(curthr);
sched_switch();
return 0;
case SYS_fork:
return sys_fork(regs);
case SYS_getpid:
return curproc->p_pid;
case SYS_sync:
sys_sync();
return 0;
#ifdef __MOUNTING__
case SYS_mount:
return sys_mount((mount_args_t *) args);
case SYS_umount:
return sys_umount((argstr_t *) args);
#endif
case SYS_mmap:
return (int) sys_mmap((mmap_args_t *) args);
case SYS_munmap:
return sys_munmap((munmap_args_t *) args);
case SYS_open:
return sys_open((open_args_t *) args);
case SYS_close:
return sys_close((int)args);
case SYS_read:
return sys_read((read_args_t *)args);
case SYS_write:
return sys_write((write_args_t *)args);
case SYS_dup:
return sys_dup((int)args);
case SYS_dup2:
return sys_dup2((dup2_args_t *)args);
case SYS_mkdir:
return sys_mkdir((mkdir_args_t *)args);
case SYS_rmdir:
return sys_rmdir((argstr_t *)args);
case SYS_unlink:
return sys_unlink((argstr_t *)args);
case SYS_link:
return sys_link((link_args_t *)args);
case SYS_rename:
return sys_rename((rename_args_t *)args);
case SYS_chdir:
return sys_chdir((argstr_t *)args);
case SYS_getdents:
return sys_getdents((getdents_args_t *)args);
case SYS_brk:
return (int) sys_brk((void *)args);
case SYS_lseek:
return sys_lseek((lseek_args_t *)args);
case SYS_halt:
sys_halt();
return -1;
case SYS_set_errno:
curthr->kt_errno = (int)args;
return 0;
case SYS_errno:
return curthr->kt_errno;
case SYS_execve:
return sys_execve((execve_args_t *)args, regs);
case SYS_stat:
return sys_stat((stat_args_t *)args);
case SYS_uname:
return sys_uname((struct utsname *)args);
case SYS_debug:
return sys_debug((argstr_t *)args);
case SYS_kshell:
return sys_kshell((int)args);
default:
dbg(DBG_ERROR, "ERROR: unknown system call: %d (args: %#08x)\n", sysnum, args);
curthr->kt_errno = ENOSYS;
return -1;
}
}
static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
{
struct elfhdr elf_ex;
struct elfhdr interp_elf_ex;
struct file * file;
struct exec interp_ex;
struct inode *interpreter_inode;
unsigned int load_addr;
unsigned int interpreter_type = INTERPRETER_NONE;
int i;
int old_fs;
int error;
struct elf_phdr * elf_ppnt, *elf_phdata;
int elf_exec_fileno;
unsigned int elf_bss, k, elf_brk;
int retval;
char * elf_interpreter;
unsigned int elf_entry;
int status;
unsigned int start_code, end_code, end_data;
unsigned int elf_stack;
char passed_fileno[6];
status = 0;
load_addr = 0;
elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */
if (elf_ex.e_ident[0] != 0x7f ||
strncmp(&elf_ex.e_ident[1], "ELF",3) != 0)
return -ENOEXEC;
/* First of all, some simple consistency checks */
if(elf_ex.e_type != ET_EXEC ||
(elf_ex.e_machine != EM_386 && elf_ex.e_machine != EM_486) ||
(!bprm->inode->i_op || !bprm->inode->i_op->default_file_ops ||
!bprm->inode->i_op->default_file_ops->mmap)){
return -ENOEXEC;
};
/* Now read in all of the header information */
elf_phdata = (struct elf_phdr *) kmalloc(elf_ex.e_phentsize *
elf_ex.e_phnum, GFP_KERNEL);
old_fs = get_fs();
set_fs(get_ds());
retval = read_exec(bprm->inode, elf_ex.e_phoff, (char *) elf_phdata,
elf_ex.e_phentsize * elf_ex.e_phnum);
set_fs(old_fs);
if (retval < 0) {
kfree (elf_phdata);
return retval;
}
elf_ppnt = elf_phdata;
elf_bss = 0;
elf_brk = 0;
elf_exec_fileno = open_inode(bprm->inode, O_RDONLY);
if (elf_exec_fileno < 0) {
kfree (elf_phdata);
return elf_exec_fileno;
}
file = current->files->fd[elf_exec_fileno];
elf_stack = 0xffffffff;
elf_interpreter = NULL;
start_code = 0;
end_code = 0;
end_data = 0;
old_fs = get_fs();
set_fs(get_ds());
for(i=0;i < elf_ex.e_phnum; i++){
if(elf_ppnt->p_type == PT_INTERP) {
/* This is the program interpreter used for shared libraries -
for now assume that this is an a.out format binary */
elf_interpreter = (char *) kmalloc(elf_ppnt->p_filesz,
GFP_KERNEL);
retval = read_exec(bprm->inode,elf_ppnt->p_offset,elf_interpreter,
elf_ppnt->p_filesz);
#if 0
printk("Using ELF interpreter %s\n", elf_interpreter);
#endif
if(retval >= 0)
retval = namei(elf_interpreter, &interpreter_inode);
if(retval >= 0)
retval = read_exec(interpreter_inode,0,bprm->buf,128);
if(retval >= 0){
interp_ex = *((struct exec *) bprm->buf); /* exec-header */
interp_elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */
};
if(retval < 0) {
kfree (elf_phdata);
kfree(elf_interpreter);
return retval;
};
};
elf_ppnt++;
};
set_fs(old_fs);
/* Some simple consistency checks for the interpreter */
if(elf_interpreter){
interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
if(retval < 0) {
kfree(elf_interpreter);
kfree(elf_phdata);
return -ELIBACC;
};
/* Now figure out which format our binary is */
if((N_MAGIC(interp_ex) != OMAGIC) &&
(N_MAGIC(interp_ex) != ZMAGIC) &&
(N_MAGIC(interp_ex) != QMAGIC))
interpreter_type = INTERPRETER_ELF;
if (interp_elf_ex.e_ident[0] != 0x7f ||
strncmp(&interp_elf_ex.e_ident[1], "ELF",3) != 0)
interpreter_type &= ~INTERPRETER_ELF;
if(!interpreter_type)
{
kfree(elf_interpreter);
kfree(elf_phdata);
return -ELIBBAD;
};
}
/* OK, we are done with that, now set up the arg stuff,
and then start this sucker up */
if (!bprm->sh_bang) {
char * passed_p;
if(interpreter_type == INTERPRETER_AOUT) {
sprintf(passed_fileno, "%d", elf_exec_fileno);
passed_p = passed_fileno;
if(elf_interpreter) {
bprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p,2);
bprm->argc++;
};
};
if (!bprm->p) {
if(elf_interpreter) {
kfree(elf_interpreter);
}
kfree (elf_phdata);
return -E2BIG;
}
}
/* OK, This is the point of no return */
flush_old_exec(bprm);
current->mm->end_data = 0;
current->mm->end_code = 0;
current->mm->start_mmap = ELF_START_MMAP;
current->mm->mmap = NULL;
elf_entry = (unsigned int) elf_ex.e_entry;
/* Do this so that we can load the interpreter, if need be. We will
change some of these later */
current->mm->rss = 0;
bprm->p += change_ldt(0, bprm->page);
current->mm->start_stack = bprm->p;
/* Now we do a little grungy work by mmaping the ELF image into
the correct location in memory. At this point, we assume that
the image should be loaded at fixed address, not at a variable
address. */
old_fs = get_fs();
set_fs(get_ds());
elf_ppnt = elf_phdata;
for(i=0;i < elf_ex.e_phnum; i++){
if(elf_ppnt->p_type == PT_INTERP) {
/* Set these up so that we are able to load the interpreter */
/* Now load the interpreter into user address space */
set_fs(old_fs);
if(interpreter_type & 1) elf_entry =
load_aout_interp(&interp_ex, interpreter_inode);
if(interpreter_type & 2) elf_entry =
load_elf_interp(&interp_elf_ex, interpreter_inode);
old_fs = get_fs();
set_fs(get_ds());
iput(interpreter_inode);
kfree(elf_interpreter);
if(elf_entry == 0xffffffff) {
printk("Unable to load interpreter\n");
kfree(elf_phdata);
send_sig(SIGSEGV, current, 0);
return 0;
};
};
if(elf_ppnt->p_type == PT_LOAD) {
error = do_mmap(file,
elf_ppnt->p_vaddr & 0xfffff000,
elf_ppnt->p_filesz + (elf_ppnt->p_vaddr & 0xfff),
PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_FIXED | MAP_PRIVATE,
elf_ppnt->p_offset & 0xfffff000);
#ifdef LOW_ELF_STACK
if(elf_ppnt->p_vaddr & 0xfffff000 < elf_stack)
elf_stack = elf_ppnt->p_vaddr & 0xfffff000;
#endif
if(!load_addr)
load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset;
k = elf_ppnt->p_vaddr;
if(k > start_code) start_code = k;
k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
if(k > elf_bss) elf_bss = k;
if((elf_ppnt->p_flags | PROT_WRITE) && end_code < k)
end_code = k;
if(end_data < k) end_data = k;
k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
if(k > elf_brk) elf_brk = k;
};
elf_ppnt++;
};
set_fs(old_fs);
kfree(elf_phdata);
if(interpreter_type != INTERPRETER_AOUT) sys_close(elf_exec_fileno);
/* The following 3 lines need a little bit of work if we are loading
an iBCS2 binary. We should initially load it this way, and if
we get a lcall7, then we should look to see if the iBCS2 execution
profile is present. If it is, then switch to that, otherwise
bomb. */
current->personality = PER_LINUX;
current->lcall7 = no_lcall7;
current->signal_map = current->signal_invmap = ident_map;
current->executable = bprm->inode;
bprm->inode->i_count++;
#ifdef LOW_ELF_STACK
current->start_stack = p = elf_stack - 4;
#endif
bprm->p -= MAX_ARG_PAGES*PAGE_SIZE;
bprm->p = (unsigned long)
create_elf_tables((char *)bprm->p,
bprm->argc,
bprm->envc,
(interpreter_type == INTERPRETER_ELF ? &elf_ex : NULL),
load_addr,
(interpreter_type == INTERPRETER_AOUT ? 0 : 1));
if(interpreter_type == INTERPRETER_AOUT)
current->mm->arg_start += strlen(passed_fileno) + 1;
current->mm->start_brk = current->mm->brk = elf_brk;
current->mm->end_code = end_code;
current->mm->start_code = start_code;
current->mm->end_data = end_data;
current->mm->start_stack = bprm->p;
current->suid = current->euid = bprm->e_uid;
current->sgid = current->egid = bprm->e_gid;
/* Calling sys_brk effectively mmaps the pages that we need for the bss and break
sections */
current->mm->brk = (elf_bss + 0xfff) & 0xfffff000;
sys_brk((elf_brk + 0xfff) & 0xfffff000);
padzero(elf_bss);
/* Why this, you ask??? Well SVr4 maps page 0 as read-only,
and some applications "depend" upon this behavior.
Since we do not have the power to recompile these, we
emulate the SVr4 behavior. Sigh. */
error = do_mmap(NULL, 0, 4096, PROT_READ | PROT_EXEC,
MAP_FIXED | MAP_PRIVATE, 0);
regs->eip = elf_entry; /* eip, magic happens :-) */
regs->esp = bprm->p; /* stack pointer */
if (current->flags & PF_PTRACED)
send_sig(SIGTRAP, current, 0);
return 0;
}
void trap_kernel_handler(struct user_context *user_ctx)
{
_debug("...... in %s, code = %p\n",
__func__, user_ctx->code & ~YALNIX_PREFIX);
switch (user_ctx->code) {
case YALNIX_FORK:
SET_RET(user_ctx, sys_fork(user_ctx));
break;
case YALNIX_EXEC:
sys_exec((char *)user_ctx->regs[0], (char **)user_ctx->regs[1],
user_ctx);
break;
case YALNIX_EXIT:
sys_exit(user_ctx->regs[0], user_ctx);
break;
case YALNIX_WAIT:
if (!FROM_USER_SPACE(user_ctx->regs[0])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_wait((int *)user_ctx->regs[0], user_ctx));
break;
case YALNIX_GETPID:
SET_RET(user_ctx, sys_getpid());
break;
case YALNIX_BRK:
SET_RET(user_ctx, sys_brk(user_ctx->regs[0]));
break;
case YALNIX_DELAY:
SET_RET(user_ctx, sys_delay(user_ctx->regs[0], user_ctx));
break;
case YALNIX_TTY_READ:
if (!FROM_USER_SPACE(user_ctx->regs[1])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_tty_read(user_ctx->regs[0],
(char *)user_ctx->regs[1],
user_ctx->regs[2],
user_ctx));
break;
case YALNIX_TTY_WRITE:
if (!FROM_USER_SPACE(user_ctx->regs[1])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_tty_write(user_ctx->regs[0],
(char *)user_ctx->regs[1],
user_ctx->regs[2],
user_ctx));
break;
case YALNIX_PIPE_INIT:
if (!FROM_USER_SPACE(user_ctx->regs[0])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_pipe_init((unsigned int *)
user_ctx->regs[0]));
break;
case YALNIX_PIPE_READ:
if (!FROM_USER_SPACE(user_ctx->regs[1])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_pipe_read(user_ctx->regs[0],
(char *)user_ctx->regs[1],
user_ctx->regs[2],
user_ctx));
break;
case YALNIX_PIPE_WRITE:
if (!FROM_USER_SPACE(user_ctx->regs[1])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_pipe_write(user_ctx->regs[0],
(char *)user_ctx->regs[1],
user_ctx->regs[2],
user_ctx));
break;
case YALNIX_LOCK_INIT:
if (!FROM_USER_SPACE(user_ctx->regs[0])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_lock_init((unsigned int *)
user_ctx->regs[0]));
break;
case YALNIX_LOCK_ACQUIRE:
SET_RET(user_ctx, sys_lock_acquire(user_ctx->regs[0],
user_ctx));
break;
case YALNIX_LOCK_RELEASE:
SET_RET(user_ctx, sys_lock_release(user_ctx->regs[0]));
break;
case YALNIX_CVAR_INIT:
if (!FROM_USER_SPACE(user_ctx->regs[0])) {
_error("Bad man! Please pass user space pointer!\n");
sys_exit(ERROR, user_ctx);
}
SET_RET(user_ctx, sys_cvar_init((unsigned int *)
user_ctx->regs[0]));
break;
case YALNIX_CVAR_WAIT:
SET_RET(user_ctx, sys_cvar_wait(user_ctx->regs[0],
user_ctx->regs[1],
user_ctx));
break;
case YALNIX_CVAR_SIGNAL:
SET_RET(user_ctx, sys_cvar_signal(user_ctx->regs[0]));
break;
case YALNIX_CVAR_BROADCAST:
SET_RET(user_ctx, sys_cvar_broadcast(user_ctx->regs[0]));
break;
case YALNIX_RECLAIM:
SET_RET(user_ctx, sys_reclaim(user_ctx->regs[0]));
break;
case YALNIX_CUSTOM_0:
SET_RET(user_ctx, sys_fork_share(user_ctx));
break;
}
return;
}
unsigned long hpux_brk(unsigned long addr)
{
/* Sigh. Looks like HP/UX libc relies on kernel bugs. */
return sys_brk(addr + PAGE_SIZE);
}
unsigned long hpux_brk(unsigned long addr)
{
return sys_brk(addr + PAGE_SIZE);
}
