diff options
author | Ralf Baechle <ralf@linux-mips.org> | 2012-10-11 05:14:12 -0400 |
---|---|---|
committer | Ralf Baechle <ralf@linux-mips.org> | 2012-10-11 05:14:12 -0400 |
commit | 2551aebc670073530d15ee249c6e41afda82a98b (patch) | |
tree | accd5291cdc50edd12a76ff514b6b06ed30367cd | |
parent | 2eaaac508a7435dda92f9f16d612a1354ea3d7c4 (diff) |
MIPS: MT: Remove kspd.
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
-rw-r--r-- | arch/mips/Kconfig | 10 | ||||
-rw-r--r-- | arch/mips/include/asm/kspd.h | 4 | ||||
-rw-r--r-- | arch/mips/kernel/Makefile | 1 | ||||
-rw-r--r-- | arch/mips/kernel/kspd.c | 423 | ||||
-rw-r--r-- | arch/mips/kernel/vpe.c | 24 |
5 files changed, 0 insertions, 462 deletions
diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig index 2c580cf59397..3803696e635d 100644 --- a/arch/mips/Kconfig +++ b/arch/mips/Kconfig | |||
@@ -2039,16 +2039,6 @@ config MIPS_VPE_APSP_API | |||
2039 | depends on MIPS_VPE_LOADER | 2039 | depends on MIPS_VPE_LOADER |
2040 | help | 2040 | help |
2041 | 2041 | ||
2042 | config MIPS_APSP_KSPD | ||
2043 | bool "Enable KSPD" | ||
2044 | depends on MIPS_VPE_APSP_API | ||
2045 | default y | ||
2046 | help | ||
2047 | KSPD is a kernel daemon that accepts syscall requests from the SP | ||
2048 | side, actions them and returns the results. It also handles the | ||
2049 | "exit" syscall notifying other kernel modules the SP program is | ||
2050 | exiting. You probably want to say yes here. | ||
2051 | |||
2052 | config MIPS_CMP | 2042 | config MIPS_CMP |
2053 | bool "MIPS CMP framework support" | 2043 | bool "MIPS CMP framework support" |
2054 | depends on SYS_SUPPORTS_MIPS_CMP | 2044 | depends on SYS_SUPPORTS_MIPS_CMP |
diff --git a/arch/mips/include/asm/kspd.h b/arch/mips/include/asm/kspd.h index 4e9e724c8935..ec6832950ace 100644 --- a/arch/mips/include/asm/kspd.h +++ b/arch/mips/include/asm/kspd.h | |||
@@ -25,12 +25,8 @@ struct kspd_notifications { | |||
25 | struct list_head list; | 25 | struct list_head list; |
26 | }; | 26 | }; |
27 | 27 | ||
28 | #ifdef CONFIG_MIPS_APSP_KSPD | ||
29 | extern void kspd_notify(struct kspd_notifications *notify); | ||
30 | #else | ||
31 | static inline void kspd_notify(struct kspd_notifications *notify) | 28 | static inline void kspd_notify(struct kspd_notifications *notify) |
32 | { | 29 | { |
33 | } | 30 | } |
34 | #endif | ||
35 | 31 | ||
36 | #endif | 32 | #endif |
diff --git a/arch/mips/kernel/Makefile b/arch/mips/kernel/Makefile index d6c2a7476bac..e49c4469f73c 100644 --- a/arch/mips/kernel/Makefile +++ b/arch/mips/kernel/Makefile | |||
@@ -53,7 +53,6 @@ obj-$(CONFIG_CPU_MIPSR2) += spram.o | |||
53 | 53 | ||
54 | obj-$(CONFIG_MIPS_VPE_LOADER) += vpe.o | 54 | obj-$(CONFIG_MIPS_VPE_LOADER) += vpe.o |
55 | obj-$(CONFIG_MIPS_VPE_APSP_API) += rtlx.o | 55 | obj-$(CONFIG_MIPS_VPE_APSP_API) += rtlx.o |
56 | obj-$(CONFIG_MIPS_APSP_KSPD) += kspd.o | ||
57 | 56 | ||
58 | obj-$(CONFIG_I8259) += i8259.o | 57 | obj-$(CONFIG_I8259) += i8259.o |
59 | obj-$(CONFIG_IRQ_CPU) += irq_cpu.o | 58 | obj-$(CONFIG_IRQ_CPU) += irq_cpu.o |
diff --git a/arch/mips/kernel/kspd.c b/arch/mips/kernel/kspd.c deleted file mode 100644 index b77f56bbb477..000000000000 --- a/arch/mips/kernel/kspd.c +++ /dev/null | |||
@@ -1,423 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2005 MIPS Technologies, Inc. All rights reserved. | ||
3 | * | ||
4 | * This program is free software; you can distribute it and/or modify it | ||
5 | * under the terms of the GNU General Public License (Version 2) as | ||
6 | * published by the Free Software Foundation. | ||
7 | * | ||
8 | * This program is distributed in the hope it will be useful, but WITHOUT | ||
9 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
10 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
11 | * for more details. | ||
12 | * | ||
13 | * You should have received a copy of the GNU General Public License along | ||
14 | * with this program; if not, write to the Free Software Foundation, Inc., | ||
15 | * 59 Temple Place - Suite 330, Boston MA 02111-1307, USA. | ||
16 | * | ||
17 | */ | ||
18 | #include <linux/kernel.h> | ||
19 | #include <linux/module.h> | ||
20 | #include <linux/sched.h> | ||
21 | #include <linux/unistd.h> | ||
22 | #include <linux/file.h> | ||
23 | #include <linux/fdtable.h> | ||
24 | #include <linux/fs.h> | ||
25 | #include <linux/syscalls.h> | ||
26 | #include <linux/workqueue.h> | ||
27 | #include <linux/errno.h> | ||
28 | #include <linux/list.h> | ||
29 | |||
30 | #include <asm/vpe.h> | ||
31 | #include <asm/rtlx.h> | ||
32 | #include <asm/kspd.h> | ||
33 | |||
34 | static struct workqueue_struct *workqueue; | ||
35 | static struct work_struct work; | ||
36 | |||
37 | extern unsigned long cpu_khz; | ||
38 | |||
39 | struct mtsp_syscall { | ||
40 | int cmd; | ||
41 | unsigned char abi; | ||
42 | unsigned char size; | ||
43 | }; | ||
44 | |||
45 | struct mtsp_syscall_ret { | ||
46 | int retval; | ||
47 | int errno; | ||
48 | }; | ||
49 | |||
50 | struct mtsp_syscall_generic { | ||
51 | int arg0; | ||
52 | int arg1; | ||
53 | int arg2; | ||
54 | int arg3; | ||
55 | int arg4; | ||
56 | int arg5; | ||
57 | int arg6; | ||
58 | }; | ||
59 | |||
60 | static struct list_head kspd_notifylist; | ||
61 | static int sp_stopping; | ||
62 | |||
63 | /* these should match with those in the SDE kit */ | ||
64 | #define MTSP_SYSCALL_BASE 0 | ||
65 | #define MTSP_SYSCALL_EXIT (MTSP_SYSCALL_BASE + 0) | ||
66 | #define MTSP_SYSCALL_OPEN (MTSP_SYSCALL_BASE + 1) | ||
67 | #define MTSP_SYSCALL_READ (MTSP_SYSCALL_BASE + 2) | ||
68 | #define MTSP_SYSCALL_WRITE (MTSP_SYSCALL_BASE + 3) | ||
69 | #define MTSP_SYSCALL_CLOSE (MTSP_SYSCALL_BASE + 4) | ||
70 | #define MTSP_SYSCALL_LSEEK32 (MTSP_SYSCALL_BASE + 5) | ||
71 | #define MTSP_SYSCALL_ISATTY (MTSP_SYSCALL_BASE + 6) | ||
72 | #define MTSP_SYSCALL_GETTIME (MTSP_SYSCALL_BASE + 7) | ||
73 | #define MTSP_SYSCALL_PIPEFREQ (MTSP_SYSCALL_BASE + 8) | ||
74 | #define MTSP_SYSCALL_GETTOD (MTSP_SYSCALL_BASE + 9) | ||
75 | #define MTSP_SYSCALL_IOCTL (MTSP_SYSCALL_BASE + 10) | ||
76 | |||
77 | #define MTSP_O_RDONLY 0x0000 | ||
78 | #define MTSP_O_WRONLY 0x0001 | ||
79 | #define MTSP_O_RDWR 0x0002 | ||
80 | #define MTSP_O_NONBLOCK 0x0004 | ||
81 | #define MTSP_O_APPEND 0x0008 | ||
82 | #define MTSP_O_SHLOCK 0x0010 | ||
83 | #define MTSP_O_EXLOCK 0x0020 | ||
84 | #define MTSP_O_ASYNC 0x0040 | ||
85 | /* XXX: check which of these is actually O_SYNC vs O_DSYNC */ | ||
86 | #define MTSP_O_FSYNC O_SYNC | ||
87 | #define MTSP_O_NOFOLLOW 0x0100 | ||
88 | #define MTSP_O_SYNC 0x0080 | ||
89 | #define MTSP_O_CREAT 0x0200 | ||
90 | #define MTSP_O_TRUNC 0x0400 | ||
91 | #define MTSP_O_EXCL 0x0800 | ||
92 | #define MTSP_O_BINARY 0x8000 | ||
93 | |||
94 | extern int tclimit; | ||
95 | |||
96 | struct apsp_table { | ||
97 | int sp; | ||
98 | int ap; | ||
99 | }; | ||
100 | |||
101 | /* we might want to do the mode flags too */ | ||
102 | struct apsp_table open_flags_table[] = { | ||
103 | { MTSP_O_RDWR, O_RDWR }, | ||
104 | { MTSP_O_WRONLY, O_WRONLY }, | ||
105 | { MTSP_O_CREAT, O_CREAT }, | ||
106 | { MTSP_O_TRUNC, O_TRUNC }, | ||
107 | { MTSP_O_NONBLOCK, O_NONBLOCK }, | ||
108 | { MTSP_O_APPEND, O_APPEND }, | ||
109 | { MTSP_O_NOFOLLOW, O_NOFOLLOW } | ||
110 | }; | ||
111 | |||
112 | struct apsp_table syscall_command_table[] = { | ||
113 | { MTSP_SYSCALL_OPEN, __NR_open }, | ||
114 | { MTSP_SYSCALL_CLOSE, __NR_close }, | ||
115 | { MTSP_SYSCALL_READ, __NR_read }, | ||
116 | { MTSP_SYSCALL_WRITE, __NR_write }, | ||
117 | { MTSP_SYSCALL_LSEEK32, __NR_lseek }, | ||
118 | { MTSP_SYSCALL_IOCTL, __NR_ioctl } | ||
119 | }; | ||
120 | |||
121 | static int sp_syscall(int num, int arg0, int arg1, int arg2, int arg3) | ||
122 | { | ||
123 | register long int _num __asm__("$2") = num; | ||
124 | register long int _arg0 __asm__("$4") = arg0; | ||
125 | register long int _arg1 __asm__("$5") = arg1; | ||
126 | register long int _arg2 __asm__("$6") = arg2; | ||
127 | register long int _arg3 __asm__("$7") = arg3; | ||
128 | |||
129 | mm_segment_t old_fs; | ||
130 | |||
131 | old_fs = get_fs(); | ||
132 | set_fs(KERNEL_DS); | ||
133 | |||
134 | __asm__ __volatile__ ( | ||
135 | " syscall \n" | ||
136 | : "=r" (_num), "=r" (_arg3) | ||
137 | : "r" (_num), "r" (_arg0), "r" (_arg1), "r" (_arg2), "r" (_arg3)); | ||
138 | |||
139 | set_fs(old_fs); | ||
140 | |||
141 | /* $a3 is error flag */ | ||
142 | if (_arg3) | ||
143 | return -_num; | ||
144 | |||
145 | return _num; | ||
146 | } | ||
147 | |||
148 | static int translate_syscall_command(int cmd) | ||
149 | { | ||
150 | int i; | ||
151 | int ret = -1; | ||
152 | |||
153 | for (i = 0; i < ARRAY_SIZE(syscall_command_table); i++) { | ||
154 | if ((cmd == syscall_command_table[i].sp)) | ||
155 | return syscall_command_table[i].ap; | ||
156 | } | ||
157 | |||
158 | return ret; | ||
159 | } | ||
160 | |||
161 | static unsigned int translate_open_flags(int flags) | ||
162 | { | ||
163 | int i; | ||
164 | unsigned int ret = 0; | ||
165 | |||
166 | for (i = 0; i < ARRAY_SIZE(open_flags_table); i++) { | ||
167 | if( (flags & open_flags_table[i].sp) ) { | ||
168 | ret |= open_flags_table[i].ap; | ||
169 | } | ||
170 | } | ||
171 | |||
172 | return ret; | ||
173 | } | ||
174 | |||
175 | |||
176 | static int sp_setfsuidgid(uid_t uid, gid_t gid) | ||
177 | { | ||
178 | struct cred *new; | ||
179 | |||
180 | new = prepare_creds(); | ||
181 | if (!new) | ||
182 | return -ENOMEM; | ||
183 | |||
184 | new->fsuid = uid; | ||
185 | new->fsgid = gid; | ||
186 | |||
187 | commit_creds(new); | ||
188 | |||
189 | return 0; | ||
190 | } | ||
191 | |||
192 | /* | ||
193 | * Expects a request to be on the sysio channel. Reads it. Decides whether | ||
194 | * its a linux syscall and runs it, or whatever. Puts the return code back | ||
195 | * into the request and sends the whole thing back. | ||
196 | */ | ||
197 | void sp_work_handle_request(void) | ||
198 | { | ||
199 | struct mtsp_syscall sc; | ||
200 | struct mtsp_syscall_generic generic; | ||
201 | struct mtsp_syscall_ret ret; | ||
202 | struct kspd_notifications *n; | ||
203 | unsigned long written; | ||
204 | mm_segment_t old_fs; | ||
205 | struct timeval tv; | ||
206 | struct timezone tz; | ||
207 | int err, cmd; | ||
208 | |||
209 | char *vcwd; | ||
210 | int size; | ||
211 | |||
212 | ret.retval = -1; | ||
213 | |||
214 | old_fs = get_fs(); | ||
215 | set_fs(KERNEL_DS); | ||
216 | |||
217 | if (!rtlx_read(RTLX_CHANNEL_SYSIO, &sc, sizeof(struct mtsp_syscall))) { | ||
218 | set_fs(old_fs); | ||
219 | printk(KERN_ERR "Expected request but nothing to read\n"); | ||
220 | return; | ||
221 | } | ||
222 | |||
223 | size = sc.size; | ||
224 | |||
225 | if (size) { | ||
226 | if (!rtlx_read(RTLX_CHANNEL_SYSIO, &generic, size)) { | ||
227 | set_fs(old_fs); | ||
228 | printk(KERN_ERR "Expected request but nothing to read\n"); | ||
229 | return; | ||
230 | } | ||
231 | } | ||
232 | |||
233 | /* Run the syscall at the privilege of the user who loaded the | ||
234 | SP program */ | ||
235 | |||
236 | if (vpe_getuid(tclimit)) { | ||
237 | err = sp_setfsuidgid(vpe_getuid(tclimit), vpe_getgid(tclimit)); | ||
238 | if (!err) | ||
239 | pr_err("Change of creds failed\n"); | ||
240 | } | ||
241 | |||
242 | switch (sc.cmd) { | ||
243 | /* needs the flags argument translating from SDE kit to | ||
244 | linux */ | ||
245 | case MTSP_SYSCALL_PIPEFREQ: | ||
246 | ret.retval = cpu_khz * 1000; | ||
247 | ret.errno = 0; | ||
248 | break; | ||
249 | |||
250 | case MTSP_SYSCALL_GETTOD: | ||
251 | memset(&tz, 0, sizeof(tz)); | ||
252 | if ((ret.retval = sp_syscall(__NR_gettimeofday, (int)&tv, | ||
253 | (int)&tz, 0, 0)) == 0) | ||
254 | ret.retval = tv.tv_sec; | ||
255 | break; | ||
256 | |||
257 | case MTSP_SYSCALL_EXIT: | ||
258 | list_for_each_entry(n, &kspd_notifylist, list) | ||
259 | n->kspd_sp_exit(tclimit); | ||
260 | sp_stopping = 1; | ||
261 | |||
262 | printk(KERN_DEBUG "KSPD got exit syscall from SP exitcode %d\n", | ||
263 | generic.arg0); | ||
264 | break; | ||
265 | |||
266 | case MTSP_SYSCALL_OPEN: | ||
267 | generic.arg1 = translate_open_flags(generic.arg1); | ||
268 | |||
269 | vcwd = vpe_getcwd(tclimit); | ||
270 | |||
271 | /* change to cwd of the process that loaded the SP program */ | ||
272 | old_fs = get_fs(); | ||
273 | set_fs(KERNEL_DS); | ||
274 | sys_chdir(vcwd); | ||
275 | set_fs(old_fs); | ||
276 | |||
277 | sc.cmd = __NR_open; | ||
278 | |||
279 | /* fall through */ | ||
280 | |||
281 | default: | ||
282 | if ((sc.cmd >= __NR_Linux) && | ||
283 | (sc.cmd <= (__NR_Linux + __NR_Linux_syscalls)) ) | ||
284 | cmd = sc.cmd; | ||
285 | else | ||
286 | cmd = translate_syscall_command(sc.cmd); | ||
287 | |||
288 | if (cmd >= 0) { | ||
289 | ret.retval = sp_syscall(cmd, generic.arg0, generic.arg1, | ||
290 | generic.arg2, generic.arg3); | ||
291 | } else | ||
292 | printk(KERN_WARNING | ||
293 | "KSPD: Unknown SP syscall number %d\n", sc.cmd); | ||
294 | break; | ||
295 | } /* switch */ | ||
296 | |||
297 | if (vpe_getuid(tclimit)) { | ||
298 | err = sp_setfsuidgid(0, 0); | ||
299 | if (!err) | ||
300 | pr_err("restoring old creds failed\n"); | ||
301 | } | ||
302 | |||
303 | old_fs = get_fs(); | ||
304 | set_fs(KERNEL_DS); | ||
305 | written = rtlx_write(RTLX_CHANNEL_SYSIO, &ret, sizeof(ret)); | ||
306 | set_fs(old_fs); | ||
307 | if (written < sizeof(ret)) | ||
308 | printk("KSPD: sp_work_handle_request failed to send to SP\n"); | ||
309 | } | ||
310 | |||
311 | static void sp_cleanup(void) | ||
312 | { | ||
313 | struct files_struct *files = current->files; | ||
314 | int i, j; | ||
315 | struct fdtable *fdt; | ||
316 | |||
317 | j = 0; | ||
318 | |||
319 | /* | ||
320 | * It is safe to dereference the fd table without RCU or | ||
321 | * ->file_lock | ||
322 | */ | ||
323 | fdt = files_fdtable(files); | ||
324 | for (;;) { | ||
325 | unsigned long set; | ||
326 | i = j * BITS_PER_LONG; | ||
327 | if (i >= fdt->max_fds) | ||
328 | break; | ||
329 | set = fdt->open_fds[j++]; | ||
330 | while (set) { | ||
331 | if (set & 1) { | ||
332 | struct file * file = xchg(&fdt->fd[i], NULL); | ||
333 | if (file) | ||
334 | filp_close(file, files); | ||
335 | } | ||
336 | i++; | ||
337 | set >>= 1; | ||
338 | } | ||
339 | } | ||
340 | |||
341 | /* Put daemon cwd back to root to avoid umount problems */ | ||
342 | sys_chdir("/"); | ||
343 | } | ||
344 | |||
345 | static int channel_open; | ||
346 | |||
347 | /* the work handler */ | ||
348 | static void sp_work(struct work_struct *unused) | ||
349 | { | ||
350 | if (!channel_open) { | ||
351 | if( rtlx_open(RTLX_CHANNEL_SYSIO, 1) != 0) { | ||
352 | printk("KSPD: unable to open sp channel\n"); | ||
353 | sp_stopping = 1; | ||
354 | } else { | ||
355 | channel_open++; | ||
356 | printk(KERN_DEBUG "KSPD: SP channel opened\n"); | ||
357 | } | ||
358 | } else { | ||
359 | /* wait for some data, allow it to sleep */ | ||
360 | rtlx_read_poll(RTLX_CHANNEL_SYSIO, 1); | ||
361 | |||
362 | /* Check we haven't been woken because we are stopping */ | ||
363 | if (!sp_stopping) | ||
364 | sp_work_handle_request(); | ||
365 | } | ||
366 | |||
367 | if (!sp_stopping) | ||
368 | queue_work(workqueue, &work); | ||
369 | else | ||
370 | sp_cleanup(); | ||
371 | } | ||
372 | |||
373 | static void startwork(int vpe) | ||
374 | { | ||
375 | sp_stopping = channel_open = 0; | ||
376 | |||
377 | if (workqueue == NULL) { | ||
378 | if ((workqueue = create_singlethread_workqueue("kspd")) == NULL) { | ||
379 | printk(KERN_ERR "unable to start kspd\n"); | ||
380 | return; | ||
381 | } | ||
382 | |||
383 | INIT_WORK(&work, sp_work); | ||
384 | } | ||
385 | |||
386 | queue_work(workqueue, &work); | ||
387 | } | ||
388 | |||
389 | static void stopwork(int vpe) | ||
390 | { | ||
391 | sp_stopping = 1; | ||
392 | |||
393 | printk(KERN_DEBUG "KSPD: SP stopping\n"); | ||
394 | } | ||
395 | |||
396 | void kspd_notify(struct kspd_notifications *notify) | ||
397 | { | ||
398 | list_add(¬ify->list, &kspd_notifylist); | ||
399 | } | ||
400 | |||
401 | static struct vpe_notifications notify; | ||
402 | static int kspd_module_init(void) | ||
403 | { | ||
404 | INIT_LIST_HEAD(&kspd_notifylist); | ||
405 | |||
406 | notify.start = startwork; | ||
407 | notify.stop = stopwork; | ||
408 | vpe_notify(tclimit, ¬ify); | ||
409 | |||
410 | return 0; | ||
411 | } | ||
412 | |||
413 | static void kspd_module_exit(void) | ||
414 | { | ||
415 | |||
416 | } | ||
417 | |||
418 | module_init(kspd_module_init); | ||
419 | module_exit(kspd_module_exit); | ||
420 | |||
421 | MODULE_DESCRIPTION("MIPS KSPD"); | ||
422 | MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc."); | ||
423 | MODULE_LICENSE("GPL"); | ||
diff --git a/arch/mips/kernel/vpe.c b/arch/mips/kernel/vpe.c index f6f91523cb1c..eec690af6581 100644 --- a/arch/mips/kernel/vpe.c +++ b/arch/mips/kernel/vpe.c | |||
@@ -50,7 +50,6 @@ | |||
50 | #include <asm/mips_mt.h> | 50 | #include <asm/mips_mt.h> |
51 | #include <asm/processor.h> | 51 | #include <asm/processor.h> |
52 | #include <asm/vpe.h> | 52 | #include <asm/vpe.h> |
53 | #include <asm/kspd.h> | ||
54 | 53 | ||
55 | typedef void *vpe_handle; | 54 | typedef void *vpe_handle; |
56 | 55 | ||
@@ -69,11 +68,6 @@ static char module_name[] = "vpe"; | |||
69 | static int major; | 68 | static int major; |
70 | static const int minor = 1; /* fixed for now */ | 69 | static const int minor = 1; /* fixed for now */ |
71 | 70 | ||
72 | #ifdef CONFIG_MIPS_APSP_KSPD | ||
73 | static struct kspd_notifications kspd_events; | ||
74 | static int kspd_events_reqd; | ||
75 | #endif | ||
76 | |||
77 | /* grab the likely amount of memory we will need. */ | 71 | /* grab the likely amount of memory we will need. */ |
78 | #ifdef CONFIG_MIPS_VPE_LOADER_TOM | 72 | #ifdef CONFIG_MIPS_VPE_LOADER_TOM |
79 | #define P_SIZE (2 * 1024 * 1024) | 73 | #define P_SIZE (2 * 1024 * 1024) |
@@ -1101,14 +1095,6 @@ static int vpe_open(struct inode *inode, struct file *filp) | |||
1101 | v->uid = filp->f_cred->fsuid; | 1095 | v->uid = filp->f_cred->fsuid; |
1102 | v->gid = filp->f_cred->fsgid; | 1096 | v->gid = filp->f_cred->fsgid; |
1103 | 1097 | ||
1104 | #ifdef CONFIG_MIPS_APSP_KSPD | ||
1105 | /* get kspd to tell us when a syscall_exit happens */ | ||
1106 | if (!kspd_events_reqd) { | ||
1107 | kspd_notify(&kspd_events); | ||
1108 | kspd_events_reqd++; | ||
1109 | } | ||
1110 | #endif | ||
1111 | |||
1112 | v->cwd[0] = 0; | 1098 | v->cwd[0] = 0; |
1113 | ret = getcwd(v->cwd, VPE_PATH_MAX); | 1099 | ret = getcwd(v->cwd, VPE_PATH_MAX); |
1114 | if (ret < 0) | 1100 | if (ret < 0) |
@@ -1341,13 +1327,6 @@ char *vpe_getcwd(int index) | |||
1341 | 1327 | ||
1342 | EXPORT_SYMBOL(vpe_getcwd); | 1328 | EXPORT_SYMBOL(vpe_getcwd); |
1343 | 1329 | ||
1344 | #ifdef CONFIG_MIPS_APSP_KSPD | ||
1345 | static void kspd_sp_exit( int sp_id) | ||
1346 | { | ||
1347 | cleanup_tc(get_tc(sp_id)); | ||
1348 | } | ||
1349 | #endif | ||
1350 | |||
1351 | static ssize_t store_kill(struct device *dev, struct device_attribute *attr, | 1330 | static ssize_t store_kill(struct device *dev, struct device_attribute *attr, |
1352 | const char *buf, size_t len) | 1331 | const char *buf, size_t len) |
1353 | { | 1332 | { |
@@ -1585,9 +1564,6 @@ out_reenable: | |||
1585 | emt(mtflags); | 1564 | emt(mtflags); |
1586 | local_irq_restore(flags); | 1565 | local_irq_restore(flags); |
1587 | 1566 | ||
1588 | #ifdef CONFIG_MIPS_APSP_KSPD | ||
1589 | kspd_events.kspd_sp_exit = kspd_sp_exit; | ||
1590 | #endif | ||
1591 | return 0; | 1567 | return 0; |
1592 | 1568 | ||
1593 | out_class: | 1569 | out_class: |