ia64/linux-2.6.18-xen.hg

view arch/mips/kernel/kspd.c @ 452:c7ed6fe5dca0

kexec: dont initialise regions in reserve_memory()

There is no need to initialise efi_memmap_res and boot_param_res in
reserve_memory() for the initial xen domain as it is done in
machine_kexec_setup_resources() using values from the kexec hypercall.

Signed-off-by: Simon Horman <horms@verge.net.au>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Feb 28 10:55:18 2008 +0000 (2008-02-28)
parents 831230e53067
children
line source
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/unistd.h>
21 #include <linux/file.h>
22 #include <linux/fs.h>
23 #include <linux/syscalls.h>
24 #include <linux/workqueue.h>
25 #include <linux/errno.h>
26 #include <linux/list.h>
28 #include <asm/vpe.h>
29 #include <asm/rtlx.h>
30 #include <asm/kspd.h>
32 static struct workqueue_struct *workqueue = NULL;
33 static struct work_struct work;
35 extern unsigned long cpu_khz;
37 struct mtsp_syscall {
38 int cmd;
39 unsigned char abi;
40 unsigned char size;
41 };
43 struct mtsp_syscall_ret {
44 int retval;
45 int errno;
46 };
48 struct mtsp_syscall_generic {
49 int arg0;
50 int arg1;
51 int arg2;
52 int arg3;
53 int arg4;
54 int arg5;
55 int arg6;
56 };
58 static struct list_head kspd_notifylist;
59 static int sp_stopping = 0;
61 /* these should match with those in the SDE kit */
62 #define MTSP_SYSCALL_BASE 0
63 #define MTSP_SYSCALL_EXIT (MTSP_SYSCALL_BASE + 0)
64 #define MTSP_SYSCALL_OPEN (MTSP_SYSCALL_BASE + 1)
65 #define MTSP_SYSCALL_READ (MTSP_SYSCALL_BASE + 2)
66 #define MTSP_SYSCALL_WRITE (MTSP_SYSCALL_BASE + 3)
67 #define MTSP_SYSCALL_CLOSE (MTSP_SYSCALL_BASE + 4)
68 #define MTSP_SYSCALL_LSEEK32 (MTSP_SYSCALL_BASE + 5)
69 #define MTSP_SYSCALL_ISATTY (MTSP_SYSCALL_BASE + 6)
70 #define MTSP_SYSCALL_GETTIME (MTSP_SYSCALL_BASE + 7)
71 #define MTSP_SYSCALL_PIPEFREQ (MTSP_SYSCALL_BASE + 8)
72 #define MTSP_SYSCALL_GETTOD (MTSP_SYSCALL_BASE + 9)
74 #define MTSP_O_RDONLY 0x0000
75 #define MTSP_O_WRONLY 0x0001
76 #define MTSP_O_RDWR 0x0002
77 #define MTSP_O_NONBLOCK 0x0004
78 #define MTSP_O_APPEND 0x0008
79 #define MTSP_O_SHLOCK 0x0010
80 #define MTSP_O_EXLOCK 0x0020
81 #define MTSP_O_ASYNC 0x0040
82 #define MTSP_O_FSYNC O_SYNC
83 #define MTSP_O_NOFOLLOW 0x0100
84 #define MTSP_O_SYNC 0x0080
85 #define MTSP_O_CREAT 0x0200
86 #define MTSP_O_TRUNC 0x0400
87 #define MTSP_O_EXCL 0x0800
88 #define MTSP_O_BINARY 0x8000
90 #define SP_VPE 1
92 struct apsp_table {
93 int sp;
94 int ap;
95 };
97 /* we might want to do the mode flags too */
98 struct apsp_table open_flags_table[] = {
99 { MTSP_O_RDWR, O_RDWR },
100 { MTSP_O_WRONLY, O_WRONLY },
101 { MTSP_O_CREAT, O_CREAT },
102 { MTSP_O_TRUNC, O_TRUNC },
103 { MTSP_O_NONBLOCK, O_NONBLOCK },
104 { MTSP_O_APPEND, O_APPEND },
105 { MTSP_O_NOFOLLOW, O_NOFOLLOW }
106 };
108 struct apsp_table syscall_command_table[] = {
109 { MTSP_SYSCALL_OPEN, __NR_open },
110 { MTSP_SYSCALL_CLOSE, __NR_close },
111 { MTSP_SYSCALL_READ, __NR_read },
112 { MTSP_SYSCALL_WRITE, __NR_write },
113 { MTSP_SYSCALL_LSEEK32, __NR_lseek }
114 };
116 static int sp_syscall(int num, int arg0, int arg1, int arg2, int arg3)
117 {
118 register long int _num __asm__ ("$2") = num;
119 register long int _arg0 __asm__ ("$4") = arg0;
120 register long int _arg1 __asm__ ("$5") = arg1;
121 register long int _arg2 __asm__ ("$6") = arg2;
122 register long int _arg3 __asm__ ("$7") = arg3;
124 mm_segment_t old_fs;
126 old_fs = get_fs();
127 set_fs(KERNEL_DS);
129 __asm__ __volatile__ (
130 " syscall \n"
131 : "=r" (_num), "=r" (_arg3)
132 : "r" (_num), "r" (_arg0), "r" (_arg1), "r" (_arg2), "r" (_arg3));
134 set_fs(old_fs);
136 /* $a3 is error flag */
137 if (_arg3)
138 return -_num;
140 return _num;
141 }
143 static int translate_syscall_command(int cmd)
144 {
145 int i;
146 int ret = -1;
148 for (i = 0; i < ARRAY_SIZE(syscall_command_table); i++) {
149 if ((cmd == syscall_command_table[i].sp))
150 return syscall_command_table[i].ap;
151 }
153 return ret;
154 }
156 static unsigned int translate_open_flags(int flags)
157 {
158 int i;
159 unsigned int ret = 0;
161 for (i = 0; i < (sizeof(open_flags_table) / sizeof(struct apsp_table));
162 i++) {
163 if( (flags & open_flags_table[i].sp) ) {
164 ret |= open_flags_table[i].ap;
165 }
166 }
168 return ret;
169 }
172 static void sp_setfsuidgid( uid_t uid, gid_t gid)
173 {
174 current->fsuid = uid;
175 current->fsgid = gid;
177 key_fsuid_changed(current);
178 key_fsgid_changed(current);
179 }
181 /*
182 * Expects a request to be on the sysio channel. Reads it. Decides whether
183 * its a linux syscall and runs it, or whatever. Puts the return code back
184 * into the request and sends the whole thing back.
185 */
186 void sp_work_handle_request(void)
187 {
188 struct mtsp_syscall sc;
189 struct mtsp_syscall_generic generic;
190 struct mtsp_syscall_ret ret;
191 struct kspd_notifications *n;
192 struct timeval tv;
193 struct timezone tz;
194 int cmd;
196 char *vcwd;
197 mm_segment_t old_fs;
198 int size;
200 ret.retval = -1;
202 if (!rtlx_read(RTLX_CHANNEL_SYSIO, &sc, sizeof(struct mtsp_syscall), 0)) {
203 printk(KERN_ERR "Expected request but nothing to read\n");
204 return;
205 }
207 size = sc.size;
209 if (size) {
210 if (!rtlx_read(RTLX_CHANNEL_SYSIO, &generic, size, 0)) {
211 printk(KERN_ERR "Expected request but nothing to read\n");
212 return;
213 }
214 }
216 /* Run the syscall at the priviledge of the user who loaded the
217 SP program */
219 if (vpe_getuid(SP_VPE))
220 sp_setfsuidgid( vpe_getuid(SP_VPE), vpe_getgid(SP_VPE));
222 switch (sc.cmd) {
223 /* needs the flags argument translating from SDE kit to
224 linux */
225 case MTSP_SYSCALL_PIPEFREQ:
226 ret.retval = cpu_khz * 1000;
227 ret.errno = 0;
228 break;
230 case MTSP_SYSCALL_GETTOD:
231 memset(&tz, 0, sizeof(tz));
232 if ((ret.retval = sp_syscall(__NR_gettimeofday, (int)&tv,
233 (int)&tz, 0,0)) == 0)
234 ret.retval = tv.tv_sec;
236 ret.errno = errno;
237 break;
239 case MTSP_SYSCALL_EXIT:
240 list_for_each_entry(n, &kspd_notifylist, list)
241 n->kspd_sp_exit(SP_VPE);
242 sp_stopping = 1;
244 printk(KERN_DEBUG "KSPD got exit syscall from SP exitcode %d\n",
245 generic.arg0);
246 break;
248 case MTSP_SYSCALL_OPEN:
249 generic.arg1 = translate_open_flags(generic.arg1);
251 vcwd = vpe_getcwd(SP_VPE);
253 /* change to the cwd of the process that loaded the SP program */
254 old_fs = get_fs();
255 set_fs(KERNEL_DS);
256 sys_chdir(vcwd);
257 set_fs(old_fs);
259 sc.cmd = __NR_open;
261 /* fall through */
263 default:
264 if ((sc.cmd >= __NR_Linux) &&
265 (sc.cmd <= (__NR_Linux + __NR_Linux_syscalls)) )
266 cmd = sc.cmd;
267 else
268 cmd = translate_syscall_command(sc.cmd);
270 if (cmd >= 0) {
271 ret.retval = sp_syscall(cmd, generic.arg0, generic.arg1,
272 generic.arg2, generic.arg3);
273 ret.errno = errno;
274 } else
275 printk(KERN_WARNING
276 "KSPD: Unknown SP syscall number %d\n", sc.cmd);
277 break;
278 } /* switch */
280 if (vpe_getuid(SP_VPE))
281 sp_setfsuidgid( 0, 0);
283 if ((rtlx_write(RTLX_CHANNEL_SYSIO, &ret, sizeof(struct mtsp_syscall_ret), 0))
284 < sizeof(struct mtsp_syscall_ret))
285 printk("KSPD: sp_work_handle_request failed to send to SP\n");
286 }
288 static void sp_cleanup(void)
289 {
290 struct files_struct *files = current->files;
291 int i, j;
292 struct fdtable *fdt;
294 j = 0;
296 /*
297 * It is safe to dereference the fd table without RCU or
298 * ->file_lock
299 */
300 fdt = files_fdtable(files);
301 for (;;) {
302 unsigned long set;
303 i = j * __NFDBITS;
304 if (i >= fdt->max_fdset || i >= fdt->max_fds)
305 break;
306 set = fdt->open_fds->fds_bits[j++];
307 while (set) {
308 if (set & 1) {
309 struct file * file = xchg(&fdt->fd[i], NULL);
310 if (file)
311 filp_close(file, files);
312 }
313 i++;
314 set >>= 1;
315 }
316 }
317 }
319 static int channel_open = 0;
321 /* the work handler */
322 static void sp_work(void *data)
323 {
324 if (!channel_open) {
325 if( rtlx_open(RTLX_CHANNEL_SYSIO, 1) != 0) {
326 printk("KSPD: unable to open sp channel\n");
327 sp_stopping = 1;
328 } else {
329 channel_open++;
330 printk(KERN_DEBUG "KSPD: SP channel opened\n");
331 }
332 } else {
333 /* wait for some data, allow it to sleep */
334 rtlx_read_poll(RTLX_CHANNEL_SYSIO, 1);
336 /* Check we haven't been woken because we are stopping */
337 if (!sp_stopping)
338 sp_work_handle_request();
339 }
341 if (!sp_stopping)
342 queue_work(workqueue, &work);
343 else
344 sp_cleanup();
345 }
347 static void startwork(int vpe)
348 {
349 sp_stopping = channel_open = 0;
351 if (workqueue == NULL) {
352 if ((workqueue = create_singlethread_workqueue("kspd")) == NULL) {
353 printk(KERN_ERR "unable to start kspd\n");
354 return;
355 }
357 INIT_WORK(&work, sp_work, NULL);
358 queue_work(workqueue, &work);
359 } else
360 queue_work(workqueue, &work);
362 }
364 static void stopwork(int vpe)
365 {
366 sp_stopping = 1;
368 printk(KERN_DEBUG "KSPD: SP stopping\n");
369 }
371 void kspd_notify(struct kspd_notifications *notify)
372 {
373 list_add(&notify->list, &kspd_notifylist);
374 }
376 static struct vpe_notifications notify;
377 static int kspd_module_init(void)
378 {
379 INIT_LIST_HEAD(&kspd_notifylist);
381 notify.start = startwork;
382 notify.stop = stopwork;
383 vpe_notify(SP_VPE, &notify);
385 return 0;
386 }
388 static void kspd_module_exit(void)
389 {
391 }
393 module_init(kspd_module_init);
394 module_exit(kspd_module_exit);
396 MODULE_DESCRIPTION("MIPS KSPD");
397 MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc.");
398 MODULE_LICENSE("GPL");