[deliverable/linux.git] / arch / um / os-Linux / process.c

/* 
 * Copyright (C) 2002 Jeff Dike (jdike@addtoit.com)
 * Licensed under the GPL
 */

#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <signal.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include "ptrace_user.h"
#include "os.h"
#include "user.h"
#include "process.h"
#include "irq_user.h"
#include "kern_util.h"
#include "longjmp.h"
#include "skas_ptrace.h"
#include "kern_constants.h"
#include "uml-config.h"
#include "init.h"

#define ARBITRARY_ADDR -1
#define FAILURE_PID    -1

#define STAT_PATH_LEN sizeof("/proc/#######/stat\0")
#define COMM_SCANF "%*[^)])"

unsigned long os_process_pc(int pid)
{
	char proc_stat[STAT_PATH_LEN], buf[256];
	unsigned long pc;
	int fd, err;

	sprintf(proc_stat, "/proc/%d/stat", pid);
	fd = os_open_file(proc_stat, of_read(OPENFLAGS()), 0);
	if(fd < 0){
		printk("os_process_pc - couldn't open '%s', err = %d\n",
		       proc_stat, -fd);
		return ARBITRARY_ADDR;
	}
	CATCH_EINTR(err = read(fd, buf, sizeof(buf)));
	if(err < 0){
		printk("os_process_pc - couldn't read '%s', err = %d\n",
		       proc_stat, errno);
		os_close_file(fd);
		return ARBITRARY_ADDR;
	}
	os_close_file(fd);
	pc = ARBITRARY_ADDR;
	if(sscanf(buf, "%*d " COMM_SCANF " %*c %*d %*d %*d %*d %*d %*d %*d "
		  "%*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d "
		  "%*d %*d %*d %*d %*d %lu", &pc) != 1){
		printk("os_process_pc - couldn't find pc in '%s'\n", buf);
	}
	return pc;
}

int os_process_parent(int pid)
{
	char stat[STAT_PATH_LEN];
	char data[256];
	int parent, n, fd;

	if(pid == -1)
		return -1;

	snprintf(stat, sizeof(stat), "/proc/%d/stat", pid);
	fd = os_open_file(stat, of_read(OPENFLAGS()), 0);
	if(fd < 0){
		printk("Couldn't open '%s', err = %d\n", stat, -fd);
		return FAILURE_PID;
	}

	CATCH_EINTR(n = read(fd, data, sizeof(data)));
	os_close_file(fd);

	if(n < 0){
		printk("Couldn't read '%s', err = %d\n", stat, errno);
		return FAILURE_PID;
	}

	parent = FAILURE_PID;
	n = sscanf(data, "%*d " COMM_SCANF " %*c %d", &parent);
	if(n != 1)
		printk("Failed to scan '%s'\n", data);

	return parent;
}

void os_stop_process(int pid)
{
	kill(pid, SIGSTOP);
}

void os_kill_process(int pid, int reap_child)
{
	kill(pid, SIGKILL);
	if(reap_child)
		CATCH_EINTR(waitpid(pid, NULL, 0));
		
}

/* This is here uniquely to have access to the userspace errno, i.e. the one
 * used by ptrace in case of error.
 */

long os_ptrace_ldt(long pid, long addr, long data)
{
	int ret;

	ret = ptrace(PTRACE_LDT, pid, addr, data);

	if (ret < 0)
		return -errno;
	return ret;
}

/* Kill off a ptraced child by all means available.  kill it normally first,
 * then PTRACE_KILL it, then PTRACE_CONT it in case it's in a run state from
 * which it can't exit directly.
 */

void os_kill_ptraced_process(int pid, int reap_child)
{
	kill(pid, SIGKILL);
	ptrace(PTRACE_KILL, pid);
	ptrace(PTRACE_CONT, pid);
	if(reap_child)
		CATCH_EINTR(waitpid(pid, NULL, 0));
}

#ifdef UML_CONFIG_MODE_TT
void os_usr1_process(int pid)
{
	kill(pid, SIGUSR1);
}
#endif

/* Don't use the glibc version, which caches the result in TLS. It misses some
 * syscalls, and also breaks with clone(), which does not unshare the TLS.
 */

int os_getpid(void)
{
	return syscall(__NR_getpid);
}

int os_getpgrp(void)
{
	return getpgrp();
}

int os_map_memory(void *virt, int fd, unsigned long long off, unsigned long len,
		  int r, int w, int x)
{
	void *loc;
	int prot;

	prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) | 
		(x ? PROT_EXEC : 0);

	loc = mmap64((void *) virt, len, prot, MAP_SHARED | MAP_FIXED,
		     fd, off);
	if(loc == MAP_FAILED)
		return -errno;
	return 0;
}

int os_protect_memory(void *addr, unsigned long len, int r, int w, int x)
{
        int prot = ((r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) | 
		    (x ? PROT_EXEC : 0));

        if(mprotect(addr, len, prot) < 0)
		return -errno;
        return 0;
}

int os_unmap_memory(void *addr, int len)
{
        int err;

        err = munmap(addr, len);
	if(err < 0)
		return -errno;
        return 0;
}

#ifndef MADV_REMOVE
#define MADV_REMOVE KERNEL_MADV_REMOVE
#endif

int __init os_drop_memory(void *addr, int length)
{
	int err;

	err = madvise(addr, length, MADV_REMOVE);
	if(err < 0)
		err = -errno;
	return err;
}

int __init can_drop_memory(void)
{
	void *addr;
	int fd, ok = 0;

	printk("Checking host MADV_REMOVE support...");
	fd = create_mem_file(UM_KERN_PAGE_SIZE);
	if(fd < 0){
		printk("Creating test memory file failed, err = %d\n", -fd);
		goto out;
	}

	addr = mmap64(NULL, UM_KERN_PAGE_SIZE, PROT_READ | PROT_WRITE,
		      MAP_SHARED, fd, 0);
	if(addr == MAP_FAILED){
		printk("Mapping test memory file failed, err = %d\n", -errno);
		goto out_close;
	}

	if(madvise(addr, UM_KERN_PAGE_SIZE, MADV_REMOVE) != 0){
		printk("MADV_REMOVE failed, err = %d\n", -errno);
		goto out_unmap;
	}

	printk("OK\n");
	ok = 1;

out_unmap:
	munmap(addr, UM_KERN_PAGE_SIZE);
out_close:
	close(fd);
out:
	return ok;
}

void init_new_thread_stack(void *sig_stack, void (*usr1_handler)(int))
{
	int flags = 0, pages;

	if(sig_stack != NULL){
		pages = (1 << UML_CONFIG_KERNEL_STACK_ORDER);
		set_sigstack(sig_stack, pages * UM_KERN_PAGE_SIZE);
		flags = SA_ONSTACK;
	}
	if(usr1_handler){
		struct sigaction sa;

		sa.sa_handler = usr1_handler;
		sigemptyset(&sa.sa_mask);
		sa.sa_flags = flags;
		sa.sa_restorer = NULL;
		if(sigaction(SIGUSR1, &sa, NULL) < 0)
			panic("init_new_thread_stack - sigaction failed - "
			      "errno = %d\n", errno);
	}
}

void init_new_thread_signals(void)
{
	set_handler(SIGSEGV, (__sighandler_t) sig_handler, SA_ONSTACK,
		    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
	set_handler(SIGTRAP, (__sighandler_t) sig_handler, SA_ONSTACK,
		    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
	set_handler(SIGFPE, (__sighandler_t) sig_handler, SA_ONSTACK,
		    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
	set_handler(SIGILL, (__sighandler_t) sig_handler, SA_ONSTACK,
		    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
	set_handler(SIGBUS, (__sighandler_t) sig_handler, SA_ONSTACK,
		    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
	set_handler(SIGUSR2, (__sighandler_t) sig_handler,
		    SA_ONSTACK, SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM,
		    -1);
	signal(SIGHUP, SIG_IGN);

	init_irq_signals(1);
}

int run_kernel_thread(int (*fn)(void *), void *arg, void **jmp_ptr)
{
	jmp_buf buf;
	int n;

	*jmp_ptr = &buf;
	n = UML_SETJMP(&buf);
	if(n != 0)
		return n;
	(*fn)(arg);
	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (C) 2002 Jeff Dike (jdike@addtoit.com)
	3	* Licensed under the GPL
	4	*/
	5
ae756df8	6	#include <unistd.h>
1da177e4 LT	7	#include <stdio.h>
	8	#include <errno.h>
	9	#include <signal.h>
1da177e4 LT	10	#include <sys/mman.h>
1da177e4 LT	11	#include <sys/wait.h>
02dea087	12	#include <sys/mman.h>
5f4c6bc1	13	#include <sys/syscall.h>
1da177e4 LT	14	#include "ptrace_user.h"
	15	#include "os.h"
	16	#include "user.h"
60d339f6 GS	17	#include "process.h"
	18	#include "irq_user.h"
	19	#include "kern_util.h"
1d7173ba	20	#include "longjmp.h"
07f4e2c6	21	#include "skas_ptrace.h"
02dea087	22	#include "kern_constants.h"
9ff1d36c	23	#include "uml-config.h"
36e45463	24	#include "init.h"
1da177e4 LT	25
	26	#define ARBITRARY_ADDR -1
	27	#define FAILURE_PID -1
	28
	29	#define STAT_PATH_LEN sizeof("/proc/#######/stat\0")
	30	#define COMM_SCANF "%*[^)])"
	31
	32	unsigned long os_process_pc(int pid)
	33	{
	34	char proc_stat[STAT_PATH_LEN], buf[256];
	35	unsigned long pc;
	36	int fd, err;
	37
	38	sprintf(proc_stat, "/proc/%d/stat", pid);
	39	fd = os_open_file(proc_stat, of_read(OPENFLAGS()), 0);
	40	if(fd < 0){
	41	printk("os_process_pc - couldn't open '%s', err = %d\n",
	42	proc_stat, -fd);
ef0470c0	43	return ARBITRARY_ADDR;
1da177e4	44	}
a61f334f	45	CATCH_EINTR(err = read(fd, buf, sizeof(buf)));
1da177e4 LT	46	if(err < 0){
1da177e4 LT	47	printk("os_process_pc - couldn't read '%s', err = %d\n",
a61f334f	48	proc_stat, errno);
1da177e4	49	os_close_file(fd);
ef0470c0	50	return ARBITRARY_ADDR;
1da177e4 LT	51	}
	52	os_close_file(fd);
	53	pc = ARBITRARY_ADDR;
	54	if(sscanf(buf, "%d " COMM_SCANF " %c %d %d %d %d %d %d %*d "
	55	"%d %d %d %d %d %d %d %d %d %d %d %d %d %d "
	56	"%d %d %d %d %*d %lu", &pc) != 1){
	57	printk("os_process_pc - couldn't find pc in '%s'\n", buf);
	58	}
ef0470c0	59	return pc;
1da177e4 LT	60	}
	61
	62	int os_process_parent(int pid)
	63	{
	64	char stat[STAT_PATH_LEN];
	65	char data[256];
	66	int parent, n, fd;
	67
ef0470c0 JD	68	if(pid == -1)
ef0470c0 JD	69	return -1;
1da177e4 LT	70
	71	snprintf(stat, sizeof(stat), "/proc/%d/stat", pid);
	72	fd = os_open_file(stat, of_read(OPENFLAGS()), 0);
	73	if(fd < 0){
	74	printk("Couldn't open '%s', err = %d\n", stat, -fd);
ef0470c0	75	return FAILURE_PID;
1da177e4 LT	76	}
1da177e4 LT	77
a61f334f	78	CATCH_EINTR(n = read(fd, data, sizeof(data)));
1da177e4 LT	79	os_close_file(fd);
	80
	81	if(n < 0){
a61f334f	82	printk("Couldn't read '%s', err = %d\n", stat, errno);
ef0470c0	83	return FAILURE_PID;
1da177e4 LT	84	}
	85
	86	parent = FAILURE_PID;
	87	n = sscanf(data, "%d " COMM_SCANF " %c %d", &parent);
	88	if(n != 1)
	89	printk("Failed to scan '%s'\n", data);
	90
ef0470c0	91	return parent;
1da177e4 LT	92	}
	93
	94	void os_stop_process(int pid)
	95	{
	96	kill(pid, SIGSTOP);
	97	}
	98
	99	void os_kill_process(int pid, int reap_child)
	100	{
	101	kill(pid, SIGKILL);
	102	if(reap_child)
	103	CATCH_EINTR(waitpid(pid, NULL, 0));
	104
	105	}
	106
07f4e2c6 PBG	107	/* This is here uniquely to have access to the userspace errno, i.e. the one
	108	* used by ptrace in case of error.
	109	*/
	110
	111	long os_ptrace_ldt(long pid, long addr, long data)
	112	{
	113	int ret;
	114
	115	ret = ptrace(PTRACE_LDT, pid, addr, data);
	116
	117	if (ret < 0)
	118	return -errno;
	119	return ret;
	120	}
	121
1da177e4 LT	122	/* Kill off a ptraced child by all means available. kill it normally first,
	123	* then PTRACE_KILL it, then PTRACE_CONT it in case it's in a run state from
	124	* which it can't exit directly.
	125	*/
	126
	127	void os_kill_ptraced_process(int pid, int reap_child)
	128	{
	129	kill(pid, SIGKILL);
	130	ptrace(PTRACE_KILL, pid);
	131	ptrace(PTRACE_CONT, pid);
	132	if(reap_child)
	133	CATCH_EINTR(waitpid(pid, NULL, 0));
	134	}
	135
9ff1d36c	136	#ifdef UML_CONFIG_MODE_TT
1da177e4 LT	137	void os_usr1_process(int pid)
	138	{
	139	kill(pid, SIGUSR1);
	140	}
9ff1d36c	141	#endif
1da177e4	142
60d339f6 GS	143	/* Don't use the glibc version, which caches the result in TLS. It misses some
	144	* syscalls, and also breaks with clone(), which does not unshare the TLS.
	145	*/
	146
1da177e4 LT	147	int os_getpid(void)
1da177e4 LT	148	{
ef0470c0	149	return syscall(__NR_getpid);
1da177e4 LT	150	}
1da177e4 LT	151
cd2ee4a3 JD	152	int os_getpgrp(void)
	153	{
	154	return getpgrp();
	155	}
	156
1da177e4 LT	157	int os_map_memory(void *virt, int fd, unsigned long long off, unsigned long len,
	158	int r, int w, int x)
	159	{
	160	void *loc;
	161	int prot;
	162
	163	prot = (r ? PROT_READ : 0) \| (w ? PROT_WRITE : 0) \|
	164	(x ? PROT_EXEC : 0);
	165
	166	loc = mmap64((void *) virt, len, prot, MAP_SHARED \| MAP_FIXED,
	167	fd, off);
	168	if(loc == MAP_FAILED)
ef0470c0 JD	169	return -errno;
ef0470c0 JD	170	return 0;
1da177e4 LT	171	}
	172
	173	int os_protect_memory(void *addr, unsigned long len, int r, int w, int x)
	174	{
	175	int prot = ((r ? PROT_READ : 0) \| (w ? PROT_WRITE : 0) \|
	176	(x ? PROT_EXEC : 0));
	177
	178	if(mprotect(addr, len, prot) < 0)
ef0470c0 JD	179	return -errno;
ef0470c0 JD	180	return 0;
1da177e4 LT	181	}
	182
	183	int os_unmap_memory(void *addr, int len)
	184	{
	185	int err;
	186
	187	err = munmap(addr, len);
	188	if(err < 0)
ef0470c0 JD	189	return -errno;
ef0470c0 JD	190	return 0;
1da177e4 LT	191	}
1da177e4 LT	192
02dea087	193	#ifndef MADV_REMOVE
b73781c8	194	#define MADV_REMOVE KERNEL_MADV_REMOVE
02dea087 JD	195	#endif
02dea087 JD	196
36e45463	197	int __init os_drop_memory(void *addr, int length)
02dea087 JD	198	{
	199	int err;
	200
	201	err = madvise(addr, length, MADV_REMOVE);
	202	if(err < 0)
	203	err = -errno;
	204	return err;
	205	}
	206
36e45463	207	int __init can_drop_memory(void)
02dea087 JD	208	{
02dea087 JD	209	void *addr;
e3104f50	210	int fd, ok = 0;
02dea087 JD	211
	212	printk("Checking host MADV_REMOVE support...");
	213	fd = create_mem_file(UM_KERN_PAGE_SIZE);
	214	if(fd < 0){
	215	printk("Creating test memory file failed, err = %d\n", -fd);
e3104f50	216	goto out;
02dea087 JD	217	}
	218
	219	addr = mmap64(NULL, UM_KERN_PAGE_SIZE, PROT_READ \| PROT_WRITE,
b73781c8	220	MAP_SHARED, fd, 0);
02dea087 JD	221	if(addr == MAP_FAILED){
02dea087 JD	222	printk("Mapping test memory file failed, err = %d\n", -errno);
e3104f50	223	goto out_close;
02dea087 JD	224	}
	225
	226	if(madvise(addr, UM_KERN_PAGE_SIZE, MADV_REMOVE) != 0){
	227	printk("MADV_REMOVE failed, err = %d\n", -errno);
e3104f50	228	goto out_unmap;
02dea087 JD	229	}
	230
	231	printk("OK\n");
e3104f50 JD	232	ok = 1;
	233
	234	out_unmap:
	235	munmap(addr, UM_KERN_PAGE_SIZE);
	236	out_close:
	237	close(fd);
	238	out:
	239	return ok;
02dea087 JD	240	}
02dea087 JD	241
60d339f6 GS	242	void init_new_thread_stack(void sig_stack, void (usr1_handler)(int))
	243	{
	244	int flags = 0, pages;
	245
	246	if(sig_stack != NULL){
	247	pages = (1 << UML_CONFIG_KERNEL_STACK_ORDER);
1ffb9164	248	set_sigstack(sig_stack, pages * UM_KERN_PAGE_SIZE);
60d339f6 GS	249	flags = SA_ONSTACK;
60d339f6 GS	250	}
4b84c69b JD	251	if(usr1_handler){
	252	struct sigaction sa;
	253
	254	sa.sa_handler = usr1_handler;
	255	sigemptyset(&sa.sa_mask);
	256	sa.sa_flags = flags;
	257	sa.sa_restorer = NULL;
	258	if(sigaction(SIGUSR1, &sa, NULL) < 0)
	259	panic("init_new_thread_stack - sigaction failed - "
	260	"errno = %d\n", errno);
	261	}
60d339f6 GS	262	}
60d339f6 GS	263
e64bd134	264	void init_new_thread_signals(void)
60d339f6	265	{
e64bd134	266	set_handler(SIGSEGV, (__sighandler_t) sig_handler, SA_ONSTACK,
60d339f6	267	SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
e64bd134	268	set_handler(SIGTRAP, (__sighandler_t) sig_handler, SA_ONSTACK,
60d339f6	269	SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
e64bd134	270	set_handler(SIGFPE, (__sighandler_t) sig_handler, SA_ONSTACK,
60d339f6	271	SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
e64bd134	272	set_handler(SIGILL, (__sighandler_t) sig_handler, SA_ONSTACK,
60d339f6	273	SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
e64bd134	274	set_handler(SIGBUS, (__sighandler_t) sig_handler, SA_ONSTACK,
60d339f6 GS	275	SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
60d339f6 GS	276	set_handler(SIGUSR2, (__sighandler_t) sig_handler,
e64bd134 JD	277	SA_ONSTACK, SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM,
e64bd134 JD	278	-1);
60d339f6 GS	279	signal(SIGHUP, SIG_IGN);
60d339f6 GS	280
e64bd134	281	init_irq_signals(1);
60d339f6 GS	282	}
	283
	284	int run_kernel_thread(int (fn)(void ), void arg, void *jmp_ptr)
	285	{
ad28e029	286	jmp_buf buf;
a5df0d1a	287	int n;
1d7173ba JD	288
1d7173ba JD	289	*jmp_ptr = &buf;
a5df0d1a	290	n = UML_SETJMP(&buf);
1d7173ba	291	if(n != 0)
a5df0d1a	292	return n;
1d7173ba	293	(*fn)(arg);
a5df0d1a	294	return 0;
60d339f6	295	}