Subversion Repositories HelenOS

Rev

Rev 3492 | Rev 3770 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 3492 Rev 3742
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
            panic("could not 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 (*f)(void);
619
    unative_t (*f)(void);
620
#ifdef ia64
620
#ifdef ia64
621
    struct {
621
    struct {
622
        unative_t f;
622
        unative_t f;
623
        unative_t gp;
623
        unative_t gp;
624
    } fptr;
624
    } fptr;
625
#endif
625
#endif
626
 
626
 
627
    symaddr = get_symbol_addr((char *) argv->buffer);
627
    symaddr = get_symbol_addr((char *) argv->buffer);
628
    if (!symaddr)
628
    if (!symaddr)
629
        printf("Symbol %s not found.\n", argv->buffer);
629
        printf("Symbol %s not found.\n", argv->buffer);
630
    else if (symaddr == (uintptr_t) -1) {
630
    else if (symaddr == (uintptr_t) -1) {
631
        symtab_print_search((char *) argv->buffer);
631
        symtab_print_search((char *) argv->buffer);
632
        printf("Duplicate symbol, be more specific.\n");
632
        printf("Duplicate symbol, be more specific.\n");
633
    } else {
633
    } else {
634
        symbol = get_symtab_entry(symaddr);
634
        symbol = get_symtab_entry(symaddr);
635
        printf("Calling %s() (%p)\n", symbol, symaddr);
635
        printf("Calling %s() (%p)\n", symbol, symaddr);
636
#ifdef ia64
636
#ifdef ia64
637
        fptr.f = symaddr;
637
        fptr.f = symaddr;
638
        fptr.gp = ((unative_t *)cmd_call2)[1];
638
        fptr.gp = ((unative_t *)cmd_call2)[1];
639
        f =  (unative_t (*)(void)) &fptr;
639
        f =  (unative_t (*)(void)) &fptr;
640
#else
640
#else
641
        f =  (unative_t (*)(void)) symaddr;
641
        f =  (unative_t (*)(void)) symaddr;
642
#endif
642
#endif
643
        printf("Result: %#" PRIxn "\n", f());
643
        printf("Result: %#" PRIxn "\n", f());
644
    }
644
    }
645
   
645
   
646
    return 1;
646
    return 1;
647
}
647
}
648
 
648
 
649
/** Call function with zero parameters on each CPU */
649
/** Call function with zero parameters on each CPU */
650
int cmd_mcall0(cmd_arg_t *argv)
650
int cmd_mcall0(cmd_arg_t *argv)
651
{
651
{
652
    /*
652
    /*
653
     * For each CPU, create a thread which will
653
     * For each CPU, create a thread which will
654
     * call the function.
654
     * call the function.
655
     */
655
     */
656
   
656
   
657
    count_t i;
657
    count_t i;
658
    for (i = 0; i < config.cpu_count; i++) {
658
    for (i = 0; i < config.cpu_count; i++) {
659
        if (!cpus[i].active)
659
        if (!cpus[i].active)
660
            continue;
660
            continue;
661
       
661
       
662
        thread_t *t;
662
        thread_t *t;
663
        if ((t = thread_create((void (*)(void *)) cmd_call0, (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
663
        if ((t = thread_create((void (*)(void *)) cmd_call0, (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
664
            spinlock_lock(&t->lock);
664
            spinlock_lock(&t->lock);
665
            t->cpu = &cpus[i];
665
            t->cpu = &cpus[i];
666
            spinlock_unlock(&t->lock);
666
            spinlock_unlock(&t->lock);
667
            printf("cpu%u: ", i);
667
            printf("cpu%u: ", i);
668
            thread_ready(t);
668
            thread_ready(t);
669
            thread_join(t);
669
            thread_join(t);
670
            thread_detach(t);
670
            thread_detach(t);
671
        } else
671
        } else
672
            printf("Unable to create thread for cpu%u\n", i);
672
            printf("Unable to create thread for cpu%u\n", i);
673
    }
673
    }
674
   
674
   
675
    return 1;
675
    return 1;
676
}
676
}
677
 
677
 
678
/** Call function with one parameter */
678
/** Call function with one parameter */
679
int cmd_call1(cmd_arg_t *argv)
679
int cmd_call1(cmd_arg_t *argv)
680
{
680
{
681
    uintptr_t symaddr;
681
    uintptr_t symaddr;
682
    char *symbol;
682
    char *symbol;
683
    unative_t (*f)(unative_t,...);
683
    unative_t (*f)(unative_t,...);
684
    unative_t arg1 = argv[1].intval;
684
    unative_t arg1 = argv[1].intval;
685
#ifdef ia64
685
#ifdef ia64
686
    struct {
686
    struct {
687
        unative_t f;
687
        unative_t f;
688
        unative_t gp;
688
        unative_t gp;
689
    } fptr;
689
    } fptr;
690
#endif
690
#endif
691
 
691
 
692
    symaddr = get_symbol_addr((char *) argv->buffer);
692
    symaddr = get_symbol_addr((char *) argv->buffer);
693
    if (!symaddr)
693
    if (!symaddr)
694
        printf("Symbol %s not found.\n", argv->buffer);
694
        printf("Symbol %s not found.\n", argv->buffer);
695
    else if (symaddr == (uintptr_t) -1) {
695
    else if (symaddr == (uintptr_t) -1) {
696
        symtab_print_search((char *) argv->buffer);
696
        symtab_print_search((char *) argv->buffer);
697
        printf("Duplicate symbol, be more specific.\n");
697
        printf("Duplicate symbol, be more specific.\n");
698
    } else {
698
    } else {
699
        symbol = get_symtab_entry(symaddr);
699
        symbol = get_symtab_entry(symaddr);
700
 
700
 
701
        printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
701
        printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
702
#ifdef ia64
702
#ifdef ia64
703
        fptr.f = symaddr;
703
        fptr.f = symaddr;
704
        fptr.gp = ((unative_t *)cmd_call2)[1];
704
        fptr.gp = ((unative_t *)cmd_call2)[1];
705
        f =  (unative_t (*)(unative_t,...)) &fptr;
705
        f =  (unative_t (*)(unative_t,...)) &fptr;
706
#else
706
#else
707
        f =  (unative_t (*)(unative_t,...)) symaddr;
707
        f =  (unative_t (*)(unative_t,...)) symaddr;
708
#endif
708
#endif
709
        printf("Result: %#" PRIxn "\n", f(arg1));
709
        printf("Result: %#" PRIxn "\n", f(arg1));
710
    }
710
    }
711
   
711
   
712
    return 1;
712
    return 1;
713
}
713
}
714
 
714
 
715
/** Call function with two parameters */
715
/** Call function with two parameters */
716
int cmd_call2(cmd_arg_t *argv)
716
int cmd_call2(cmd_arg_t *argv)
717
{
717
{
718
    uintptr_t symaddr;
718
    uintptr_t symaddr;
719
    char *symbol;
719
    char *symbol;
720
    unative_t (*f)(unative_t,unative_t,...);
720
    unative_t (*f)(unative_t,unative_t,...);
721
    unative_t arg1 = argv[1].intval;
721
    unative_t arg1 = argv[1].intval;
722
    unative_t arg2 = argv[2].intval;
722
    unative_t arg2 = argv[2].intval;
723
#ifdef ia64
723
#ifdef ia64
724
    struct {
724
    struct {
725
        unative_t f;
725
        unative_t f;
726
        unative_t gp;
726
        unative_t gp;
727
    }fptr;
727
    }fptr;
728
#endif
728
#endif
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
        printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
738
        printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
739
               arg1, arg2, symaddr, symbol);
739
               arg1, arg2, symaddr, symbol);
740
#ifdef ia64
740
#ifdef ia64
741
        fptr.f = symaddr;
741
        fptr.f = symaddr;
742
        fptr.gp = ((unative_t *)cmd_call2)[1];
742
        fptr.gp = ((unative_t *)cmd_call2)[1];
743
        f =  (unative_t (*)(unative_t,unative_t,...)) &fptr;
743
        f =  (unative_t (*)(unative_t,unative_t,...)) &fptr;
744
#else
744
#else
745
        f =  (unative_t (*)(unative_t,unative_t,...)) symaddr;
745
        f =  (unative_t (*)(unative_t,unative_t,...)) symaddr;
746
#endif
746
#endif
747
        printf("Result: %#" PRIxn "\n", f(arg1, arg2));
747
        printf("Result: %#" PRIxn "\n", f(arg1, arg2));
748
    }
748
    }
749
   
749
   
750
    return 1;
750
    return 1;
751
}
751
}
752
 
752
 
753
/** Call function with three parameters */
753
/** Call function with three parameters */
754
int cmd_call3(cmd_arg_t *argv)
754
int cmd_call3(cmd_arg_t *argv)
755
{
755
{
756
    uintptr_t symaddr;
756
    uintptr_t symaddr;
757
    char *symbol;
757
    char *symbol;
758
    unative_t (*f)(unative_t,unative_t,unative_t,...);
758
    unative_t (*f)(unative_t,unative_t,unative_t,...);
759
    unative_t arg1 = argv[1].intval;
759
    unative_t arg1 = argv[1].intval;
760
    unative_t arg2 = argv[2].intval;
760
    unative_t arg2 = argv[2].intval;
761
    unative_t arg3 = argv[3].intval;
761
    unative_t arg3 = argv[3].intval;
762
#ifdef ia64
762
#ifdef ia64
763
    struct {
763
    struct {
764
        unative_t f;
764
        unative_t f;
765
        unative_t gp;
765
        unative_t gp;
766
    }fptr;
766
    }fptr;
767
#endif
767
#endif
768
 
768
 
769
    symaddr = get_symbol_addr((char *) argv->buffer);
769
    symaddr = get_symbol_addr((char *) argv->buffer);
770
    if (!symaddr)
770
    if (!symaddr)
771
        printf("Symbol %s not found.\n", argv->buffer);
771
        printf("Symbol %s not found.\n", argv->buffer);
772
    else if (symaddr == (uintptr_t) -1) {
772
    else if (symaddr == (uintptr_t) -1) {
773
        symtab_print_search((char *) argv->buffer);
773
        symtab_print_search((char *) argv->buffer);
774
        printf("Duplicate symbol, be more specific.\n");
774
        printf("Duplicate symbol, be more specific.\n");
775
    } else {
775
    } else {
776
        symbol = get_symtab_entry(symaddr);
776
        symbol = get_symtab_entry(symaddr);
777
        printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
777
        printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
778
               arg1, arg2, arg3, symaddr, symbol);
778
               arg1, arg2, arg3, symaddr, symbol);
779
#ifdef ia64
779
#ifdef ia64
780
        fptr.f = symaddr;
780
        fptr.f = symaddr;
781
        fptr.gp = ((unative_t *)cmd_call2)[1];
781
        fptr.gp = ((unative_t *)cmd_call2)[1];
782
        f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) &fptr;
782
        f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) &fptr;
783
#else
783
#else
784
        f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) symaddr;
784
        f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) symaddr;
785
#endif
785
#endif
786
        printf("Result: %#" PRIxn "\n", f(arg1, arg2, arg3));
786
        printf("Result: %#" PRIxn "\n", f(arg1, arg2, arg3));
787
    }
787
    }
788
   
788
   
789
    return 1;
789
    return 1;
790
}
790
}
791
 
791
 
792
 
792
 
793
/** Print detailed description of 'describe' command. */
793
/** Print detailed description of 'describe' command. */
794
void desc_help(void)
794
void desc_help(void)
795
{
795
{
796
    printf("Syntax: describe command_name\n");
796
    printf("Syntax: describe command_name\n");
797
}
797
}
798
 
798
 
799
/** Halt the kernel.
799
/** Halt the kernel.
800
 *
800
 *
801
 * @param argv Argument vector (ignored).
801
 * @param argv Argument vector (ignored).
802
 *
802
 *
803
 * @return 0 on failure, 1 on success (never returns).
803
 * @return 0 on failure, 1 on success (never returns).
804
 */
804
 */
805
int cmd_halt(cmd_arg_t *argv)
805
int cmd_halt(cmd_arg_t *argv)
806
{
806
{
807
    halt();
807
    halt();
808
    return 1;
808
    return 1;
809
}
809
}
810
 
810
 
811
/** Command for printing TLB contents.
811
/** Command for printing TLB contents.
812
 *
812
 *
813
 * @param argv Not used.
813
 * @param argv Not used.
814
 *
814
 *
815
 * @return Always returns 1.
815
 * @return Always returns 1.
816
 */
816
 */
817
int cmd_tlb(cmd_arg_t *argv)
817
int cmd_tlb(cmd_arg_t *argv)
818
{
818
{
819
    tlb_print();
819
    tlb_print();
820
    return 1;
820
    return 1;
821
}
821
}
822
 
822
 
823
/** Command for printing physical memory configuration.
823
/** Command for printing physical memory configuration.
824
 *
824
 *
825
 * @param argv Not used.
825
 * @param argv Not used.
826
 *
826
 *
827
 * @return Always returns 1.
827
 * @return Always returns 1.
828
 */
828
 */
829
int cmd_physmem(cmd_arg_t *argv)
829
int cmd_physmem(cmd_arg_t *argv)
830
{
830
{
831
    physmem_print();
831
    physmem_print();
832
    return 1;
832
    return 1;
833
}
833
}
834
 
834
 
835
/** Write 4 byte value to address */
835
/** Write 4 byte value to address */
836
int cmd_set4(cmd_arg_t *argv)
836
int cmd_set4(cmd_arg_t *argv)
837
{
837
{
838
    uint32_t *addr;
838
    uint32_t *addr;
839
    uint32_t arg1 = argv[1].intval;
839
    uint32_t arg1 = argv[1].intval;
840
    bool pointer = false;
840
    bool pointer = false;
841
 
841
 
842
    if (((char *)argv->buffer)[0] == '*') {
842
    if (((char *)argv->buffer)[0] == '*') {
843
        addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);
843
        addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);
844
        pointer = true;
844
        pointer = true;
845
    } else if (((char *) argv->buffer)[0] >= '0' &&
845
    } else if (((char *) argv->buffer)[0] >= '0' &&
846
           ((char *)argv->buffer)[0] <= '9')
846
           ((char *)argv->buffer)[0] <= '9')
847
        addr = (uint32_t *)atoi((char *)argv->buffer);
847
        addr = (uint32_t *)atoi((char *)argv->buffer);
848
    else
848
    else
849
        addr = (uint32_t *)get_symbol_addr((char *) argv->buffer);
849
        addr = (uint32_t *)get_symbol_addr((char *) argv->buffer);
850
 
850
 
851
    if (!addr)
851
    if (!addr)
852
        printf("Symbol %s not found.\n", argv->buffer);
852
        printf("Symbol %s not found.\n", argv->buffer);
853
    else if (addr == (uint32_t *) -1) {
853
    else if (addr == (uint32_t *) -1) {
854
        symtab_print_search((char *) argv->buffer);
854
        symtab_print_search((char *) argv->buffer);
855
        printf("Duplicate symbol, be more specific.\n");
855
        printf("Duplicate symbol, be more specific.\n");
856
    } else {
856
    } else {
857
        if (pointer)
857
        if (pointer)
858
            addr = (uint32_t *)(*(unative_t *)addr);
858
            addr = (uint32_t *)(*(unative_t *)addr);
859
        printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
859
        printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
860
        *addr = arg1;
860
        *addr = arg1;
861
       
861
       
862
    }
862
    }
863
   
863
   
864
    return 1;
864
    return 1;
865
}
865
}
866
 
866
 
867
/** Command for listings SLAB caches
867
/** Command for listings SLAB caches
868
 *
868
 *
869
 * @param argv Ignores
869
 * @param argv Ignores
870
 *
870
 *
871
 * @return Always 1
871
 * @return Always 1
872
 */
872
 */
873
int cmd_slabs(cmd_arg_t * argv) {
873
int cmd_slabs(cmd_arg_t * argv) {
874
    slab_print_list();
874
    slab_print_list();
875
    return 1;
875
    return 1;
876
}
876
}
877
 
877
 
878
 
878
 
879
/** Command for listings Thread information
879
/** Command for listings Thread information
880
 *
880
 *
881
 * @param argv Ignores
881
 * @param argv Ignores
882
 *
882
 *
883
 * @return Always 1
883
 * @return Always 1
884
 */
884
 */
885
int cmd_threads(cmd_arg_t * argv) {
885
int cmd_threads(cmd_arg_t * argv) {
886
    thread_print_list();
886
    thread_print_list();
887
    return 1;
887
    return 1;
888
}
888
}
889
 
889
 
890
/** Command for listings Task information
890
/** Command for listings Task information
891
 *
891
 *
892
 * @param argv Ignores
892
 * @param argv Ignores
893
 *
893
 *
894
 * @return Always 1
894
 * @return Always 1
895
 */
895
 */
896
int cmd_tasks(cmd_arg_t * argv) {
896
int cmd_tasks(cmd_arg_t * argv) {
897
    task_print_list();
897
    task_print_list();
898
    return 1;
898
    return 1;
899
}
899
}
900
 
900
 
901
/** Command for listings Thread information
901
/** Command for listings Thread information
902
 *
902
 *
903
 * @param argv Ignores
903
 * @param argv Ignores
904
 *
904
 *
905
 * @return Always 1
905
 * @return Always 1
906
 */
906
 */
907
int cmd_sched(cmd_arg_t * argv) {
907
int cmd_sched(cmd_arg_t * argv) {
908
    sched_print_list();
908
    sched_print_list();
909
    return 1;
909
    return 1;
910
}
910
}
911
 
911
 
912
/** Command for listing memory zones
912
/** Command for listing memory zones
913
 *
913
 *
914
 * @param argv Ignored
914
 * @param argv Ignored
915
 *
915
 *
916
 * return Always 1
916
 * return Always 1
917
 */
917
 */
918
int cmd_zones(cmd_arg_t * argv) {
918
int cmd_zones(cmd_arg_t * argv) {
919
    zone_print_list();
919
    zone_print_list();
920
    return 1;
920
    return 1;
921
}
921
}
922
 
922
 
923
/** Command for memory zone details
923
/** Command for memory zone details
924
 *
924
 *
925
 * @param argv Integer argument from cmdline expected
925
 * @param argv Integer argument from cmdline expected
926
 *
926
 *
927
 * return Always 1
927
 * return Always 1
928
 */
928
 */
929
int cmd_zone(cmd_arg_t * argv) {
929
int cmd_zone(cmd_arg_t * argv) {
930
    zone_print_one(argv[0].intval);
930
    zone_print_one(argv[0].intval);
931
    return 1;
931
    return 1;
932
}
932
}
933
 
933
 
934
/** Command for printing task ipc details
934
/** Command for printing task ipc details
935
 *
935
 *
936
 * @param argv Integer argument from cmdline expected
936
 * @param argv Integer argument from cmdline expected
937
 *
937
 *
938
 * return Always 1
938
 * return Always 1
939
 */
939
 */
940
int cmd_ipc(cmd_arg_t * argv) {
940
int cmd_ipc(cmd_arg_t * argv) {
941
    ipc_print_task(argv[0].intval);
941
    ipc_print_task(argv[0].intval);
942
    return 1;
942
    return 1;
943
}
943
}
944
 
944
 
945
 
945
 
946
/** Command for listing processors.
946
/** Command for listing processors.
947
 *
947
 *
948
 * @param argv Ignored.
948
 * @param argv Ignored.
949
 *
949
 *
950
 * return Always 1.
950
 * return Always 1.
951
 */
951
 */
952
int cmd_cpus(cmd_arg_t *argv)
952
int cmd_cpus(cmd_arg_t *argv)
953
{
953
{
954
    cpu_list();
954
    cpu_list();
955
    return 1;
955
    return 1;
956
}
956
}
957
 
957
 
958
/** Command for printing kernel version.
958
/** Command for printing kernel version.
959
 *
959
 *
960
 * @param argv Ignored.
960
 * @param argv Ignored.
961
 *
961
 *
962
 * return Always 1.
962
 * return Always 1.
963
 */
963
 */
964
int cmd_version(cmd_arg_t *argv)
964
int cmd_version(cmd_arg_t *argv)
965
{
965
{
966
    version_print();
966
    version_print();
967
    return 1;
967
    return 1;
968
}
968
}
969
 
969
 
970
/** Command for returning console back to userspace.
970
/** Command for returning console back to userspace.
971
 *
971
 *
972
 * @param argv Ignored.
972
 * @param argv Ignored.
973
 *
973
 *
974
 * return Always 1.
974
 * return Always 1.
975
 */
975
 */
976
int cmd_continue(cmd_arg_t *argv)
976
int cmd_continue(cmd_arg_t *argv)
977
{
977
{
978
    printf("The kernel will now relinquish the console.\n");
978
    printf("The kernel will now relinquish the console.\n");
979
    printf("Use userspace controls to redraw the screen.\n");
979
    printf("Use userspace controls to redraw the screen.\n");
980
    arch_release_console();
980
    arch_release_console();
981
    return 1;
981
    return 1;
982
}
982
}
983
 
983
 
984
#ifdef CONFIG_TEST
984
#ifdef CONFIG_TEST
985
/** Command for printing kernel tests list.
985
/** Command for printing kernel tests list.
986
 *
986
 *
987
 * @param argv Ignored.
987
 * @param argv Ignored.
988
 *
988
 *
989
 * return Always 1.
989
 * return Always 1.
990
 */
990
 */
991
int cmd_tests(cmd_arg_t *argv)
991
int cmd_tests(cmd_arg_t *argv)
992
{
992
{
993
    test_t *test;
993
    test_t *test;
994
   
994
   
995
    for (test = tests; test->name != NULL; test++)
995
    for (test = tests; test->name != NULL; test++)
996
        printf("%s\t\t%s%s\n", test->name, test->desc, (test->safe ? "" : " (unsafe)"));
996
        printf("%s\t\t%s%s\n", test->name, test->desc, (test->safe ? "" : " (unsafe)"));
997
   
997
   
998
    printf("*\t\tRun all safe tests\n");
998
    printf("*\t\tRun all safe tests\n");
999
    return 1;
999
    return 1;
1000
}
1000
}
1001
 
1001
 
1002
static bool run_test(const test_t *test)
1002
static bool run_test(const test_t *test)
1003
{
1003
{
1004
    printf("%s\t\t%s\n", test->name, test->desc);
1004
    printf("%s\t\t%s\n", test->name, test->desc);
1005
   
1005
   
1006
    /* Update and read thread accounting
1006
    /* Update and read thread accounting
1007
       for benchmarking */
1007
       for benchmarking */
1008
    ipl_t ipl = interrupts_disable();
1008
    ipl_t ipl = interrupts_disable();
1009
    spinlock_lock(&TASK->lock);
1009
    spinlock_lock(&TASK->lock);
1010
    uint64_t t0 = task_get_accounting(TASK);
1010
    uint64_t t0 = task_get_accounting(TASK);
1011
    spinlock_unlock(&TASK->lock);
1011
    spinlock_unlock(&TASK->lock);
1012
    interrupts_restore(ipl);
1012
    interrupts_restore(ipl);
1013
   
1013
   
1014
    /* Execute the test */
1014
    /* Execute the test */
1015
    char * ret = test->entry(false);
1015
    char * ret = test->entry(false);
1016
   
1016
   
1017
    /* Update and read thread accounting */
1017
    /* Update and read thread accounting */
1018
    ipl = interrupts_disable();
1018
    ipl = interrupts_disable();
1019
    spinlock_lock(&TASK->lock);
1019
    spinlock_lock(&TASK->lock);
1020
    uint64_t dt = task_get_accounting(TASK) - t0;
1020
    uint64_t dt = task_get_accounting(TASK) - t0;
1021
    spinlock_unlock(&TASK->lock);
1021
    spinlock_unlock(&TASK->lock);
1022
    interrupts_restore(ipl);
1022
    interrupts_restore(ipl);
1023
   
1023
   
1024
    uint64_t cycles;
1024
    uint64_t cycles;
1025
    char suffix;
1025
    char suffix;
1026
    order(dt, &cycles, &suffix);
1026
    order(dt, &cycles, &suffix);
1027
       
1027
       
1028
    printf("Time: %" PRIu64 "%c cycles\n", cycles, suffix);
1028
    printf("Time: %" PRIu64 "%c cycles\n", cycles, suffix);
1029
   
1029
   
1030
    if (ret == NULL) {
1030
    if (ret == NULL) {
1031
        printf("Test passed\n");
1031
        printf("Test passed\n");
1032
        return true;
1032
        return true;
1033
    }
1033
    }
1034
 
1034
 
1035
    printf("%s\n", ret);
1035
    printf("%s\n", ret);
1036
    return false;
1036
    return false;
1037
}
1037
}
1038
 
1038
 
1039
static bool run_bench(const test_t *test, const uint32_t cnt)
1039
static bool run_bench(const test_t *test, const uint32_t cnt)
1040
{
1040
{
1041
    uint32_t i;
1041
    uint32_t i;
1042
    bool ret = true;
1042
    bool ret = true;
1043
    uint64_t cycles;
1043
    uint64_t cycles;
1044
    char suffix;
1044
    char suffix;
1045
   
1045
   
1046
    if (cnt < 1)
1046
    if (cnt < 1)
1047
        return true;
1047
        return true;
1048
   
1048
   
1049
    uint64_t *data = (uint64_t *) malloc(sizeof(uint64_t) * cnt, 0);
1049
    uint64_t *data = (uint64_t *) malloc(sizeof(uint64_t) * cnt, 0);
1050
    if (data == NULL) {
1050
    if (data == NULL) {
1051
        printf("Error allocating memory for statistics\n");
1051
        printf("Error allocating memory for statistics\n");
1052
        return false;
1052
        return false;
1053
    }
1053
    }
1054
   
1054
   
1055
    for (i = 0; i < cnt; i++) {
1055
    for (i = 0; i < cnt; i++) {
1056
        printf("%s (%u/%u) ... ", test->name, i + 1, cnt);
1056
        printf("%s (%u/%u) ... ", test->name, i + 1, cnt);
1057
       
1057
       
1058
        /* Update and read thread accounting
1058
        /* Update and read thread accounting
1059
           for benchmarking */
1059
           for benchmarking */
1060
        ipl_t ipl = interrupts_disable();
1060
        ipl_t ipl = interrupts_disable();
1061
        spinlock_lock(&TASK->lock);
1061
        spinlock_lock(&TASK->lock);
1062
        uint64_t t0 = task_get_accounting(TASK);
1062
        uint64_t t0 = task_get_accounting(TASK);
1063
        spinlock_unlock(&TASK->lock);
1063
        spinlock_unlock(&TASK->lock);
1064
        interrupts_restore(ipl);
1064
        interrupts_restore(ipl);
1065
       
1065
       
1066
        /* Execute the test */
1066
        /* Execute the test */
1067
        char * ret = test->entry(true);
1067
        char * ret = test->entry(true);
1068
       
1068
       
1069
        /* Update and read thread accounting */
1069
        /* Update and read thread accounting */
1070
        ipl = interrupts_disable();
1070
        ipl = interrupts_disable();
1071
        spinlock_lock(&TASK->lock);
1071
        spinlock_lock(&TASK->lock);
1072
        uint64_t dt = task_get_accounting(TASK) - t0;
1072
        uint64_t dt = task_get_accounting(TASK) - t0;
1073
        spinlock_unlock(&TASK->lock);
1073
        spinlock_unlock(&TASK->lock);
1074
        interrupts_restore(ipl);
1074
        interrupts_restore(ipl);
1075
       
1075
       
1076
        if (ret != NULL) {
1076
        if (ret != NULL) {
1077
            printf("%s\n", ret);
1077
            printf("%s\n", ret);
1078
            ret = false;
1078
            ret = false;
1079
            break;
1079
            break;
1080
        }
1080
        }
1081
       
1081
       
1082
        data[i] = dt;
1082
        data[i] = dt;
1083
        order(dt, &cycles, &suffix);
1083
        order(dt, &cycles, &suffix);
1084
        printf("OK (%" PRIu64 "%c cycles)\n", cycles, suffix);
1084
        printf("OK (%" PRIu64 "%c cycles)\n", cycles, suffix);
1085
    }
1085
    }
1086
   
1086
   
1087
    if (ret) {
1087
    if (ret) {
1088
        printf("\n");
1088
        printf("\n");
1089
       
1089
       
1090
        uint64_t sum = 0;
1090
        uint64_t sum = 0;
1091
       
1091
       
1092
        for (i = 0; i < cnt; i++) {
1092
        for (i = 0; i < cnt; i++) {
1093
            sum += data[i];
1093
            sum += data[i];
1094
        }
1094
        }
1095
       
1095
       
1096
        order(sum / (uint64_t) cnt, &cycles, &suffix);
1096
        order(sum / (uint64_t) cnt, &cycles, &suffix);
1097
        printf("Average\t\t%" PRIu64 "%c\n", cycles, suffix);
1097
        printf("Average\t\t%" PRIu64 "%c\n", cycles, suffix);
1098
    }
1098
    }
1099
   
1099
   
1100
    free(data);
1100
    free(data);
1101
   
1101
   
1102
    return ret;
1102
    return ret;
1103
}
1103
}
1104
 
1104
 
1105
/** Command for returning kernel tests
1105
/** Command for returning kernel tests
1106
 *
1106
 *
1107
 * @param argv Argument vector.
1107
 * @param argv Argument vector.
1108
 *
1108
 *
1109
 * return Always 1.
1109
 * return Always 1.
1110
 */
1110
 */
1111
int cmd_test(cmd_arg_t *argv)
1111
int cmd_test(cmd_arg_t *argv)
1112
{
1112
{
1113
    test_t *test;
1113
    test_t *test;
1114
   
1114
   
1115
    if (strcmp((char *) argv->buffer, "*") == 0) {
1115
    if (strcmp((char *) argv->buffer, "*") == 0) {
1116
        for (test = tests; test->name != NULL; test++) {
1116
        for (test = tests; test->name != NULL; test++) {
1117
            if (test->safe) {
1117
            if (test->safe) {
1118
                printf("\n");
1118
                printf("\n");
1119
                if (!run_test(test))
1119
                if (!run_test(test))
1120
                    break;
1120
                    break;
1121
            }
1121
            }
1122
        }
1122
        }
1123
    } else {
1123
    } else {
1124
        bool fnd = false;
1124
        bool fnd = false;
1125
       
1125
       
1126
        for (test = tests; test->name != NULL; test++) {
1126
        for (test = tests; test->name != NULL; test++) {
1127
            if (strcmp(test->name, (char *) argv->buffer) == 0) {
1127
            if (strcmp(test->name, (char *) argv->buffer) == 0) {
1128
                fnd = true;
1128
                fnd = true;
1129
                run_test(test);
1129
                run_test(test);
1130
                break;
1130
                break;
1131
            }
1131
            }
1132
        }
1132
        }
1133
       
1133
       
1134
        if (!fnd)
1134
        if (!fnd)
1135
            printf("Unknown test\n");
1135
            printf("Unknown test\n");
1136
    }
1136
    }
1137
   
1137
   
1138
    return 1;
1138
    return 1;
1139
}
1139
}
1140
 
1140
 
1141
/** Command for returning kernel tests as benchmarks
1141
/** Command for returning kernel tests as benchmarks
1142
 *
1142
 *
1143
 * @param argv Argument vector.
1143
 * @param argv Argument vector.
1144
 *
1144
 *
1145
 * return Always 1.
1145
 * return Always 1.
1146
 */
1146
 */
1147
int cmd_bench(cmd_arg_t *argv)
1147
int cmd_bench(cmd_arg_t *argv)
1148
{
1148
{
1149
    test_t *test;
1149
    test_t *test;
1150
    uint32_t cnt = argv[1].intval;
1150
    uint32_t cnt = argv[1].intval;
1151
   
1151
   
1152
    bool fnd = false;
1152
    bool fnd = false;
1153
   
1153
   
1154
    for (test = tests; test->name != NULL; test++) {
1154
    for (test = tests; test->name != NULL; test++) {
1155
        if (strcmp(test->name, (char *) argv->buffer) == 0) {
1155
        if (strcmp(test->name, (char *) argv->buffer) == 0) {
1156
            fnd = true;
1156
            fnd = true;
1157
           
1157
           
1158
            if (test->safe)
1158
            if (test->safe)
1159
                run_bench(test, cnt);
1159
                run_bench(test, cnt);
1160
            else
1160
            else
1161
                printf("Unsafe test\n");
1161
                printf("Unsafe test\n");
1162
           
1162
           
1163
            break;
1163
            break;
1164
        }
1164
        }
1165
    }
1165
    }
1166
       
1166
       
1167
    if (!fnd)
1167
    if (!fnd)
1168
        printf("Unknown test\n");
1168
        printf("Unknown test\n");
1169
 
1169
 
1170
    return 1;
1170
    return 1;
1171
}
1171
}
1172
 
1172
 
1173
#endif
1173
#endif
1174
 
1174
 
1175
/** @}
1175
/** @}
1176
 */
1176
 */
1177
 
1177