Merge commit 'origin/master' into pr7043

Conflicts:
	runtime/print.c
	runtime/transport/transport.c
	runtime/transport/transport_msgs.h

1 files changed, 299 insertions, 108 deletions

diff --git a/runtime/syscall.h b/runtime/syscall.h
index ae451070..38b523e1 100644
--- a/runtime/syscall.h
+++ b/runtime/syscall.h
@@ -1,5 +1,6 @@
-/* syscall defines and inlines
- * Copyright (C) 2008 Red Hat Inc.
+/*
+ * syscall defines and inlines
+ * Copyright (C) 2008-2009 Red Hat Inc.
  *
  * This file is part of systemtap, and is free software.  You can
  * redistribute it and/or modify it under the terms of the GNU General
@@ -89,9 +90,17 @@
 #error "Unimplemented architecture"
 #endif
 
+#ifdef STAPCONF_ASM_SYSCALL_H
+
+/* If the system has asm/syscall.h, use defines from it. */
+#include <asm/syscall.h>
+
+#else  /* !STAPCONF_ASM_SYSCALL_H */
+
+/* If the system doesn't have asm/syscall.h, use our defines. */
 #if defined(__i386__) || defined(__x86_64__)
-static inline unsigned long
-__stp_user_syscall_nr(struct pt_regs *regs)
+static inline long
+syscall_get_nr(struct task_struct *task, struct pt_regs *regs)
 {
 #if defined(STAPCONF_X86_UNIREGS)
 	return regs->orig_ax;
@@ -104,37 +113,45 @@ __stp_user_syscall_nr(struct pt_regs *regs)
 #endif
 
 #if defined(__powerpc__)
-static inline unsigned long
-__stp_user_syscall_nr(struct pt_regs *regs)
+static inline long
+syscall_get_nr(struct task_struct *task, struct pt_regs *regs)
 {
 	return regs->gpr[0];
 }
 #endif
 
 #if defined(__ia64__)
-static inline unsigned long
-__stp_user_syscall_nr(struct pt_regs *regs)
+static inline long
+syscall_get_nr(struct task_struct *task, struct pt_regs *regs)
 {
-        return regs->r15;
+	if ((long)regs->cr_ifs < 0) /* Not a syscall */
+		return -1;
+
+#ifdef CONFIG_IA32_SUPPORT
+	if (IS_IA32_PROCESS(regs))
+		return regs->r1;
+#endif
+
+	return regs->r15;
 }
 #endif
 
 #if defined(__s390__) || defined(__s390x__)
-static inline unsigned long
-__stp_user_syscall_nr(struct pt_regs *regs)
+static inline long
+syscall_get_nr(struct task_struct *task, struct pt_regs *regs)
 {
-	    // might need to be 'orig_gpr2'
+	// might need to be 'orig_gpr2'
 	return regs->gprs[2];
 }
 #endif
 
 #if defined(__i386__) || defined(__x86_64__)
-static inline long *
-__stp_user_syscall_return_value(struct task_struct *task, struct pt_regs *regs)
+static inline long
+syscall_get_return_value(struct task_struct *task, struct pt_regs *regs)
 {
 #ifdef CONFIG_IA32_EMULATION
 // This code works, but isn't what we need.  Since
-// __stp_user_syscall_arg() doesn't sign-extend, a value passed in as
+// syscall_get_syscall_arg() doesn't sign-extend, a value passed in as
 // an argument and then returned won't compare correctly anymore.  So,
 // for now, disable this code.
 # if 0
@@ -145,158 +162,332 @@ __stp_user_syscall_return_value(struct task_struct *task, struct pt_regs *regs)
 # endif
 #endif
 #if defined(STAPCONF_X86_UNIREGS)
-	return &regs->ax;
+	return regs->ax;
 #elif defined(__x86_64__)
-	return &regs->rax;
+	return regs->rax;
 #elif defined (__i386__)
-	return &regs->eax;
+	return regs->eax;
 #endif
 }
 #endif
 
 #if defined(__powerpc__)
-static inline long *
-__stp_user_syscall_return_value(struct task_struct *task, struct pt_regs *regs)
+static inline long
+syscall_get_return_value(struct task_struct *task, struct pt_regs *regs)
 {
-	return &regs->gpr[3];
+	return regs->gpr[3];
 } 
 #endif
 
 #if defined(__ia64__)
-static inline long *
-__stp_user_syscall_return_value(struct task_struct *task, struct pt_regs *regs)
+static inline long
+syscall_get_return_value(struct task_struct *task, struct pt_regs *regs)
 {
-	return &regs->r8;
+	return regs->r8;
 }
 #endif
 
 #if defined(__s390__) || defined(__s390x__)
-static inline long *
-__stp_user_syscall_return_value(struct task_struct *task, struct pt_regs *regs)
+static inline long
+syscall_get_return_value(struct task_struct *task, struct pt_regs *regs)
 {
-	return &regs->gprs[2];
+	return regs->gprs[2];
 }
 #endif
 
 #if defined(__i386__) || defined(__x86_64__)
-static inline long *
-__stp_user_syscall_arg(struct task_struct *task, struct pt_regs *regs,
-		       unsigned int n)
+static inline void
+syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
+		      unsigned int i, unsigned int n, unsigned long *args)
 {
-#if defined(__i386__)
-	if (n > 5) {
-		_stp_error("syscall arg > 5");
-		return NULL;
+	if (i + n > 6) {
+		_stp_error("invalid syscall arg request");
+		return;
 	}
+#if defined(__i386__)
 #if defined(STAPCONF_X86_UNIREGS)
-	return &regs->bx + n;
+	memcpy(args, &regs->bx + i, n * sizeof(args[0]));
 #else
-	return &regs->ebx + n;
+	memcpy(args, &regs->ebx + i, n * sizeof(args[0]));
 #endif
 #elif defined(__x86_64__)
 #ifdef CONFIG_IA32_EMULATION
-	if (test_tsk_thread_flag(task, TIF_IA32))
-		switch (n) {
+	if (test_tsk_thread_flag(task, TIF_IA32)) {
+		switch (i) {
 #if defined(STAPCONF_X86_UNIREGS)
-		case 0: return &regs->bx;
-		case 1: return &regs->cx;
-		case 2: return &regs->dx;
-		case 3: return &regs->si;
-		case 4: return &regs->di;
-		case 5: return &regs->bp;
+		case 0:
+			if (!n--) break;
+			*args++ = regs->bx;
+		case 1:
+			if (!n--) break;
+			*args++ = regs->cx;
+		case 2:
+			if (!n--) break;
+			*args++ = regs->dx;
+		case 3:
+			if (!n--) break;
+			*args++ = regs->si;
+		case 4:
+			if (!n--) break;
+			*args++ = regs->di;
+		case 5:
+			if (!n--) break;
+			*args++ = regs->bp;
 #else
-		case 0: return &regs->rbx;
-		case 1: return &regs->rcx;
-		case 2: return &regs->rdx;
-		case 3: return &regs->rsi;
-		case 4: return &regs->rdi;
-		case 5: return &regs->rbp;
+		case 0:
+			if (!n--) break;
+			*args++ = regs->rbx;
+		case 1:
+			if (!n--) break;
+			*args++ = regs->rcx;
+		case 2:
+			if (!n--) break;
+			*args++ = regs->rdx;
+		case 3:
+			if (!n--) break;
+			*args++ = regs->rsi;
+		case 4:
+			if (!n--) break;
+			*args++ = regs->rdi;
+		case 5:
+			if (!n--) break;
+			*args++ = regs->rbp;
 #endif
-		default: 
-			_stp_error("syscall arg > 5");
-			return NULL;
 		}
+		return;
+	}
 #endif /* CONFIG_IA32_EMULATION */
-	switch (n) {
+	switch (i) {
 #if defined(STAPCONF_X86_UNIREGS)
-	case 0: return &regs->di;
-	case 1: return &regs->si;
-	case 2: return &regs->dx;
-	case 3: return &regs->r10;
-	case 4: return &regs->r8;
-	case 5: return &regs->r9;
+	case 0:
+		if (!n--) break;
+		*args++ = regs->di;
+	case 1:
+		if (!n--) break;
+		*args++ = regs->si;
+	case 2:
+		if (!n--) break;
+		*args++ = regs->dx;
+	case 3:
+		if (!n--) break;
+		*args++ = regs->r10;
+	case 4:
+		if (!n--) break;
+		*args++ = regs->r8;
+	case 5:
+		if (!n--) break;
+		*args++ = regs->r9;
 #else
-	case 0: return &regs->rdi;
-	case 1: return &regs->rsi;
-	case 2: return &regs->rdx;
-	case 3: return &regs->r10;
-	case 4: return &regs->r8;
-	case 5: return &regs->r9;
+	case 0:
+		if (!n--) break;
+		*args++ = regs->rdi;
+	case 1:
+		if (!n--) break;
+		*args++ = regs->rsi;
+	case 2:
+		if (!n--) break;
+		*args++ = regs->rdx;
+	case 3:
+		if (!n--) break;
+		*args++ = regs->r10;
+	case 4:
+		if (!n--) break;
+		*args++ = regs->r8;
+	case 5:
+		if (!n--) break;
+		*args++ = regs->r9;
 #endif
-	default: 
-		_stp_error("syscall arg > 5");
-		return NULL;
 	}
 #endif /* CONFIG_X86_32 */
+	return;
 }
 #endif
 
 #if defined(__powerpc__)
-static inline long *
-__stp_user_syscall_arg(struct task_struct *task, struct pt_regs *regs,
-		       unsigned int n)
+static inline void
+syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
+		      unsigned int i, unsigned int n, unsigned long *args)
 {
-	switch (n) {
-	case 0: return &regs->gpr[3];
-	case 1: return &regs->gpr[4];
-	case 2: return &regs->gpr[5];
-	case 3: return &regs->gpr[6];
-	case 4: return &regs->gpr[7];
-	case 5: return &regs->gpr[8];
-	default:
-		_stp_error("syscall arg > 5");
-		return NULL;
+	if (i + n > 6) {
+		_stp_error("invalid syscall arg request");
+		return;
 	}
+#ifdef CONFIG_PPC64
+	if (test_tsk_thread_flag(task, TIF_32BIT)) {
+		/*
+		 * Zero-extend 32-bit argument values.  The high bits are
+		 * garbage ignored by the actual syscall dispatch.
+		 */
+		while (n-- > 0)
+			args[n] = (u32) regs->gpr[3 + i + n];
+		return;
+	}
+#endif
+	memcpy(args, &regs->gpr[3 + i], n * sizeof(args[0]));
 }
 #endif
 
 #if defined(__ia64__)
-#define __stp_user_syscall_arg(task, regs, n) \
-	____stp_user_syscall_arg(task, regs, n, &c->unwaddr)
 
-static inline long *
-____stp_user_syscall_arg(struct task_struct *task, struct pt_regs *regs,
-			 unsigned int n, unsigned long **cache)
+/* Return TRUE if PT was created due to kernel-entry via a system-call.  */
+
+static inline int
+in_syscall (struct pt_regs *pt)
+{
+	return (long) pt->cr_ifs >= 0;
+}
+
+struct syscall_get_set_args {
+	unsigned int i;
+	unsigned int n;
+	unsigned long *args;
+	struct pt_regs *regs;
+	int rw;
+};
+
+#define CFM_SOF(cfm) ((cfm) & 0x7f)			/* Size of frame */
+#define CFM_SOL(cfm) (((cfm) >> 7) & 0x7f)		/* Size of locals */
+#define CFM_OUT(cfm) (CFM_SOF(cfm) - CFM_SOL(cfm))	/* Size of outputs */
+
+static void syscall_get_set_args_cb(struct unw_frame_info *info, void *data)
+{
+	struct syscall_get_set_args *args = data;
+	struct pt_regs *pt = args->regs;
+	unsigned long *krbs, cfm, ndirty;
+	int i, count;
+
+	if (unw_unwind_to_user(info) < 0)
+		return;
+
+	cfm = pt->cr_ifs;
+	krbs = (unsigned long *)info->task + IA64_RBS_OFFSET/8;
+	ndirty = ia64_rse_num_regs(krbs, krbs + (pt->loadrs >> 19));
+
+	count = 0;
+	if (in_syscall(pt))
+		/* args->i + args->n must be less equal than nr outputs */
+		count = min_t(int, args->n, CFM_OUT(cfm) - args->i);
+
+	for (i = 0; i < count; i++) {
+		/* Skips dirties and locals */
+		if (args->rw)
+			*ia64_rse_skip_regs(krbs,
+				ndirty + CFM_SOL(cfm) + args->i + i) =
+				args->args[i];
+		else
+			args->args[i] = *ia64_rse_skip_regs(krbs,
+				ndirty + CFM_SOL(cfm) + args->i + i);
+	}
+
+	if (!args->rw) {
+		while (i < args->n) {
+			args->args[i] = 0;
+			i++;
+		}
+	}
+}
+
+void ia64_syscall_get_set_arguments(struct task_struct *task,
+	struct pt_regs *regs, unsigned int i, unsigned int n,
+	unsigned long *args, int rw)
 {
-	if (n > 5) {
-		_stp_error("syscall arg > 5");
-		return NULL;
+	struct syscall_get_set_args data = {
+		.i = i,
+		.n = n,
+		.args = args,
+		.regs = regs,
+		.rw = rw,
+	};
+
+	if (task == current)
+		unw_init_running(syscall_get_set_args_cb, &data);
+	else {
+		struct unw_frame_info ufi;
+		memset(&ufi, 0, sizeof(ufi));
+		unw_init_from_blocked_task(&ufi, task);
+		syscall_get_set_args_cb(&ufi, &data);
 	}
-	return __ia64_fetch_register(n + 32, regs, cache);
+}
+
+static inline void syscall_get_arguments(struct task_struct *task,
+					 struct pt_regs *regs,
+					 unsigned int i, unsigned int n,
+					 unsigned long *args)
+{
+	BUG_ON(i + n > 6);
+
+#ifdef CONFIG_IA32_SUPPORT
+	if (IS_IA32_PROCESS(regs)) {
+		switch (i + n) {
+		case 6:
+			if (!n--) break;
+			*args++ = regs->r13;
+		case 5:
+			if (!n--) break;
+			*args++ = regs->r15;
+		case 4:
+			if (!n--) break;
+			*args++ = regs->r14;
+		case 3:
+			if (!n--) break;
+			*args++ = regs->r10;
+		case 2:
+			if (!n--) break;
+			*args++ = regs->r9;
+		case 1:
+			if (!n--) break;
+			*args++ = regs->r11;
+		case 0:
+			if (!n--) break;
+		default:
+			BUG();
+			break;
+		}
+
+		return;
+	}
+#endif
+	ia64_syscall_get_set_arguments(task, regs, i, n, args, 0);
 }
 #endif
 
 #if defined(__s390__) || defined(__s390x__)
-static inline long *
-__stp_user_syscall_arg(struct task_struct *task, struct pt_regs *regs,
-		       unsigned int n)
+static inline void
+syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
+		      unsigned int i, unsigned int n, unsigned long *args)
 {
-	/* If we were returning a value, we could check for TIF_31BIT
-	 * here and cast the value with '(u32)' to make sure it got
-	 * down to 32bits.  But, since we're returning an address,
-	 * there isn't much we can do. */
-	switch (n) {
-	case 0: return &regs->orig_gpr2;
-	case 1: return &regs->gprs[3];
-	case 2: return &regs->gprs[4];
-	case 3: return &regs->gprs[5];
-	case 4: return &regs->gprs[6];
-	case 5: return &regs->args[0];
-	default:
-		_stp_error("syscall arg > 5");
-		return NULL;
+	unsigned long mask = -1UL;
+
+	if (i + n > 6) {
+		_stp_error("invalid syscall arg request");
+		return;
+	}
+#ifdef CONFIG_COMPAT
+	if (test_tsk_thread_flag(task, TIF_31BIT))
+		mask = 0xffffffff;
+#endif
+	switch (i) {
+	case 0:
+		if (!n--) break;
+		*args++ = regs->orig_gpr2 & mask;
+	case 1:
+		if (!n--) break;
+		*args++ = regs->gprs[3] & mask;
+	case 2:
+		if (!n--) break;
+		*args++ = regs->gprs[4] & mask;
+	case 3:
+		if (!n--) break;
+		*args++ = regs->gprs[5] & mask;
+	case 4:
+		if (!n--) break;
+		*args++ = regs->gprs[6] & mask;
+	case 5:
+		if (!n--) break;
+		*args++ = regs->args[0] & mask;
 	}
 }
 #endif
 
+#endif /* !STAPCONF_ASM_SYSCALL_H */
 #endif /* _SYSCALL_H_ */