write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/lib/syscall.c
..
..
@@ -5,16 +5,15 @@
5
5
 #include <linux/export.h>
6
6
 #include <asm/syscall.h>
7
7
 
8
-static int collect_syscall(struct task_struct *target, long *callno,
9
-			   unsigned long args[6], unsigned int maxargs,
10
-			   unsigned long *sp, unsigned long *pc)
8
+static int collect_syscall(struct task_struct *target, struct syscall_info *info)
11
9
 {
10
+	unsigned long args[6] = { };
12
11
 	struct pt_regs *regs;
13
12
 
14
13
 	if (!try_get_task_stack(target)) {
15
14
 		/* Task has no stack, so the task isn't in a syscall. */
16
-		*sp = *pc = 0;
17
-		*callno = -1;
15
+		memset(info, 0, sizeof(*info));
16
+		info->data.nr = -1;
18
17
 		return 0;
19
18
 	}
20
19
 
..
..
@@ -24,12 +23,19 @@
24
23
 		return -EAGAIN;
25
24
 	}
26
25
 
27
-	*sp = user_stack_pointer(regs);
28
-	*pc = instruction_pointer(regs);
26
+	info->sp = user_stack_pointer(regs);
27
+	info->data.instruction_pointer = instruction_pointer(regs);
29
28
 
30
-	*callno = syscall_get_nr(target, regs);
31
-	if (*callno != -1L && maxargs > 0)
32
-		syscall_get_arguments(target, regs, 0, maxargs, args);
29
+	info->data.nr = syscall_get_nr(target, regs);
30
+	if (info->data.nr != -1L)
31
+		syscall_get_arguments(target, regs, args);
32
+
33
+	info->data.args[0] = args[0];
34
+	info->data.args[1] = args[1];
35
+	info->data.args[2] = args[2];
36
+	info->data.args[3] = args[3];
37
+	info->data.args[4] = args[4];
38
+	info->data.args[5] = args[5];
33
39
 
34
40
 	put_task_stack(target);
35
41
 	return 0;
..
..
@@ -38,41 +44,35 @@
38
44
 /**
39
45
  * task_current_syscall - Discover what a blocked task is doing.
40
46
  * @target:		thread to examine
41
- * @callno:		filled with system call number or -1
42
- * @args:		filled with @maxargs system call arguments
43
- * @maxargs:		number of elements in @args to fill
44
- * @sp:			filled with user stack pointer
45
- * @pc:			filled with user PC
47
+ * @info:		structure with the following fields:
48
+ *			 .sp        - filled with user stack pointer
49
+ *			 .data.nr   - filled with system call number or -1
50
+ *			 .data.args - filled with @maxargs system call arguments
51
+ *			 .data.instruction_pointer - filled with user PC
46
52
  *
47
- * If @target is blocked in a system call, returns zero with *@callno
48
- * set to the the call's number and @args filled in with its arguments.
49
- * Registers not used for system call arguments may not be available and
50
- * it is not kosher to use &struct user_regset calls while the system
53
+ * If @target is blocked in a system call, returns zero with @info.data.nr
54
+ * set to the call's number and @info.data.args filled in with its
55
+ * arguments. Registers not used for system call arguments may not be available
56
+ * and it is not kosher to use &struct user_regset calls while the system
51
57
  * call is still in progress.  Note we may get this result if @target
52
58
  * has finished its system call but not yet returned to user mode, such
53
59
  * as when it's stopped for signal handling or syscall exit tracing.
54
60
  *
55
61
  * If @target is blocked in the kernel during a fault or exception,
56
- * returns zero with *@callno set to -1 and does not fill in @args.
57
- * If so, it's now safe to examine @target using &struct user_regset
58
- * get() calls as long as we're sure @target won't return to user mode.
62
+ * returns zero with *@info.data.nr set to -1 and does not fill in
63
+ * @info.data.args. If so, it's now safe to examine @target using
64
+ * &struct user_regset get() calls as long as we're sure @target won't return
65
+ * to user mode.
59
66
  *
60
67
  * Returns -%EAGAIN if @target does not remain blocked.
61
- *
62
- * Returns -%EINVAL if @maxargs is too large (maximum is six).
63
68
  */
64
-int task_current_syscall(struct task_struct *target, long *callno,
65
-			 unsigned long args[6], unsigned int maxargs,
66
-			 unsigned long *sp, unsigned long *pc)
69
+int task_current_syscall(struct task_struct *target, struct syscall_info *info)
67
70
 {
68
71
 	long state;
69
72
 	unsigned long ncsw;
70
73
 
71
-	if (unlikely(maxargs > 6))
72
-		return -EINVAL;
73
-
74
74
 	if (target == current)
75
-		return collect_syscall(target, callno, args, maxargs, sp, pc);
75
+		return collect_syscall(target, info);
76
76
 
77
77
 	state = target->state;
78
78
 	if (unlikely(!state))
..
..
@@ -80,7 +80,7 @@
80
80
 
81
81
 	ncsw = wait_task_inactive(target, state);
82
82
 	if (unlikely(!ncsw) ||
83
-	    unlikely(collect_syscall(target, callno, args, maxargs, sp, pc)) ||
83
+	    unlikely(collect_syscall(target, info)) ||
84
84
 	    unlikely(wait_task_inactive(target, state) != ncsw))
85
85
 		return -EAGAIN;
86
86