Subversion Repositories HelenOS

Rev

Rev 3875 | Rev 3974 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 3875 Rev 3908
1 
/*
 1 
/*
2 
 * Copyright (c) 2005 Jakub Jermar
 2 
 * Copyright (c) 2005 Jakub Jermar
3 
 * All rights reserved.
 3 
 * All rights reserved.
4 
 *
 4 
 *
5 
 * Redistribution and use in source and binary forms, with or without
 5 
 * Redistribution and use in source and binary forms, with or without
6 
 * modification, are permitted provided that the following conditions
 6 
 * modification, are permitted provided that the following conditions
7 
 * are met:
 7 
 * are met:
8 
 *
 8 
 *
9 
 * - Redistributions of source code must retain the above copyright
 9 
 * - Redistributions of source code must retain the above copyright
10 
 *   notice, this list of conditions and the following disclaimer.
 10 
 *   notice, this list of conditions and the following disclaimer.
11 
 * - Redistributions in binary form must reproduce the above copyright
 11 
 * - Redistributions in binary form must reproduce the above copyright
12 
 *   notice, this list of conditions and the following disclaimer in the
 12 
 *   notice, this list of conditions and the following disclaimer in the
13 
 *   documentation and/or other materials provided with the distribution.
 13 
 *   documentation and/or other materials provided with the distribution.
14 
 * - The name of the author may not be used to endorse or promote products
 14 
 * - The name of the author may not be used to endorse or promote products
15 
 *   derived from this software without specific prior written permission.
 15 
 *   derived from this software without specific prior written permission.
16 
 *
 16 
 *
17 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 17 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 18 
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 19 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 20 
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 21 
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 22 
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 23 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 24 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 25 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 26 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
 */
 27 
 */
28 
 
 28 
 
29 
/** @addtogroup genericconsole
 29 
/** @addtogroup genericconsole
30 
 * @{
 30 
 * @{
31 
 */
 31 
 */
32 
 
 32 
 
33 
/**
 33 
/**
34 
 * @file    cmd.c
 34 
 * @file    cmd.c
35 
 * @brief   Kernel console command wrappers.
 35 
 * @brief   Kernel console command wrappers.
36 
 *
 36 
 *
37 
 * This file is meant to contain all wrapper functions for
 37 
 * This file is meant to contain all wrapper functions for
38 
 * all kconsole commands. The point is in separating
 38 
 * all kconsole commands. The point is in separating
39 
 * kconsole specific wrappers from kconsole-unaware functions
 39 
 * kconsole specific wrappers from kconsole-unaware functions
40 
 * from other subsystems.
 40 
 * from other subsystems.
41 
 */
 41 
 */
42 
 
 42 
 
43 
#include <console/cmd.h>
 43 
#include <console/cmd.h>
44 
#include <console/console.h>
 44 
#include <console/console.h>
45 
#include <console/kconsole.h>
 45 
#include <console/kconsole.h>
46 
#include <print.h>
 46 
#include <print.h>
47 
#include <panic.h>
 47 
#include <panic.h>
48 
#include <arch/types.h>
 48 
#include <arch/types.h>
49 
#include <adt/list.h>
 49 
#include <adt/list.h>
50 
#include <arch.h>
 50 
#include <arch.h>
51 
#include <config.h>
 51 
#include <config.h>
52 
#include <func.h>
 52 
#include <func.h>
53 
#include <macros.h>
 53 
#include <macros.h>
54 
#include <debug.h>
 54 
#include <debug.h>
55 
#include <symtab.h>
 55 
#include <symtab.h>
56 
#include <cpu.h>
 56 
#include <cpu.h>
57 
#include <mm/tlb.h>
 57 
#include <mm/tlb.h>
58 
#include <arch/mm/tlb.h>
 58 
#include <arch/mm/tlb.h>
59 
#include <mm/frame.h>
 59 
#include <mm/frame.h>
60 
#include <main/version.h>
 60 
#include <main/version.h>
61 
#include <mm/slab.h>
 61 
#include <mm/slab.h>
62 
#include <proc/scheduler.h>
 62 
#include <proc/scheduler.h>
63 
#include <proc/thread.h>
 63 
#include <proc/thread.h>
64 
#include <proc/task.h>
 64 
#include <proc/task.h>
65 
#include <ipc/ipc.h>
 65 
#include <ipc/ipc.h>
66 
#include <ipc/irq.h>
 66 
#include <ipc/irq.h>
67 
 
 67 
 
68 
#ifdef CONFIG_TEST
 68 
#ifdef CONFIG_TEST
69 
#include <test.h>
 69 
#include <test.h>
70 
#endif
 70 
#endif
71 
 
 71 
 
72 
/* Data and methods for 'help' command. */
 72 
/* Data and methods for 'help' command. */
73 
static int cmd_help(cmd_arg_t *argv);
 73 
static int cmd_help(cmd_arg_t *argv);
74 
static cmd_info_t help_info = {
 74 
static cmd_info_t help_info = {
75 
    .name = "help",
 75 
    .name = "help",
76 
    .description = "List of supported commands.",
 76 
    .description = "List of supported commands.",
77 
    .func = cmd_help,
 77 
    .func = cmd_help,
78 
    .argc = 0
 78 
    .argc = 0
79 
};
 79 
};
80 
 
 80 
 
81 
static cmd_info_t exit_info = {
 81 
static cmd_info_t exit_info = {
82 
    .name = "exit",
 82 
    .name = "exit",
83 
    .description = "Exit kconsole.",
 83 
    .description = "Exit kconsole.",
84 
    .argc = 0
 84 
    .argc = 0
85 
};
 85 
};
86 
 
 86 
 
87 
static int cmd_reboot(cmd_arg_t *argv);
 87 
static int cmd_reboot(cmd_arg_t *argv);
88 
static cmd_info_t reboot_info = {
 88 
static cmd_info_t reboot_info = {
89 
    .name = "reboot",
 89 
    .name = "reboot",
90 
    .description = "Reboot.",
 90 
    .description = "Reboot.",
91 
    .func = cmd_reboot,
 91 
    .func = cmd_reboot,
92 
    .argc = 0
 92 
    .argc = 0
93 
};
 93 
};
94 
 
 94 
 
95 
static int cmd_uptime(cmd_arg_t *argv);
 95 
static int cmd_uptime(cmd_arg_t *argv);
96 
static cmd_info_t uptime_info = {
 96 
static cmd_info_t uptime_info = {
97 
    .name = "uptime",
 97 
    .name = "uptime",
98 
    .description = "Print uptime information.",
 98 
    .description = "Print uptime information.",
99 
    .func = cmd_uptime,
 99 
    .func = cmd_uptime,
100 
    .argc = 0
 100 
    .argc = 0
101 
};
 101 
};
102 
 
 102 
 
103 
static int cmd_continue(cmd_arg_t *argv);
 103 
static int cmd_continue(cmd_arg_t *argv);
104 
static cmd_info_t continue_info = {
 104 
static cmd_info_t continue_info = {
105 
    .name = "continue",
 105 
    .name = "continue",
106 
    .description = "Return console back to userspace.",
 106 
    .description = "Return console back to userspace.",
107 
    .func = cmd_continue,
 107 
    .func = cmd_continue,
108 
    .argc = 0
 108 
    .argc = 0
109 
};
 109 
};
110 
 
 110 
 
111 
#ifdef CONFIG_TEST
 111 
#ifdef CONFIG_TEST
112 
static int cmd_tests(cmd_arg_t *argv);
 112 
static int cmd_tests(cmd_arg_t *argv);
113 
static cmd_info_t tests_info = {
 113 
static cmd_info_t tests_info = {
114 
    .name = "tests",
 114 
    .name = "tests",
115 
    .description = "Print available kernel tests.",
 115 
    .description = "Print available kernel tests.",
116 
    .func = cmd_tests,
 116 
    .func = cmd_tests,
117 
    .argc = 0
 117 
    .argc = 0
118 
};
 118 
};
119 
 
 119 
 
120 
static char test_buf[MAX_CMDLINE + 1];
 120 
static char test_buf[MAX_CMDLINE + 1];
121 
static int cmd_test(cmd_arg_t *argv);
 121 
static int cmd_test(cmd_arg_t *argv);
122 
static cmd_arg_t test_argv[] = {
 122 
static cmd_arg_t test_argv[] = {
123 
    {
 123 
    {
124 
        .type = ARG_TYPE_STRING,
 124 
        .type = ARG_TYPE_STRING,
125 
        .buffer = test_buf,
 125 
        .buffer = test_buf,
126 
        .len = sizeof(test_buf)
 126 
        .len = sizeof(test_buf)
127 
    }
 127 
    }
128 
};
 128 
};
129 
static cmd_info_t test_info = {
 129 
static cmd_info_t test_info = {
130 
    .name = "test",
 130 
    .name = "test",
131 
    .description = "Run kernel test.",
 131 
    .description = "Run kernel test.",
132 
    .func = cmd_test,
 132 
    .func = cmd_test,
133 
    .argc = 1,
 133 
    .argc = 1,
134 
    .argv = test_argv
 134 
    .argv = test_argv
135 
};
 135 
};
136 
 
 136 
 
137 
static int cmd_bench(cmd_arg_t *argv);
 137 
static int cmd_bench(cmd_arg_t *argv);
138 
static cmd_arg_t bench_argv[] = {
 138 
static cmd_arg_t bench_argv[] = {
139 
    {
 139 
    {
140 
        .type = ARG_TYPE_STRING,
 140 
        .type = ARG_TYPE_STRING,
141 
        .buffer = test_buf,
 141 
        .buffer = test_buf,
142 
        .len = sizeof(test_buf)
 142 
        .len = sizeof(test_buf)
143 
    },
 143 
    },
144 
    {
 144 
    {
145 
        .type = ARG_TYPE_INT,
 145 
        .type = ARG_TYPE_INT,
146 
    }
 146 
    }
147 
};
 147 
};
148 
static cmd_info_t bench_info = {
 148 
static cmd_info_t bench_info = {
149 
    .name = "bench",
 149 
    .name = "bench",
150 
    .description = "Run kernel test as benchmark.",
 150 
    .description = "Run kernel test as benchmark.",
151 
    .func = cmd_bench,
 151 
    .func = cmd_bench,
152 
    .argc = 2,
 152 
    .argc = 2,
153 
    .argv = bench_argv
 153 
    .argv = bench_argv
154 
};
 154 
};
155 
#endif
 155 
#endif
156 
 
 156 
 
157 
/* Data and methods for 'description' command. */
 157 
/* Data and methods for 'description' command. */
158 
static int cmd_desc(cmd_arg_t *argv);
 158 
static int cmd_desc(cmd_arg_t *argv);
159 
static void desc_help(void);
 159 
static void desc_help(void);
160 
static char desc_buf[MAX_CMDLINE+1];
 160 
static char desc_buf[MAX_CMDLINE+1];
161 
static cmd_arg_t desc_argv = {
 161 
static cmd_arg_t desc_argv = {
162 
    .type = ARG_TYPE_STRING,
 162 
    .type = ARG_TYPE_STRING,
163 
    .buffer = desc_buf,
 163 
    .buffer = desc_buf,
164 
    .len = sizeof(desc_buf)
 164 
    .len = sizeof(desc_buf)
165 
};
 165 
};
166 
static cmd_info_t desc_info = {
 166 
static cmd_info_t desc_info = {
167 
    .name = "describe",
 167 
    .name = "describe",
168 
    .description = "Describe specified command.",
 168 
    .description = "Describe specified command.",
169 
    .help = desc_help,
 169 
    .help = desc_help,
170 
    .func = cmd_desc,
 170 
    .func = cmd_desc,
171 
    .argc = 1,
 171 
    .argc = 1,
172 
    .argv = &desc_argv
 172 
    .argv = &desc_argv
173 
};
 173 
};
174 
 
 174 
 
175 
/* Data and methods for 'symaddr' command. */
 175 
/* Data and methods for 'symaddr' command. */
176 
static int cmd_symaddr(cmd_arg_t *argv);
 176 
static int cmd_symaddr(cmd_arg_t *argv);
177 
static char symaddr_buf[MAX_CMDLINE+1];
 177 
static char symaddr_buf[MAX_CMDLINE+1];
178 
static cmd_arg_t symaddr_argv = {
 178 
static cmd_arg_t symaddr_argv = {
179 
    .type = ARG_TYPE_STRING,
 179 
    .type = ARG_TYPE_STRING,
180 
    .buffer = symaddr_buf,
 180 
    .buffer = symaddr_buf,
181 
    .len = sizeof(symaddr_buf)
 181 
    .len = sizeof(symaddr_buf)
182 
};
 182 
};
183 
static cmd_info_t symaddr_info = {
 183 
static cmd_info_t symaddr_info = {
184 
    .name = "symaddr",
 184 
    .name = "symaddr",
185 
    .description = "Return symbol address.",
 185 
    .description = "Return symbol address.",
186 
    .func = cmd_symaddr,
 186 
    .func = cmd_symaddr,
187 
    .argc = 1,
 187 
    .argc = 1,
188 
    .argv = &symaddr_argv
 188 
    .argv = &symaddr_argv
189 
};
 189 
};
190 
 
 190 
 
191 
static char set_buf[MAX_CMDLINE+1];
 191 
static char set_buf[MAX_CMDLINE+1];
192 
static int cmd_set4(cmd_arg_t *argv);
 192 
static int cmd_set4(cmd_arg_t *argv);
193 
static cmd_arg_t set4_argv[] = {
 193 
static cmd_arg_t set4_argv[] = {
194 
    {
 194 
    {
195 
        .type = ARG_TYPE_STRING,
 195 
        .type = ARG_TYPE_STRING,
196 
        .buffer = set_buf,
 196 
        .buffer = set_buf,
197 
        .len = sizeof(set_buf)
 197 
        .len = sizeof(set_buf)
198 
    },
 198 
    },
199 
    {
 199 
    {
200 
        .type = ARG_TYPE_INT
 200 
        .type = ARG_TYPE_INT
201 
    }
 201 
    }
202 
};
 202 
};
203 
static cmd_info_t set4_info = {
 203 
static cmd_info_t set4_info = {
204 
    .name = "set4",
 204 
    .name = "set4",
205 
    .description = "set <dest_addr> <value> - 4byte version",
 205 
    .description = "set <dest_addr> <value> - 4byte version",
206 
    .func = cmd_set4,
 206 
    .func = cmd_set4,
207 
    .argc = 2,
 207 
    .argc = 2,
208 
    .argv = set4_argv
 208 
    .argv = set4_argv
209 
};
 209 
};
210 
 
 210 
 
211 
/* Data and methods for 'call0' command. */
 211 
/* Data and methods for 'call0' command. */
212 
static char call0_buf[MAX_CMDLINE + 1];
 212 
static char call0_buf[MAX_CMDLINE + 1];
213 
static char carg1_buf[MAX_CMDLINE + 1];
 213 
static char carg1_buf[MAX_CMDLINE + 1];
214 
static char carg2_buf[MAX_CMDLINE + 1];
 214 
static char carg2_buf[MAX_CMDLINE + 1];
215 
static char carg3_buf[MAX_CMDLINE + 1];
 215 
static char carg3_buf[MAX_CMDLINE + 1];
216 
 
 216 
 
217 
static int cmd_call0(cmd_arg_t *argv);
 217 
static int cmd_call0(cmd_arg_t *argv);
218 
static cmd_arg_t call0_argv = {
 218 
static cmd_arg_t call0_argv = {
219 
    .type = ARG_TYPE_STRING,
 219 
    .type = ARG_TYPE_STRING,
220 
    .buffer = call0_buf,
 220 
    .buffer = call0_buf,
221 
    .len = sizeof(call0_buf)
 221 
    .len = sizeof(call0_buf)
222 
};
 222 
};
223 
static cmd_info_t call0_info = {
 223 
static cmd_info_t call0_info = {
224 
    .name = "call0",
 224 
    .name = "call0",
225 
    .description = "call0 <function> -> call function().",
 225 
    .description = "call0 <function> -> call function().",
226 
    .func = cmd_call0,
 226 
    .func = cmd_call0,
227 
    .argc = 1,
 227 
    .argc = 1,
228 
    .argv = &call0_argv
 228 
    .argv = &call0_argv
229 
};
 229 
};
230 
 
 230 
 
231 
/* Data and methods for 'mcall0' command. */
 231 
/* Data and methods for 'mcall0' command. */
232 
static int cmd_mcall0(cmd_arg_t *argv);
 232 
static int cmd_mcall0(cmd_arg_t *argv);
233 
static cmd_arg_t mcall0_argv = {
 233 
static cmd_arg_t mcall0_argv = {
234 
    .type = ARG_TYPE_STRING,
 234 
    .type = ARG_TYPE_STRING,
235 
    .buffer = call0_buf,
 235 
    .buffer = call0_buf,
236 
    .len = sizeof(call0_buf)
 236 
    .len = sizeof(call0_buf)
237 
};
 237 
};
238 
static cmd_info_t mcall0_info = {
 238 
static cmd_info_t mcall0_info = {
239 
    .name = "mcall0",
 239 
    .name = "mcall0",
240 
    .description = "mcall0 <function> -> call function() on each CPU.",
 240 
    .description = "mcall0 <function> -> call function() on each CPU.",
241 
    .func = cmd_mcall0,
 241 
    .func = cmd_mcall0,
242 
    .argc = 1,
 242 
    .argc = 1,
243 
    .argv = &mcall0_argv
 243 
    .argv = &mcall0_argv
244 
};
 244 
};
245 
 
 245 
 
246 
/* Data and methods for 'call1' command. */
 246 
/* Data and methods for 'call1' command. */
247 
static int cmd_call1(cmd_arg_t *argv);
 247 
static int cmd_call1(cmd_arg_t *argv);
248 
static cmd_arg_t call1_argv[] = {
 248 
static cmd_arg_t call1_argv[] = {
249 
    {
 249 
    {
250 
        .type = ARG_TYPE_STRING,
 250 
        .type = ARG_TYPE_STRING,
251 
        .buffer = call0_buf,
 251 
        .buffer = call0_buf,
252 
        .len = sizeof(call0_buf)
 252 
        .len = sizeof(call0_buf)
253 
    },
 253 
    },
254 
    {
 254 
    {
255 
        .type = ARG_TYPE_VAR,
 255 
        .type = ARG_TYPE_VAR,
256 
        .buffer = carg1_buf,
 256 
        .buffer = carg1_buf,
257 
        .len = sizeof(carg1_buf)
 257 
        .len = sizeof(carg1_buf)
258 
    }
 258 
    }
259 
};
 259 
};
260 
static cmd_info_t call1_info = {
 260 
static cmd_info_t call1_info = {
261 
    .name = "call1",
 261 
    .name = "call1",
262 
    .description = "call1 <function> <arg1> -> call function(arg1).",
 262 
    .description = "call1 <function> <arg1> -> call function(arg1).",
263 
    .func = cmd_call1,
 263 
    .func = cmd_call1,
264 
    .argc = 2,
 264 
    .argc = 2,
265 
    .argv = call1_argv
 265 
    .argv = call1_argv
266 
};
 266 
};
267 
 
 267 
 
268 
/* Data and methods for 'call2' command. */
 268 
/* Data and methods for 'call2' command. */
269 
static int cmd_call2(cmd_arg_t *argv);
 269 
static int cmd_call2(cmd_arg_t *argv);
270 
static cmd_arg_t call2_argv[] = {
 270 
static cmd_arg_t call2_argv[] = {
271 
    {
 271 
    {
272 
        .type = ARG_TYPE_STRING,
 272 
        .type = ARG_TYPE_STRING,
273 
        .buffer = call0_buf,
 273 
        .buffer = call0_buf,
274 
        .len = sizeof(call0_buf)
 274 
        .len = sizeof(call0_buf)
275 
    },
 275 
    },
276 
    {
 276 
    {
277 
        .type = ARG_TYPE_VAR,
 277 
        .type = ARG_TYPE_VAR,
278 
        .buffer = carg1_buf,
 278 
        .buffer = carg1_buf,
279 
        .len = sizeof(carg1_buf)
 279 
        .len = sizeof(carg1_buf)
280 
    },
 280 
    },
281 
    {
 281 
    {
282 
        .type = ARG_TYPE_VAR,
 282 
        .type = ARG_TYPE_VAR,
283 
        .buffer = carg2_buf,
 283 
        .buffer = carg2_buf,
284 
        .len = sizeof(carg2_buf)
 284 
        .len = sizeof(carg2_buf)
285 
    }
 285 
    }
286 
};
 286 
};
287 
static cmd_info_t call2_info = {
 287 
static cmd_info_t call2_info = {
288 
    .name = "call2",
 288 
    .name = "call2",
289 
    .description = "call2 <function> <arg1> <arg2> -> call function(arg1,arg2).",
 289 
    .description = "call2 <function> <arg1> <arg2> -> call function(arg1,arg2).",
290 
    .func = cmd_call2,
 290 
    .func = cmd_call2,
291 
    .argc = 3,
 291 
    .argc = 3,
292 
    .argv = call2_argv
 292 
    .argv = call2_argv
293 
};
 293 
};
294 
 
 294 
 
295 
/* Data and methods for 'call3' command. */
 295 
/* Data and methods for 'call3' command. */
296 
static int cmd_call3(cmd_arg_t *argv);
 296 
static int cmd_call3(cmd_arg_t *argv);
297 
static cmd_arg_t call3_argv[] = {
 297 
static cmd_arg_t call3_argv[] = {
298 
    {
 298 
    {
299 
        .type = ARG_TYPE_STRING,
 299 
        .type = ARG_TYPE_STRING,
300 
        .buffer = call0_buf,
 300 
        .buffer = call0_buf,
301 
        .len = sizeof(call0_buf)
 301 
        .len = sizeof(call0_buf)
302 
    },
 302 
    },
303 
    {
 303 
    {
304 
        .type = ARG_TYPE_VAR,
 304 
        .type = ARG_TYPE_VAR,
305 
        .buffer = carg1_buf,
 305 
        .buffer = carg1_buf,
306 
        .len = sizeof(carg1_buf)
 306 
        .len = sizeof(carg1_buf)
307 
    },
 307 
    },
308 
    {
 308 
    {
309 
        .type = ARG_TYPE_VAR,
 309 
        .type = ARG_TYPE_VAR,
310 
        .buffer = carg2_buf,
 310 
        .buffer = carg2_buf,
311 
        .len = sizeof(carg2_buf)
 311 
        .len = sizeof(carg2_buf)
312 
    },
 312 
    },
313 
    {
 313 
    {
314 
        .type = ARG_TYPE_VAR,
 314 
        .type = ARG_TYPE_VAR,
315 
        .buffer = carg3_buf,
 315 
        .buffer = carg3_buf,
316 
        .len = sizeof(carg3_buf)
 316 
        .len = sizeof(carg3_buf)
317 
    }
 317 
    }
318 
 
 318 
 
319 
};
 319 
};
320 
static cmd_info_t call3_info = {
 320 
static cmd_info_t call3_info = {
321 
    .name = "call3",
 321 
    .name = "call3",
322 
    .description = "call3 <function> <arg1> <arg2> <arg3> -> call function(arg1,arg2,arg3).",
 322 
    .description = "call3 <function> <arg1> <arg2> <arg3> -> call function(arg1,arg2,arg3).",
323 
    .func = cmd_call3,
 323 
    .func = cmd_call3,
324 
    .argc = 4,
 324 
    .argc = 4,
325 
    .argv = call3_argv
 325 
    .argv = call3_argv
326 
};
 326 
};
327 
 
 327 
 
328 
/* Data and methods for 'halt' command. */
 328 
/* Data and methods for 'halt' command. */
329 
static int cmd_halt(cmd_arg_t *argv);
 329 
static int cmd_halt(cmd_arg_t *argv);
330 
static cmd_info_t halt_info = {
 330 
static cmd_info_t halt_info = {
331 
    .name = "halt",
 331 
    .name = "halt",
332 
    .description = "Halt the kernel.",
 332 
    .description = "Halt the kernel.",
333 
    .func = cmd_halt,
 333 
    .func = cmd_halt,
334 
    .argc = 0
 334 
    .argc = 0
335 
};
 335 
};
336 
 
 336 
 
337 
/* Data and methods for 'physmem' command. */
 337 
/* Data and methods for 'physmem' command. */
338 
static int cmd_physmem(cmd_arg_t *argv);
 338 
static int cmd_physmem(cmd_arg_t *argv);
339 
cmd_info_t physmem_info = {
 339 
cmd_info_t physmem_info = {
340 
    .name = "physmem",
 340 
    .name = "physmem",
341 
    .description = "Print physical memory configuration.",
 341 
    .description = "Print physical memory configuration.",
342 
    .help = NULL,
 342 
    .help = NULL,
343 
    .func = cmd_physmem,
 343 
    .func = cmd_physmem,
344 
    .argc = 0,
 344 
    .argc = 0,
345 
    .argv = NULL
 345 
    .argv = NULL
346 
};
 346 
};
347 
 
 347 
 
348 
/* Data and methods for 'tlb' command. */
 348 
/* Data and methods for 'tlb' command. */
349 
static int cmd_tlb(cmd_arg_t *argv);
 349 
static int cmd_tlb(cmd_arg_t *argv);
350 
cmd_info_t tlb_info = {
 350 
cmd_info_t tlb_info = {
351 
    .name = "tlb",
 351 
    .name = "tlb",
352 
    .description = "Print TLB of current processor.",
 352 
    .description = "Print TLB of current processor.",
353 
    .help = NULL,
 353 
    .help = NULL,
354 
    .func = cmd_tlb,
 354 
    .func = cmd_tlb,
355 
    .argc = 0,
 355 
    .argc = 0,
356 
    .argv = NULL
 356 
    .argv = NULL
357 
};
 357 
};
358 
 
 358 
 
359 
static int cmd_threads(cmd_arg_t *argv);
 359 
static int cmd_threads(cmd_arg_t *argv);
360 
static cmd_info_t threads_info = {
 360 
static cmd_info_t threads_info = {
361 
    .name = "threads",
 361 
    .name = "threads",
362 
    .description = "List all threads.",
 362 
    .description = "List all threads.",
363 
    .func = cmd_threads,
 363 
    .func = cmd_threads,
364 
    .argc = 0
 364 
    .argc = 0
365 
};
 365 
};
366 
 
 366 
 
367 
static int cmd_tasks(cmd_arg_t *argv);
 367 
static int cmd_tasks(cmd_arg_t *argv);
368 
static cmd_info_t tasks_info = {
 368 
static cmd_info_t tasks_info = {
369 
    .name = "tasks",
 369 
    .name = "tasks",
370 
    .description = "List all tasks.",
 370 
    .description = "List all tasks.",
371 
    .func = cmd_tasks,
 371 
    .func = cmd_tasks,
372 
    .argc = 0
 372 
    .argc = 0
373 
};
 373 
};
374 
 
 374 
 
375 
 
 375 
 
376 
static int cmd_sched(cmd_arg_t *argv);
 376 
static int cmd_sched(cmd_arg_t *argv);
377 
static cmd_info_t sched_info = {
 377 
static cmd_info_t sched_info = {
378 
    .name = "scheduler",
 378 
    .name = "scheduler",
379 
    .description = "List all scheduler information.",
 379 
    .description = "List all scheduler information.",
380 
    .func = cmd_sched,
 380 
    .func = cmd_sched,
381 
    .argc = 0
 381 
    .argc = 0
382 
};
 382 
};
383 
 
 383 
 
384 
static int cmd_slabs(cmd_arg_t *argv);
 384 
static int cmd_slabs(cmd_arg_t *argv);
385 
static cmd_info_t slabs_info = {
 385 
static cmd_info_t slabs_info = {
386 
    .name = "slabs",
 386 
    .name = "slabs",
387 
    .description = "List slab caches.",
 387 
    .description = "List slab caches.",
388 
    .func = cmd_slabs,
 388 
    .func = cmd_slabs,
389 
    .argc = 0
 389 
    .argc = 0
390 
};
 390 
};
391 
 
 391 
 
392 
/* Data and methods for 'zones' command */
 392 
/* Data and methods for 'zones' command */
393 
static int cmd_zones(cmd_arg_t *argv);
 393 
static int cmd_zones(cmd_arg_t *argv);
394 
static cmd_info_t zones_info = {
 394 
static cmd_info_t zones_info = {
395 
    .name = "zones",
 395 
    .name = "zones",
396 
    .description = "List of memory zones.",
 396 
    .description = "List of memory zones.",
397 
    .func = cmd_zones,
 397 
    .func = cmd_zones,
398 
    .argc = 0
 398 
    .argc = 0
399 
};
 399 
};
400 
 
 400 
 
401 
/* Data and methods for 'ipc' command */
 401 
/* Data and methods for 'ipc' command */
402 
static int cmd_ipc(cmd_arg_t *argv);
 402 
static int cmd_ipc(cmd_arg_t *argv);
403 
static cmd_arg_t ipc_argv = {
 403 
static cmd_arg_t ipc_argv = {
404 
    .type = ARG_TYPE_INT,
 404 
    .type = ARG_TYPE_INT,
405 
};
 405 
};
406 
static cmd_info_t ipc_info = {
 406 
static cmd_info_t ipc_info = {
407 
    .name = "ipc",
 407 
    .name = "ipc",
408 
    .description = "ipc <taskid> Show IPC information of given task.",
 408 
    .description = "ipc <taskid> Show IPC information of given task.",
409 
    .func = cmd_ipc,
 409 
    .func = cmd_ipc,
410 
    .argc = 1,
 410 
    .argc = 1,
411 
    .argv = &ipc_argv
 411 
    .argv = &ipc_argv
412 
};
 412 
};
413 
 
 413 
 
414 
/* Data and methods for 'zone' command */
 414 
/* Data and methods for 'zone' command */
415 
static int cmd_zone(cmd_arg_t *argv);
 415 
static int cmd_zone(cmd_arg_t *argv);
416 
static cmd_arg_t zone_argv = {
 416 
static cmd_arg_t zone_argv = {
417 
    .type = ARG_TYPE_INT,
 417 
    .type = ARG_TYPE_INT,
418 
};
 418 
};
419 
 
 419 
 
420 
static cmd_info_t zone_info = {
 420 
static cmd_info_t zone_info = {
421 
    .name = "zone",
 421 
    .name = "zone",
422 
    .description = "Show memory zone structure.",
 422 
    .description = "Show memory zone structure.",
423 
    .func = cmd_zone,
 423 
    .func = cmd_zone,
424 
    .argc = 1,
 424 
    .argc = 1,
425 
    .argv = &zone_argv
 425 
    .argv = &zone_argv
426 
};
 426 
};
427 
 
 427 
 
428 
/* Data and methods for 'cpus' command. */
 428 
/* Data and methods for 'cpus' command. */
429 
static int cmd_cpus(cmd_arg_t *argv);
 429 
static int cmd_cpus(cmd_arg_t *argv);
430 
cmd_info_t cpus_info = {
 430 
cmd_info_t cpus_info = {
431 
    .name = "cpus",
 431 
    .name = "cpus",
432 
    .description = "List all processors.",
 432 
    .description = "List all processors.",
433 
    .help = NULL,
 433 
    .help = NULL,
434 
    .func = cmd_cpus,
 434 
    .func = cmd_cpus,
435 
    .argc = 0,
 435 
    .argc = 0,
436 
    .argv = NULL
 436 
    .argv = NULL
437 
};
 437 
};
438 
 
 438 
 
439 
/* Data and methods for 'version' command. */
 439 
/* Data and methods for 'version' command. */
440 
static int cmd_version(cmd_arg_t *argv);
 440 
static int cmd_version(cmd_arg_t *argv);
441 
cmd_info_t version_info = {
 441 
cmd_info_t version_info = {
442 
    .name = "version",
 442 
    .name = "version",
443 
    .description = "Print version information.",
 443 
    .description = "Print version information.",
444 
    .help = NULL,
 444 
    .help = NULL,
445 
    .func = cmd_version,
 445 
    .func = cmd_version,
446 
    .argc = 0,
 446 
    .argc = 0,
447 
    .argv = NULL
 447 
    .argv = NULL
448 
};
 448 
};
449 
 
 449 
 
450 
static cmd_info_t *basic_commands[] = {
 450 
static cmd_info_t *basic_commands[] = {
451 
    &call0_info,
 451 
    &call0_info,
452 
    &mcall0_info,
 452 
    &mcall0_info,
453 
    &call1_info,
 453 
    &call1_info,
454 
    &call2_info,
 454 
    &call2_info,
455 
    &call3_info,
 455 
    &call3_info,
456 
    &continue_info,
 456 
    &continue_info,
457 
    &cpus_info,
 457 
    &cpus_info,
458 
    &desc_info,
 458 
    &desc_info,
459 
    &exit_info,
 459 
    &exit_info,
460 
    &reboot_info,
 460 
    &reboot_info,
461 
    &uptime_info,
 461 
    &uptime_info,
462 
    &halt_info,
 462 
    &halt_info,
463 
    &help_info,
 463 
    &help_info,
464 
    &ipc_info,
 464 
    &ipc_info,
465 
    &set4_info,
 465 
    &set4_info,
466 
    &slabs_info,
 466 
    &slabs_info,
467 
    &symaddr_info,
 467 
    &symaddr_info,
468 
    &sched_info,
 468 
    &sched_info,
469 
    &threads_info,
 469 
    &threads_info,
470 
    &tasks_info,
 470 
    &tasks_info,
471 
    &physmem_info,
 471 
    &physmem_info,
472 
    &tlb_info,
 472 
    &tlb_info,
473 
    &version_info,
 473 
    &version_info,
474 
    &zones_info,
 474 
    &zones_info,
475 
    &zone_info,
 475 
    &zone_info,
476 
#ifdef CONFIG_TEST
 476 
#ifdef CONFIG_TEST
477 
    &tests_info,
 477 
    &tests_info,
478 
    &test_info,
 478 
    &test_info,
479 
    &bench_info,
 479 
    &bench_info,
480 
#endif
 480 
#endif
481 
    NULL
 481 
    NULL
482 
};
 482 
};
483 
 
 483 
 
484 
 
 484 
 
485 
/** Initialize command info structure.
 485 
/** Initialize command info structure.
486 
 *
 486 
 *
487 
 * @param cmd Command info structure.
 487 
 * @param cmd Command info structure.
488 
 *
 488 
 *
489 
 */
 489 
 */
490 
void cmd_initialize(cmd_info_t *cmd)
 490 
void cmd_initialize(cmd_info_t *cmd)
491 
{
 491 
{
492 
    spinlock_initialize(&cmd->lock, "cmd");
 492 
    spinlock_initialize(&cmd->lock, "cmd");
493 
    link_initialize(&cmd->link);
 493 
    link_initialize(&cmd->link);
494 
}
 494 
}
495 
 
 495 
 
496 
/** Initialize and register commands. */
 496 
/** Initialize and register commands. */
497 
void cmd_init(void)
 497 
void cmd_init(void)
498 
{
 498 
{
499 
    unsigned int i;
 499 
    unsigned int i;
500 
 
 500 
 
501 
    for (i = 0; basic_commands[i]; i++) {
 501 
    for (i = 0; basic_commands[i]; i++) {
502 
        cmd_initialize(basic_commands[i]);
 502 
        cmd_initialize(basic_commands[i]);
503 
        if (!cmd_register(basic_commands[i]))
 503 
        if (!cmd_register(basic_commands[i]))
504 
            printf("Cannot register command %s\n", basic_commands[i]->name);
 504 
            printf("Cannot register command %s\n", basic_commands[i]->name);
505 
    }
 505 
    }
506 
}
 506 
}
507 
 
 507 
 
508 
 
 508 
 
509 
/** List supported commands.
 509 
/** List supported commands.
510 
 *
 510 
 *
511 
 * @param argv Argument vector.
 511 
 * @param argv Argument vector.
512 
 *
 512 
 *
513 
 * @return 0 on failure, 1 on success.
 513 
 * @return 0 on failure, 1 on success.
514 
 */
 514 
 */
515 
int cmd_help(cmd_arg_t *argv)
 515 
int cmd_help(cmd_arg_t *argv)
516 
{
 516 
{
517 
    link_t *cur;
 517 
    link_t *cur;
518 
 
 518 
 
519 
    spinlock_lock(&cmd_lock);
 519 
    spinlock_lock(&cmd_lock);
520 
   
 520 
   
521 
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
 521 
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
522 
        cmd_info_t *hlp;
 522 
        cmd_info_t *hlp;
523 
       
 523 
       
524 
        hlp = list_get_instance(cur, cmd_info_t, link);
 524 
        hlp = list_get_instance(cur, cmd_info_t, link);
525 
        spinlock_lock(&hlp->lock);
 525 
        spinlock_lock(&hlp->lock);
526 
       
 526 
       
527 
        printf("%s - %s\n", hlp->name, hlp->description);
 527 
        printf("%s - %s\n", hlp->name, hlp->description);
528 
 
 528 
 
529 
        spinlock_unlock(&hlp->lock);
 529 
        spinlock_unlock(&hlp->lock);
530 
    }
 530 
    }
531 
   
 531 
   
532 
    spinlock_unlock(&cmd_lock);
 532 
    spinlock_unlock(&cmd_lock);
533 
 
 533 
 
534 
    return 1;
 534 
    return 1;
535 
}
 535 
}
536 
 
 536 
 
537 
 
 537 
 
538 
/** Reboot the system.
 538 
/** Reboot the system.
539 
 *
 539 
 *
540 
 * @param argv Argument vector.
 540 
 * @param argv Argument vector.
541 
 *
 541 
 *
542 
 * @return 0 on failure, 1 on success.
 542 
 * @return 0 on failure, 1 on success.
543 
 */
 543 
 */
544 
int cmd_reboot(cmd_arg_t *argv)
 544 
int cmd_reboot(cmd_arg_t *argv)
545 
{
 545 
{
546 
    reboot();
 546 
    reboot();
547 
   
 547 
   
548 
    /* Not reached */
 548 
    /* Not reached */
549 
    return 1;
 549 
    return 1;
550 
}
 550 
}
551 
 
 551 
 
552 
 
 552 
 
553 
/** Print system uptime information.
 553 
/** Print system uptime information.
554 
 *
 554 
 *
555 
 * @param argv Argument vector.
 555 
 * @param argv Argument vector.
556 
 *
 556 
 *
557 
 * @return 0 on failure, 1 on success.
 557 
 * @return 0 on failure, 1 on success.
558 
 */
 558 
 */
559 
int cmd_uptime(cmd_arg_t *argv)
 559 
int cmd_uptime(cmd_arg_t *argv)
560 
{
 560 
{
561 
    ASSERT(uptime);
 561 
    ASSERT(uptime);
562 
   
 562 
   
563 
    /* This doesn't have to be very accurate */
 563 
    /* This doesn't have to be very accurate */
564 
    unative_t sec = uptime->seconds1;
 564 
    unative_t sec = uptime->seconds1;
565 
   
 565 
   
566 
    printf("Up %" PRIun " days, %" PRIun " hours, %" PRIun " minutes, %" PRIun " seconds\n",
 566 
    printf("Up %" PRIun " days, %" PRIun " hours, %" PRIun " minutes, %" PRIun " seconds\n",
567 
        sec / 86400, (sec % 86400) / 3600, (sec % 3600) / 60, sec % 60);
 567 
        sec / 86400, (sec % 86400) / 3600, (sec % 3600) / 60, sec % 60);
568 
   
 568 
   
569 
    return 1;
 569 
    return 1;
570 
}
 570 
}
571 
 
 571 
 
572 
/** Describe specified command.
 572 
/** Describe specified command.
573 
 *
 573 
 *
574 
 * @param argv Argument vector.
 574 
 * @param argv Argument vector.
575 
 *
 575 
 *
576 
 * @return 0 on failure, 1 on success.
 576 
 * @return 0 on failure, 1 on success.
577 
 */
 577 
 */
578 
int cmd_desc(cmd_arg_t *argv)
 578 
int cmd_desc(cmd_arg_t *argv)
579 
{
 579 
{
580 
    link_t *cur;
 580 
    link_t *cur;
581 
 
 581 
 
582 
    spinlock_lock(&cmd_lock);
 582 
    spinlock_lock(&cmd_lock);
583 
   
 583 
   
584 
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
 584 
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
585 
        cmd_info_t *hlp;
 585 
        cmd_info_t *hlp;
586 
       
 586 
       
587 
        hlp = list_get_instance(cur, cmd_info_t, link);
 587 
        hlp = list_get_instance(cur, cmd_info_t, link);
588 
        spinlock_lock(&hlp->lock);
 588 
        spinlock_lock(&hlp->lock);
589 
 
 589 
 
590 
        if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
 590 
        if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
591 
            printf("%s - %s\n", hlp->name, hlp->description);
 591 
            printf("%s - %s\n", hlp->name, hlp->description);
592 
            if (hlp->help)
 592 
            if (hlp->help)
593 
                hlp->help();
 593 
                hlp->help();
594 
            spinlock_unlock(&hlp->lock);
 594 
            spinlock_unlock(&hlp->lock);
595 
            break;
 595 
            break;
596 
        }
 596 
        }
597 
 
 597 
 
598 
        spinlock_unlock(&hlp->lock);
 598 
        spinlock_unlock(&hlp->lock);
599 
    }
 599 
    }
600 
   
 600 
   
601 
    spinlock_unlock(&cmd_lock);
 601 
    spinlock_unlock(&cmd_lock);
602 
 
 602 
 
603 
    return 1;
 603 
    return 1;
604 
}
 604 
}
605 
 
 605 
 
606 
/** Search symbol table */
 606 
/** Search symbol table */
607 
int cmd_symaddr(cmd_arg_t *argv)
 607 
int cmd_symaddr(cmd_arg_t *argv)
608 
{
 608 
{
609 
    symtab_print_search((char *) argv->buffer);
 609 
    symtab_print_search((char *) argv->buffer);
610 
   
 610 
   
611 
    return 1;
 611 
    return 1;
612 
}
 612 
}
613 
 
 613 
 
614 
/** Call function with zero parameters */
 614 
/** Call function with zero parameters */
615 
int cmd_call0(cmd_arg_t *argv)
 615 
int cmd_call0(cmd_arg_t *argv)
616 
{
 616 
{
617 
    uintptr_t symaddr;
 617 
    uintptr_t symaddr;
618 
    char *symbol;
 618 
    char *symbol;
619 
    unative_t (*fnc)(void);
 619 
    unative_t (*fnc)(void);
620 
    fncptr_t fptr;
 620 
    fncptr_t fptr;
621 
   
 621 
   
622 
    symaddr = get_symbol_addr((char *) argv->buffer);
 622 
    symaddr = get_symbol_addr((char *) argv->buffer);
623 
    if (!symaddr)
 623 
    if (!symaddr)
624 
        printf("Symbol %s not found.\n", argv->buffer);
 624 
        printf("Symbol %s not found.\n", argv->buffer);
625 
    else if (symaddr == (uintptr_t) -1) {
 625 
    else if (symaddr == (uintptr_t) -1) {
626 
        symtab_print_search((char *) argv->buffer);
 626 
        symtab_print_search((char *) argv->buffer);
627 
        printf("Duplicate symbol, be more specific.\n");
 627 
        printf("Duplicate symbol, be more specific.\n");
628 
    } else {
 628 
    } else {
629 
        symbol = get_symtab_entry(symaddr);
 629 
        symbol = get_symtab_entry(symaddr);
630 
        fnc = (unative_t (*)(void)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call0);
 630 
        fnc = (unative_t (*)(void)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call0);
631 
        printf("Calling %s() (%p)\n", symbol, symaddr);
 631 
        printf("Calling %s() (%p)\n", symbol, symaddr);
632 
        printf("Result: %#" PRIxn "\n", fnc());
 632 
        printf("Result: %#" PRIxn "\n", fnc());
633 
    }
 633 
    }
634 
   
 634 
   
635 
    return 1;
 635 
    return 1;
636 
}
 636 
}
637 
 
 637 
 
638 
/** Call function with zero parameters on each CPU */
 638 
/** Call function with zero parameters on each CPU */
639 
int cmd_mcall0(cmd_arg_t *argv)
 639 
int cmd_mcall0(cmd_arg_t *argv)
640 
{
 640 
{
641 
    /*
 641 
    /*
642 
     * For each CPU, create a thread which will
 642 
     * For each CPU, create a thread which will
643 
     * call the function.
 643 
     * call the function.
644 
     */
 644 
     */
645 
   
 645 
   
646 
    count_t i;
 646 
    count_t i;
647 
    for (i = 0; i < config.cpu_count; i++) {
 647 
    for (i = 0; i < config.cpu_count; i++) {
648 
        if (!cpus[i].active)
 648 
        if (!cpus[i].active)
649 
            continue;
 649 
            continue;
650 
       
 650 
       
651 
        thread_t *t;
 651 
        thread_t *t;
652 
        if ((t = thread_create((void (*)(void *)) cmd_call0, (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
 652 
        if ((t = thread_create((void (*)(void *)) cmd_call0, (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
653 
            spinlock_lock(&t->lock);
 653 
            spinlock_lock(&t->lock);
654 
            t->cpu = &cpus[i];
 654 
            t->cpu = &cpus[i];
655 
            spinlock_unlock(&t->lock);
 655 
            spinlock_unlock(&t->lock);
656 
            printf("cpu%u: ", i);
 656 
            printf("cpu%u: ", i);
657 
            thread_ready(t);
 657 
            thread_ready(t);
658 
            thread_join(t);
 658 
            thread_join(t);
659 
            thread_detach(t);
 659 
            thread_detach(t);
660 
        } else
 660 
        } else
661 
            printf("Unable to create thread for cpu%u\n", i);
 661 
            printf("Unable to create thread for cpu%u\n", i);
662 
    }
 662 
    }
663 
   
 663 
   
664 
    return 1;
 664 
    return 1;
665 
}
 665 
}
666 
 
 666 
 
667 
/** Call function with one parameter */
 667 
/** Call function with one parameter */
668 
int cmd_call1(cmd_arg_t *argv)
 668 
int cmd_call1(cmd_arg_t *argv)
669 
{
 669 
{
670 
    uintptr_t symaddr;
 670 
    uintptr_t symaddr;
671 
    char *symbol;
 671 
    char *symbol;
672 
    unative_t (*fnc)(unative_t, ...);
 672 
    unative_t (*fnc)(unative_t, ...);
673 
    unative_t arg1 = argv[1].intval;
 673 
    unative_t arg1 = argv[1].intval;
674 
    fncptr_t fptr;
 674 
    fncptr_t fptr;
675 
   
 675 
   
676 
    symaddr = get_symbol_addr((char *) argv->buffer);
 676 
    symaddr = get_symbol_addr((char *) argv->buffer);
677 
    if (!symaddr)
 677 
    if (!symaddr)
678 
        printf("Symbol %s not found.\n", argv->buffer);
 678 
        printf("Symbol %s not found.\n", argv->buffer);
679 
    else if (symaddr == (uintptr_t) -1) {
 679 
    else if (symaddr == (uintptr_t) -1) {
680 
        symtab_print_search((char *) argv->buffer);
 680 
        symtab_print_search((char *) argv->buffer);
681 
        printf("Duplicate symbol, be more specific.\n");
 681 
        printf("Duplicate symbol, be more specific.\n");
682 
    } else {
 682 
    } else {
683 
        symbol = get_symtab_entry(symaddr);
 683 
        symbol = get_symtab_entry(symaddr);
684 
        fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1);
 684 
        fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1);
685 
        printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
 685 
        printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
686 
        printf("Result: %#" PRIxn "\n", fnc(arg1));
 686 
        printf("Result: %#" PRIxn "\n", fnc(arg1));
687 
    }
 687 
    }
688 
   
 688 
   
689 
    return 1;
 689 
    return 1;
690 
}
 690 
}
691 
 
 691 
 
692 
/** Call function with two parameters */
 692 
/** Call function with two parameters */
693 
int cmd_call2(cmd_arg_t *argv)
 693 
int cmd_call2(cmd_arg_t *argv)
694 
{
 694 
{
695 
    uintptr_t symaddr;
 695 
    uintptr_t symaddr;
696 
    char *symbol;
 696 
    char *symbol;
697 
    unative_t (*fnc)(unative_t, unative_t, ...);
 697 
    unative_t (*fnc)(unative_t, unative_t, ...);
698 
    unative_t arg1 = argv[1].intval;
 698 
    unative_t arg1 = argv[1].intval;
699 
    unative_t arg2 = argv[2].intval;
 699 
    unative_t arg2 = argv[2].intval;
700 
    fncptr_t fptr;
 700 
    fncptr_t fptr;
701 
   
 701 
   
702 
    symaddr = get_symbol_addr((char *) argv->buffer);
 702 
    symaddr = get_symbol_addr((char *) argv->buffer);
703 
    if (!symaddr)
 703 
    if (!symaddr)
704 
        printf("Symbol %s not found.\n", argv->buffer);
 704 
        printf("Symbol %s not found.\n", argv->buffer);
705 
    else if (symaddr == (uintptr_t) -1) {
 705 
    else if (symaddr == (uintptr_t) -1) {
706 
        symtab_print_search((char *) argv->buffer);
 706 
        symtab_print_search((char *) argv->buffer);
707 
        printf("Duplicate symbol, be more specific.\n");
 707 
        printf("Duplicate symbol, be more specific.\n");
708 
    } else {
 708 
    } else {
709 
        symbol = get_symtab_entry(symaddr);
 709 
        symbol = get_symtab_entry(symaddr);
710 
        fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2);
 710 
        fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2);
711 
        printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
 711 
        printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
712 
               arg1, arg2, symaddr, symbol);
 712 
               arg1, arg2, symaddr, symbol);
713 
        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
 713 
        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
714 
    }
 714 
    }
715 
   
 715 
   
716 
    return 1;
 716 
    return 1;
717 
}
 717 
}
718 
 
 718 
 
719 
/** Call function with three parameters */
 719 
/** Call function with three parameters */
720 
int cmd_call3(cmd_arg_t *argv)
 720 
int cmd_call3(cmd_arg_t *argv)
721 
{
 721 
{
722 
    uintptr_t symaddr;
 722 
    uintptr_t symaddr;
723 
    char *symbol;
 723 
    char *symbol;
724 
    unative_t (*fnc)(unative_t, unative_t, unative_t, ...);
 724 
    unative_t (*fnc)(unative_t, unative_t, unative_t, ...);
725 
    unative_t arg1 = argv[1].intval;
 725 
    unative_t arg1 = argv[1].intval;
726 
    unative_t arg2 = argv[2].intval;
 726 
    unative_t arg2 = argv[2].intval;
727 
    unative_t arg3 = argv[3].intval;
 727 
    unative_t arg3 = argv[3].intval;
728 
    fncptr_t fptr;
 728 
    fncptr_t fptr;
729 
   
 729 
   
730 
    symaddr = get_symbol_addr((char *) argv->buffer);
 730 
    symaddr = get_symbol_addr((char *) argv->buffer);
731 
    if (!symaddr)
 731 
    if (!symaddr)
732 
        printf("Symbol %s not found.\n", argv->buffer);
 732 
        printf("Symbol %s not found.\n", argv->buffer);
733 
    else if (symaddr == (uintptr_t) -1) {
 733 
    else if (symaddr == (uintptr_t) -1) {
734 
        symtab_print_search((char *) argv->buffer);
 734 
        symtab_print_search((char *) argv->buffer);
735 
        printf("Duplicate symbol, be more specific.\n");
 735 
        printf("Duplicate symbol, be more specific.\n");
736 
    } else {
 736 
    } else {
737 
        symbol = get_symtab_entry(symaddr);
 737 
        symbol = get_symtab_entry(symaddr);
738 
        fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3);
 738 
        fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3);
739 
        printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
 739 
        printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
740 
               arg1, arg2, arg3, symaddr, symbol);
 740 
               arg1, arg2, arg3, symaddr, symbol);
741 
        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3));
 741 
        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3));
742 
    }
 742 
    }
743 
   
 743 
   
744 
    return 1;
 744 
    return 1;
745 
}
 745 
}
746 
 
 746 
 
747 
 
 747 
 
748 
/** Print detailed description of 'describe' command. */
 748 
/** Print detailed description of 'describe' command. */
749 
void desc_help(void)
 749 
void desc_help(void)
750 
{
 750 
{
751 
    printf("Syntax: describe command_name\n");
 751 
    printf("Syntax: describe command_name\n");
752 
}
 752 
}
753 
 
 753 
 
754 
/** Halt the kernel.
 754 
/** Halt the kernel.
755 
 *
 755 
 *
756 
 * @param argv Argument vector (ignored).
 756 
 * @param argv Argument vector (ignored).
757 
 *
 757 
 *
758 
 * @return 0 on failure, 1 on success (never returns).
 758 
 * @return 0 on failure, 1 on success (never returns).
759 
 */
 759 
 */
760 
int cmd_halt(cmd_arg_t *argv)
 760 
int cmd_halt(cmd_arg_t *argv)
761 
{
 761 
{
762 
    halt();
 762 
    halt();
763 
    return 1;
 763 
    return 1;
764 
}
 764 
}
765 
 
 765 
 
766 
/** Command for printing TLB contents.
 766 
/** Command for printing TLB contents.
767 
 *
 767 
 *
768 
 * @param argv Not used.
 768 
 * @param argv Not used.
769 
 *
 769 
 *
770 
 * @return Always returns 1.
 770 
 * @return Always returns 1.
771 
 */
 771 
 */
772 
int cmd_tlb(cmd_arg_t *argv)
 772 
int cmd_tlb(cmd_arg_t *argv)
773 
{
 773 
{
774 
    tlb_print();
 774 
    tlb_print();
775 
    return 1;
 775 
    return 1;
776 
}
 776 
}
777 
 
 777 
 
778 
/** Command for printing physical memory configuration.
 778 
/** Command for printing physical memory configuration.
779 
 *
 779 
 *
780 
 * @param argv Not used.
 780 
 * @param argv Not used.
781 
 *
 781 
 *
782 
 * @return Always returns 1.
 782 
 * @return Always returns 1.
783 
 */
 783 
 */
784 
int cmd_physmem(cmd_arg_t *argv)
 784 
int cmd_physmem(cmd_arg_t *argv)
785 
{
 785 
{
786 
    physmem_print();
 786 
    physmem_print();
787 
    return 1;
 787 
    return 1;
788 
}
 788 
}
789 
 
 789 
 
790 
/** Write 4 byte value to address */
 790 
/** Write 4 byte value to address */
791 
int cmd_set4(cmd_arg_t *argv)
 791 
int cmd_set4(cmd_arg_t *argv)
792 
{
 792 
{
793 
    uint32_t *addr;
 793 
    uint32_t *addr;
794 
    uint32_t arg1 = argv[1].intval;
 794 
    uint32_t arg1 = argv[1].intval;
795 
    bool pointer = false;
 795 
    bool pointer = false;
796 
 
 796 
 
797 
    if (((char *)argv->buffer)[0] == '*') {
 797 
    if (((char *)argv->buffer)[0] == '*') {
798 
        addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);
 798 
        addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);
799 
        pointer = true;
 799 
        pointer = true;
800 
    } else if (((char *) argv->buffer)[0] >= '0' &&
 800 
    } else if (((char *) argv->buffer)[0] >= '0' &&
801 
           ((char *)argv->buffer)[0] <= '9')
 801 
           ((char *)argv->buffer)[0] <= '9')
802 
        addr = (uint32_t *)atoi((char *)argv->buffer);
 802 
        addr = (uint32_t *)atoi((char *)argv->buffer);
803 
    else
 803 
    else
804 
        addr = (uint32_t *)get_symbol_addr((char *) argv->buffer);
 804 
        addr = (uint32_t *)get_symbol_addr((char *) argv->buffer);
805 
 
 805 
 
806 
    if (!addr)
 806 
    if (!addr)
807 
        printf("Symbol %s not found.\n", argv->buffer);
 807 
        printf("Symbol %s not found.\n", argv->buffer);
808 
    else if (addr == (uint32_t *) -1) {
 808 
    else if (addr == (uint32_t *) -1) {
809 
        symtab_print_search((char *) argv->buffer);
 809 
        symtab_print_search((char *) argv->buffer);
810 
        printf("Duplicate symbol, be more specific.\n");
 810 
        printf("Duplicate symbol, be more specific.\n");
811 
    } else {
 811 
    } else {
812 
        if (pointer)
 812 
        if (pointer)
813 
            addr = (uint32_t *)(*(unative_t *)addr);
 813 
            addr = (uint32_t *)(*(unative_t *)addr);
814 
        printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
 814 
        printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
815 
        *addr = arg1;
 815 
        *addr = arg1;
816 
       
 816 
       
817 
    }
 817 
    }
818 
   
 818 
   
819 
    return 1;
 819 
    return 1;
820 
}
 820 
}
821 
 
 821 
 
822 
/** Command for listings SLAB caches
 822 
/** Command for listings SLAB caches
823 
 *
 823 
 *
824 
 * @param argv Ignores
 824 
 * @param argv Ignores
825 
 *
 825 
 *
826 
 * @return Always 1
 826 
 * @return Always 1
827 
 */
 827 
 */
828 
int cmd_slabs(cmd_arg_t * argv) {
 828 
int cmd_slabs(cmd_arg_t * argv) {
829 
    slab_print_list();
 829 
    slab_print_list();
830 
    return 1;
 830 
    return 1;
831 
}
 831 
}
832 
 
 832 
 
833 
 
 833 
 
834 
/** Command for listings Thread information
 834 
/** Command for listings Thread information
835 
 *
 835 
 *
836 
 * @param argv Ignores
 836 
 * @param argv Ignores
837 
 *
 837 
 *
838 
 * @return Always 1
 838 
 * @return Always 1
839 
 */
 839 
 */
840 
int cmd_threads(cmd_arg_t * argv) {
 840 
int cmd_threads(cmd_arg_t * argv) {
841 
    thread_print_list();
 841 
    thread_print_list();
842 
    return 1;
 842 
    return 1;
843 
}
 843 
}
844 
 
 844 
 
845 
/** Command for listings Task information
 845 
/** Command for listings Task information
846 
 *
 846 
 *
847 
 * @param argv Ignores
 847 
 * @param argv Ignores
848 
 *
 848 
 *
849 
 * @return Always 1
 849 
 * @return Always 1
850 
 */
 850 
 */
851 
int cmd_tasks(cmd_arg_t * argv) {
 851 
int cmd_tasks(cmd_arg_t * argv) {
852 
    task_print_list();
 852 
    task_print_list();
853 
    return 1;
 853 
    return 1;
854 
}
 854 
}
855 
 
 855 
 
856 
/** Command for listings Thread information
 856 
/** Command for listings Thread information
857 
 *
 857 
 *
858 
 * @param argv Ignores
 858 
 * @param argv Ignores
859 
 *
 859 
 *
860 
 * @return Always 1
 860 
 * @return Always 1
861 
 */
 861 
 */
862 
int cmd_sched(cmd_arg_t * argv) {
 862 
int cmd_sched(cmd_arg_t * argv) {
863 
    sched_print_list();
 863 
    sched_print_list();
864 
    return 1;
 864 
    return 1;
865 
}
 865 
}
866 
 
 866 
 
867 
/** Command for listing memory zones
 867 
/** Command for listing memory zones
868 
 *
 868 
 *
869 
 * @param argv Ignored
 869 
 * @param argv Ignored
870 
 *
 870 
 *
871 
 * return Always 1
 871 
 * return Always 1
872 
 */
 872 
 */
873 
int cmd_zones(cmd_arg_t * argv) {
 873 
int cmd_zones(cmd_arg_t * argv) {
874 
    zone_print_list();
 874 
    zone_print_list();
875 
    return 1;
 875 
    return 1;
876 
}
 876 
}
877 
 
 877 
 
878 
/** Command for memory zone details
 878 
/** Command for memory zone details
879 
 *
 879 
 *
880 
 * @param argv Integer argument from cmdline expected
 880 
 * @param argv Integer argument from cmdline expected
881 
 *
 881 
 *
882 
 * return Always 1
 882 
 * return Always 1
883 
 */
 883 
 */
884 
int cmd_zone(cmd_arg_t * argv) {
 884 
int cmd_zone(cmd_arg_t * argv) {
885 
    zone_print_one(argv[0].intval);
 885 
    zone_print_one(argv[0].intval);
886 
    return 1;
 886 
    return 1;
887 
}
 887 
}
888 
 
 888 
 
889 
/** Command for printing task ipc details
 889 
/** Command for printing task ipc details
890 
 *
 890 
 *
891 
 * @param argv Integer argument from cmdline expected
 891 
 * @param argv Integer argument from cmdline expected
892 
 *
 892 
 *
893 
 * return Always 1
 893 
 * return Always 1
894 
 */
 894 
 */
895 
int cmd_ipc(cmd_arg_t * argv) {
 895 
int cmd_ipc(cmd_arg_t * argv) {
896 
    ipc_print_task(argv[0].intval);
 896 
    ipc_print_task(argv[0].intval);
897 
    return 1;
 897 
    return 1;
898 
}
 898 
}
899 
 
 899 
 
900 
 
 900 
 
901 
/** Command for listing processors.
 901 
/** Command for listing processors.
902 
 *
 902 
 *
903 
 * @param argv Ignored.
 903 
 * @param argv Ignored.
904 
 *
 904 
 *
905 
 * return Always 1.
 905 
 * return Always 1.
906 
 */
 906 
 */
907 
int cmd_cpus(cmd_arg_t *argv)
 907 
int cmd_cpus(cmd_arg_t *argv)
908 
{
 908 
{
909 
    cpu_list();
 909 
    cpu_list();
910 
    return 1;
 910 
    return 1;
911 
}
 911 
}
912 
 
 912 
 
913 
/** Command for printing kernel version.
 913 
/** Command for printing kernel version.
914 
 *
 914 
 *
915 
 * @param argv Ignored.
 915 
 * @param argv Ignored.
916 
 *
 916 
 *
917 
 * return Always 1.
 917 
 * return Always 1.
918 
 */
 918 
 */
919 
int cmd_version(cmd_arg_t *argv)
 919 
int cmd_version(cmd_arg_t *argv)
920 
{
 920 
{
921 
    version_print();
 921 
    version_print();
922 
    return 1;
 922 
    return 1;
923 
}
 923 
}
924 
 
 924 
 
925 
/** Command for returning console back to userspace.
 925 
/** Command for returning console back to userspace.
926 
 *
 926 
 *
927 
 * @param argv Ignored.
 927 
 * @param argv Ignored.
928 
 *
 928 
 *
929 
 * return Always 1.
 929 
 * return Always 1.
930 
 */
 930 
 */
931 
int cmd_continue(cmd_arg_t *argv)
 931 
int cmd_continue(cmd_arg_t *argv)
932 
{
 932 
{
933 
    printf("The kernel will now relinquish the console.\n");
 933 
    printf("The kernel will now relinquish the console.\n");
934 
    release_console();
 934 
    release_console();
935 
   
 935 
   
936 
    if ((kconsole_notify) && (kconsole_irq.notif_cfg.notify))
 936 
    if ((kconsole_notify) && (kconsole_irq.notif_cfg.notify))
937 
        ipc_irq_send_msg_0(&kconsole_irq);
 937 
        ipc_irq_send_msg_0(&kconsole_irq);
938 
   
 938 
   
939 
    return 1;
 939 
    return 1;
940 
}
 940 
}
941 
 
 941 
 
942 
#ifdef CONFIG_TEST
 942 
#ifdef CONFIG_TEST
943 
/** Command for printing kernel tests list.
 943 
/** Command for printing kernel tests list.
944 
 *
 944 
 *
945 
 * @param argv Ignored.
 945 
 * @param argv Ignored.
946 
 *
 946 
 *
947 
 * return Always 1.
 947 
 * return Always 1.
948 
 */
 948 
 */
949 
int cmd_tests(cmd_arg_t *argv)
 949 
int cmd_tests(cmd_arg_t *argv)
950 
{
 950 
{
951 
    test_t *test;
 951 
    test_t *test;
952 
   
 952 
   
953 
    for (test = tests; test->name != NULL; test++)
 953 
    for (test = tests; test->name != NULL; test++)
954 
        printf("%-10s %s%s\n", test->name, test->desc, (test->safe ? "" : " (unsafe)"));
 954 
        printf("%-10s %s%s\n", test->name, test->desc, (test->safe ? "" : " (unsafe)"));
955 
   
 955 
   
956 
    printf("%-10s Run all safe tests\n", "*");
 956 
    printf("%-10s Run all safe tests\n", "*");
957 
    return 1;
 957 
    return 1;
958 
}
 958 
}
959 
 
 959 
 
960 
static bool run_test(const test_t *test)
 960 
static bool run_test(const test_t *test)
961 
{
 961 
{
962 
    printf("%s\t\t%s\n", test->name, test->desc);
 962 
    printf("%s\t\t%s\n", test->name, test->desc);
963 
   
 963 
   
964 
    /* Update and read thread accounting
 964 
    /* Update and read thread accounting
965 
       for benchmarking */
 965 
       for benchmarking */
966 
    ipl_t ipl = interrupts_disable();
 966 
    ipl_t ipl = interrupts_disable();
967 
    spinlock_lock(&TASK->lock);
 967 
    spinlock_lock(&TASK->lock);
968 
    uint64_t t0 = task_get_accounting(TASK);
 968 
    uint64_t t0 = task_get_accounting(TASK);
969 
    spinlock_unlock(&TASK->lock);
 969 
    spinlock_unlock(&TASK->lock);
970 
    interrupts_restore(ipl);
 970 
    interrupts_restore(ipl);
971 
   
 971 
   
972 
    /* Execute the test */
 972 
    /* Execute the test */
973 
    char * ret = test->entry(false);
 973 
    char * ret = test->entry(false);
974 
   
 974 
   
975 
    /* Update and read thread accounting */
 975 
    /* Update and read thread accounting */
976 
    ipl = interrupts_disable();
 976 
    ipl = interrupts_disable();
977 
    spinlock_lock(&TASK->lock);
 977 
    spinlock_lock(&TASK->lock);
978 
    uint64_t dt = task_get_accounting(TASK) - t0;
 978 
    uint64_t dt = task_get_accounting(TASK) - t0;
979 
    spinlock_unlock(&TASK->lock);
 979 
    spinlock_unlock(&TASK->lock);
980 
    interrupts_restore(ipl);
 980 
    interrupts_restore(ipl);
981 
   
 981 
   
982 
    uint64_t cycles;
 982 
    uint64_t cycles;
983 
    char suffix;
 983 
    char suffix;
984 
    order(dt, &cycles, &suffix);
 984 
    order(dt, &cycles, &suffix);
985 
       
 985 
       
986 
    printf("Time: %" PRIu64 "%c cycles\n", cycles, suffix);
 986 
    printf("Time: %" PRIu64 "%c cycles\n", cycles, suffix);
987 
   
 987 
   
988 
    if (ret == NULL) {
 988 
    if (ret == NULL) {
989 
        printf("Test passed\n");
 989 
        printf("Test passed\n");
990 
        return true;
 990 
        return true;
991 
    }
 991 
    }
992 
 
 992 
 
993 
    printf("%s\n", ret);
 993 
    printf("%s\n", ret);
994 
    return false;
 994 
    return false;
995 
}
 995 
}
996 
 
 996 
 
997 
static bool run_bench(const test_t *test, const uint32_t cnt)
 997 
static bool run_bench(const test_t *test, const uint32_t cnt)
998 
{
 998 
{
999 
    uint32_t i;
 999 
    uint32_t i;
1000 
    bool ret = true;
 1000 
    bool ret = true;
1001 
    uint64_t cycles;
 1001 
    uint64_t cycles;
1002 
    char suffix;
 1002 
    char suffix;
1003 
   
 1003 
   
1004 
    if (cnt < 1)
 1004 
    if (cnt < 1)
1005 
        return true;
 1005 
        return true;
1006 
   
 1006 
   
1007 
    uint64_t *data = (uint64_t *) malloc(sizeof(uint64_t) * cnt, 0);
 1007 
    uint64_t *data = (uint64_t *) malloc(sizeof(uint64_t) * cnt, 0);
1008 
    if (data == NULL) {
 1008 
    if (data == NULL) {
1009 
        printf("Error allocating memory for statistics\n");
 1009 
        printf("Error allocating memory for statistics\n");
1010 
        return false;
 1010 
        return false;
1011 
    }
 1011 
    }
1012 
   
 1012 
   
1013 
    for (i = 0; i < cnt; i++) {
 1013 
    for (i = 0; i < cnt; i++) {
1014 
        printf("%s (%u/%u) ... ", test->name, i + 1, cnt);
 1014 
        printf("%s (%u/%u) ... ", test->name, i + 1, cnt);
1015 
       
 1015 
       
1016 
        /* Update and read thread accounting
 1016 
        /* Update and read thread accounting
1017 
           for benchmarking */
 1017 
           for benchmarking */
1018 
        ipl_t ipl = interrupts_disable();
 1018 
        ipl_t ipl = interrupts_disable();
1019 
        spinlock_lock(&TASK->lock);
 1019 
        spinlock_lock(&TASK->lock);
1020 
        uint64_t t0 = task_get_accounting(TASK);
 1020 
        uint64_t t0 = task_get_accounting(TASK);
1021 
        spinlock_unlock(&TASK->lock);
 1021 
        spinlock_unlock(&TASK->lock);
1022 
        interrupts_restore(ipl);
 1022 
        interrupts_restore(ipl);
1023 
       
 1023 
       
1024 
        /* Execute the test */
 1024 
        /* Execute the test */
1025 
        char * ret = test->entry(true);
 1025 
        char * ret = test->entry(true);
1026 
       
 1026 
       
1027 
        /* Update and read thread accounting */
 1027 
        /* Update and read thread accounting */
1028 
        ipl = interrupts_disable();
 1028 
        ipl = interrupts_disable();
1029 
        spinlock_lock(&TASK->lock);
 1029 
        spinlock_lock(&TASK->lock);
1030 
        uint64_t dt = task_get_accounting(TASK) - t0;
 1030 
        uint64_t dt = task_get_accounting(TASK) - t0;
1031 
        spinlock_unlock(&TASK->lock);
 1031 
        spinlock_unlock(&TASK->lock);
1032 
        interrupts_restore(ipl);
 1032 
        interrupts_restore(ipl);
1033 
       
 1033 
       
1034 
        if (ret != NULL) {
 1034 
        if (ret != NULL) {
1035 
            printf("%s\n", ret);
 1035 
            printf("%s\n", ret);
1036 
            ret = false;
 1036 
            ret = false;
1037 
            break;
 1037 
            break;
1038 
        }
 1038 
        }
1039 
       
 1039 
       
1040 
        data[i] = dt;
 1040 
        data[i] = dt;
1041 
        order(dt, &cycles, &suffix);
 1041 
        order(dt, &cycles, &suffix);
1042 
        printf("OK (%" PRIu64 "%c cycles)\n", cycles, suffix);
 1042 
        printf("OK (%" PRIu64 "%c cycles)\n", cycles, suffix);
1043 
    }
 1043 
    }
1044 
   
 1044 
   
1045 
    if (ret) {
 1045 
    if (ret) {
1046 
        printf("\n");
 1046 
        printf("\n");
1047 
       
 1047 
       
1048 
        uint64_t sum = 0;
 1048 
        uint64_t sum = 0;
1049 
       
 1049 
       
1050 
        for (i = 0; i < cnt; i++) {
 1050 
        for (i = 0; i < cnt; i++) {
1051 
            sum += data[i];
 1051 
            sum += data[i];
1052 
        }
 1052 
        }
1053 
       
 1053 
       
1054 
        order(sum / (uint64_t) cnt, &cycles, &suffix);
 1054 
        order(sum / (uint64_t) cnt, &cycles, &suffix);
1055 
        printf("Average\t\t%" PRIu64 "%c\n", cycles, suffix);
 1055 
        printf("Average\t\t%" PRIu64 "%c\n", cycles, suffix);
1056 
    }
 1056 
    }
1057 
   
 1057 
   
1058 
    free(data);
 1058 
    free(data);
1059 
   
 1059 
   
1060 
    return ret;
 1060 
    return ret;
1061 
}
 1061 
}
1062 
 
 1062 
 
1063 
/** Command for returning kernel tests
 1063 
/** Command for returning kernel tests
1064 
 *
 1064 
 *
1065 
 * @param argv Argument vector.
 1065 
 * @param argv Argument vector.
1066 
 *
 1066 
 *
1067 
 * return Always 1.
 1067 
 * return Always 1.
1068 
 */
 1068 
 */
1069 
int cmd_test(cmd_arg_t *argv)
 1069 
int cmd_test(cmd_arg_t *argv)
1070 
{
 1070 
{
1071 
    test_t *test;
 1071 
    test_t *test;
1072 
   
 1072 
   
1073 
    if (strcmp((char *) argv->buffer, "*") == 0) {
 1073 
    if (strcmp((char *) argv->buffer, "*") == 0) {
1074 
        for (test = tests; test->name != NULL; test++) {
 1074 
        for (test = tests; test->name != NULL; test++) {
1075 
            if (test->safe) {
 1075 
            if (test->safe) {
1076 
                printf("\n");
 1076 
                printf("\n");
1077 
                if (!run_test(test))
 1077 
                if (!run_test(test))
1078 
                    break;
 1078 
                    break;
1079 
            }
 1079 
            }
1080 
        }
 1080 
        }
1081 
    } else {
 1081 
    } else {
1082 
        bool fnd = false;
 1082 
        bool fnd = false;
1083 
       
 1083 
       
1084 
        for (test = tests; test->name != NULL; test++) {
 1084 
        for (test = tests; test->name != NULL; test++) {
1085 
            if (strcmp(test->name, (char *) argv->buffer) == 0) {
 1085 
            if (strcmp(test->name, (char *) argv->buffer) == 0) {
1086 
                fnd = true;
 1086 
                fnd = true;
1087 
                run_test(test);
 1087 
                run_test(test);
1088 
                break;
 1088 
                break;
1089 
            }
 1089 
            }
1090 
        }
 1090 
        }
1091 
       
 1091 
       
1092 
        if (!fnd)
 1092 
        if (!fnd)
1093 
            printf("Unknown test\n");
 1093 
            printf("Unknown test\n");
1094 
    }
 1094 
    }
1095 
   
 1095 
   
1096 
    return 1;
 1096 
    return 1;
1097 
}
 1097 
}
1098 
 
 1098 
 
1099 
/** Command for returning kernel tests as benchmarks
 1099 
/** Command for returning kernel tests as benchmarks
1100 
 *
 1100 
 *
1101 
 * @param argv Argument vector.
 1101 
 * @param argv Argument vector.
1102 
 *
 1102 
 *
1103 
 * return Always 1.
 1103 
 * return Always 1.
1104 
 */
 1104 
 */
1105 
int cmd_bench(cmd_arg_t *argv)
 1105 
int cmd_bench(cmd_arg_t *argv)
1106 
{
 1106 
{
1107 
    test_t *test;
 1107 
    test_t *test;
1108 
    uint32_t cnt = argv[1].intval;
 1108 
    uint32_t cnt = argv[1].intval;
1109 
   
 1109 
   
1110 
    bool fnd = false;
 1110 
    bool fnd = false;
1111 
   
 1111 
   
1112 
    for (test = tests; test->name != NULL; test++) {
 1112 
    for (test = tests; test->name != NULL; test++) {
1113 
        if (strcmp(test->name, (char *) argv->buffer) == 0) {
 1113 
        if (strcmp(test->name, (char *) argv->buffer) == 0) {
1114 
            fnd = true;
 1114 
            fnd = true;
1115 
           
 1115 
           
1116 
            if (test->safe)
 1116 
            if (test->safe)
1117 
                run_bench(test, cnt);
 1117 
                run_bench(test, cnt);
1118 
            else
 1118 
            else
1119 
                printf("Unsafe test\n");
 1119 
                printf("Unsafe test\n");
1120 
           
 1120 
           
1121 
            break;
 1121 
            break;
1122 
        }
 1122 
        }
1123 
    }
 1123 
    }
1124 
       
 1124 
       
1125 
    if (!fnd)
 1125 
    if (!fnd)
1126 
        printf("Unknown test\n");
 1126 
        printf("Unknown test\n");
1127 
 
 1127 
 
1128 
    return 1;
 1128 
    return 1;
1129 
}
 1129 
}
1130 
 
 1130 
 
1131 
#endif
 1131 
#endif
1132 
 
 1132 
 
1133 
/** @}
 1133 
/** @}
1134 
 */
 1134 
 */
1135 
 
 1135