Subversion Repositories HelenOS-historic

Rev

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

Rev 1465 Rev 1486
1
/*
1
/*
2
 * Copyright (C) 2005 Martin Decky
2
 * Copyright (C) 2005 Martin Decky
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
#include "version.h"
29
#include "version.h"
30
#include <ipc/ipc.h>
30
#include <ipc/ipc.h>
31
#include <ipc/services.h>
31
#include <ipc/services.h>
32
#include <ipc/ns.h>
32
#include <ipc/ns.h>
33
#include <stdio.h>
33
#include <stdio.h>
34
#include <unistd.h>
34
#include <unistd.h>
35
#include <stdlib.h>
35
#include <stdlib.h>
36
#include <thread.h>
36
#include <thread.h>
37
#include <task.h>
37
#include <task.h>
38
#include <psthread.h>
38
#include <psthread.h>
39
#include <futex.h>
39
#include <futex.h>
40
#include <as.h>
40
#include <as.h>
41
#include <ddi.h>
41
#include <ddi.h>
42
#include <string.h>
42
#include <string.h>
43
#include <errno.h>
43
#include <errno.h>
44
#include <kbd.h>
44
#include <kbd.h>
45
#include <ipc/fb.h>
45
#include <ipc/fb.h>
46
#include <async.h>
46
#include <async.h>
47
#include <sys/time.h>
47
#include <sys/time.h>
48
 
48
 
49
int a;
49
int a;
50
atomic_t ftx;
50
atomic_t ftx;
51
 
51
 
52
int __thread stage;
52
int __thread stage;
53
 
53
 
54
extern void utest(void *arg);
54
extern void utest(void *arg);
55
void utest(void *arg)
55
void utest(void *arg)
56
{
56
{
57
    printf("Uspace thread started.\n");
57
    printf("Uspace thread started.\n");
58
    if (futex_down(&ftx) < 0)
58
    if (futex_down(&ftx) < 0)
59
        printf("Futex failed.\n");
59
        printf("Futex failed.\n");
60
    if (futex_up(&ftx) < 0)
60
    if (futex_up(&ftx) < 0)
61
        printf("Futex failed.\n");
61
        printf("Futex failed.\n");
62
       
62
       
63
    printf("%s in good condition.\n", __FUNCTION__);
63
    printf("%s in good condition.\n", __FUNCTION__);
64
   
64
   
65
    for (;;)
65
    for (;;)
66
        ;
66
        ;
67
}
67
}
68
 
68
 
69
/* test different parameters types and modifiers */
69
/* test different parameters types and modifiers */
70
static void test_printf(void)
70
static void test_printf(void)
71
{
71
{
72
    printf("Simple text.\n");
72
    printf("Simple text.\n");
73
    printf("Now insert '%s' string.\n","this");
73
    printf("Now insert '%s' string.\n","this");
74
    printf("Signed formats on uns. numbers: '%d', '%+d', '% d', '%u' (,+, ,u)\n", 321, 321, 321, 321);
74
    printf("Signed formats on uns. numbers: '%d', '%+d', '% d', '%u' (,+, ,u)\n", 321, 321, 321, 321);
75
    printf("Signed formats on sig. numbers: '%d', '%+d', '% d', '%u' (,+, ,u)\n", -321, -321, -321, -321);
75
    printf("Signed formats on sig. numbers: '%d', '%+d', '% d', '%u' (,+, ,u)\n", -321, -321, -321, -321);
76
    printf("Signed with different sized: '%hhd', '%hd', '%d', '%ld', %lld;\n", -3, -32, -321, -32101l, -3210123ll);
76
    printf("Signed with different sized: '%hhd', '%hd', '%d', '%ld', %lld;\n", -3, -32, -321, -32101l, -3210123ll);
77
    printf("And now... '%hhd' byte! '%hd' word! '%d' int! \n", 11, 11111, 1111111111);
77
    printf("And now... '%hhd' byte! '%hd' word! '%d' int! \n", 11, 11111, 1111111111);
78
    printf("Different bases: %#hx, %#hu, %#ho and %#hb\n", 123, 123, 123, 123);
78
    printf("Different bases: %#hx, %#hu, %#ho and %#hb\n", 123, 123, 123, 123);
79
    printf("Different bases signed: %#hx, %#hu, %#ho and %#hb\n", -123, -123, -123, -123);
79
    printf("Different bases signed: %#hx, %#hu, %#ho and %#hb\n", -123, -123, -123, -123);
80
    printf("'%llX' llX! Another '%llx' llx! \n", 0x1234567887654321ll, 0x1234567887654321ll);
80
    printf("'%llX' llX! Another '%llx' llx! \n", 0x1234567887654321ll, 0x1234567887654321ll);
81
    printf("'%llX' with 64bit value and '%x' with 32 bit value. \n", 0x1234567887654321ll, 0x12345678 );
81
    printf("'%llX' with 64bit value and '%x' with 32 bit value. \n", 0x1234567887654321ll, 0x12345678 );
82
    printf("'%llx' 64bit, '%x' 32bit, '%hhx' 8bit, '%hx' 16bit, '%llX' 64bit and '%s' string.\n", 0x1234567887654321ll, 0x12345678, 0x12, 0x1234, 0x1234567887654321ull, "Lovely string" );
82
    printf("'%llx' 64bit, '%x' 32bit, '%hhx' 8bit, '%hx' 16bit, '%llX' 64bit and '%s' string.\n", 0x1234567887654321ll, 0x12345678, 0x12, 0x1234, 0x1234567887654321ull, "Lovely string" );
83
   
83
   
84
    printf("Thats all, folks!\n");
84
    printf("Thats all, folks!\n");
85
}
85
}
86
 
86
 
87
/* test width and precision modifiers */
87
/* test width and precision modifiers */
88
static void test_printf2(void)
88
static void test_printf2(void)
89
{
89
{
90
    printf(" text 10.8s %*.*s \n", 5, 3, "text");
90
    printf(" text 10.8s %*.*s \n", 5, 3, "text");
91
    printf(" very long text 10.8s %10.8s \n", "very long text");
91
    printf(" very long text 10.8s %10.8s \n", "very long text");
92
    printf(" text 8.10s %8.10s \n", "text");
92
    printf(" text 8.10s %8.10s \n", "text");
93
    printf(" very long text 8.10s %8.10s \n", "very long text");
93
    printf(" very long text 8.10s %8.10s \n", "very long text");
94
 
94
 
95
    printf(" char: c '%c', 3.2c '%3.2c', -3.2c '%-3.2c', 2.3c '%2.3c', -2.3c '%-2.3c' \n",'a', 'b', 'c', 'd', 'e' );
95
    printf(" char: c '%c', 3.2c '%3.2c', -3.2c '%-3.2c', 2.3c '%2.3c', -2.3c '%-2.3c' \n",'a', 'b', 'c', 'd', 'e' );
96
    printf(" int: d '%d', 3.2d '%3.2d', -3.2d '%-3.2d', 2.3d '%2.3d', -2.3d '%-2.3d' \n",1, 1, 1, 1, 1 );
96
    printf(" int: d '%d', 3.2d '%3.2d', -3.2d '%-3.2d', 2.3d '%2.3d', -2.3d '%-2.3d' \n",1, 1, 1, 1, 1 );
97
    printf(" -int: d '%d', 3.2d '%3.2d', -3.2d '%-3.2d', 2.3d '%2.3d', -2.3d '%-2.3d' \n",-1, -1, -1, -1, -1 );
97
    printf(" -int: d '%d', 3.2d '%3.2d', -3.2d '%-3.2d', 2.3d '%2.3d', -2.3d '%-2.3d' \n",-1, -1, -1, -1, -1 );
98
    printf(" 0xint: x '%x', 5.3x '%#5.3x', -5.3x '%#-5.3x', 3.5x '%#3.5x', -3.5x '%#-3.5x' \n",17, 17, 17, 17, 17 );
98
    printf(" 0xint: x '%x', 5.3x '%#5.3x', -5.3x '%#-5.3x', 3.5x '%#3.5x', -3.5x '%#-3.5x' \n",17, 17, 17, 17, 17 );
99
 
99
 
100
}
100
}
101
 
101
 
102
extern char _heap;
102
extern char _heap;
103
static void test_mremap(void)
103
static void test_mremap(void)
104
{
104
{
105
    printf("Writing to good memory\n");
105
    printf("Writing to good memory\n");
106
    as_area_resize(&_heap, 120000, 0);
106
    as_area_resize(&_heap, 120000, 0);
107
    printf("%P\n", ((char *)&_heap));
107
    printf("%P\n", ((char *)&_heap));
108
    printf("%P\n", ((char *)&_heap) + 80000);
108
    printf("%P\n", ((char *)&_heap) + 80000);
109
    *(((char *)&_heap) + 80000) = 10;
109
    *(((char *)&_heap) + 80000) = 10;
110
    printf("Making small\n");
110
    printf("Making small\n");
111
    as_area_resize(&_heap, 16000, 0);
111
    as_area_resize(&_heap, 16000, 0);
112
    printf("Failing..\n");
112
    printf("Failing..\n");
113
    *((&_heap) + 80000) = 10;
113
    *((&_heap) + 80000) = 10;
114
 
114
 
115
    printf("memory done\n");
115
    printf("memory done\n");
116
}
116
}
117
/*
117
/*
118
static void test_sbrk(void)
118
static void test_sbrk(void)
119
{
119
{
120
    printf("Writing to good memory\n");
120
    printf("Writing to good memory\n");
121
    printf("Got: %P\n", sbrk(120000));
121
    printf("Got: %P\n", sbrk(120000));
122
    printf("%P\n", ((char *)&_heap));
122
    printf("%P\n", ((char *)&_heap));
123
    printf("%P\n", ((char *)&_heap) + 80000);
123
    printf("%P\n", ((char *)&_heap) + 80000);
124
    *(((char *)&_heap) + 80000) = 10;
124
    *(((char *)&_heap) + 80000) = 10;
125
    printf("Making small, got: %P\n",sbrk(-120000));
125
    printf("Making small, got: %P\n",sbrk(-120000));
126
    printf("Testing access to heap\n");
126
    printf("Testing access to heap\n");
127
    _heap = 10;
127
    _heap = 10;
128
    printf("Failing..\n");
128
    printf("Failing..\n");
129
    *((&_heap) + 80000) = 10;
129
    *((&_heap) + 80000) = 10;
130
 
130
 
131
    printf("memory done\n");
131
    printf("memory done\n");
132
}
132
}
133
*/
133
*/
134
/*
134
/*
135
static void test_malloc(void)
135
static void test_malloc(void)
136
{
136
{
137
    char *data;
137
    char *data;
138
 
138
 
139
    data = malloc(10);
139
    data = malloc(10);
140
    printf("Heap: %P, data: %P\n", &_heap, data);
140
    printf("Heap: %P, data: %P\n", &_heap, data);
141
    data[0] = 'a';
141
    data[0] = 'a';
142
    free(data);
142
    free(data);
143
}
143
}
144
*/
144
*/
145
 
145
 
146
 
146
 
147
static void test_ping(void)
147
static void test_ping(void)
148
{
148
{
149
    ipcarg_t result;
149
    ipcarg_t result;
150
    int retval;
150
    int retval;
151
 
151
 
152
    printf("Pinging\n");
152
    printf("Pinging\n");
153
    retval = ipc_call_sync(PHONE_NS, NS_PING, 0xbeef,&result);
153
    retval = ipc_call_sync(PHONE_NS, NS_PING, 0xbeef,&result);
154
    printf("Retval: %d - received: %P\n", retval, result);
154
    printf("Retval: %d - received: %P\n", retval, result);
155
}
155
}
156
 
156
 
157
static void got_answer(void *private, int retval, ipc_call_t *data)
157
static void got_answer(void *private, int retval, ipc_call_t *data)
158
{
158
{
159
    printf("Retval: %d...%s...%zX, %zX\n", retval, private,
159
    printf("Retval: %d...%s...%zX, %zX\n", retval, private,
160
           IPC_GET_ARG1(*data), IPC_GET_ARG2(*data));
160
           IPC_GET_ARG1(*data), IPC_GET_ARG2(*data));
161
}
161
}
162
static void test_async_ipc(void)
162
static void test_async_ipc(void)
163
{
163
{
164
    ipc_call_t data;
164
    ipc_call_t data;
165
    int i;
165
    int i;
166
 
166
 
167
    printf("Sending ping\n");
167
    printf("Sending ping\n");
168
    ipc_call_async_2(PHONE_NS, NS_PING, 1, 0xbeefbee2,
168
    ipc_call_async_2(PHONE_NS, NS_PING, 1, 0xbeefbee2,
169
             "Pong1", got_answer);
169
             "Pong1", got_answer);
170
    ipc_call_async_2(PHONE_NS, NS_PING, 2, 0xbeefbee4,
170
    ipc_call_async_2(PHONE_NS, NS_PING, 2, 0xbeefbee4,
171
             "Pong2", got_answer);
171
             "Pong2", got_answer);
172
    ipc_call_async_2(PHONE_NS, NS_PING, 3, 0xbeefbee4,
172
    ipc_call_async_2(PHONE_NS, NS_PING, 3, 0xbeefbee4,
173
             "Pong3", got_answer);
173
             "Pong3", got_answer);
174
    ipc_call_async_2(PHONE_NS, NS_PING, 4, 0xbeefbee4,
174
    ipc_call_async_2(PHONE_NS, NS_PING, 4, 0xbeefbee4,
175
             "Pong4", got_answer);
175
             "Pong4", got_answer);
176
    ipc_call_async_2(PHONE_NS, NS_PING, 5, 0xbeefbee4,
176
    ipc_call_async_2(PHONE_NS, NS_PING, 5, 0xbeefbee4,
177
             "Pong5", got_answer);
177
             "Pong5", got_answer);
178
    ipc_call_async_2(PHONE_NS, NS_PING, 6, 0xbeefbee4,
178
    ipc_call_async_2(PHONE_NS, NS_PING, 6, 0xbeefbee4,
179
             "Pong6", got_answer);
179
             "Pong6", got_answer);
180
    printf("Waiting forever...\n");
180
    printf("Waiting forever...\n");
181
    for (i=0; i<100;i++)
181
    for (i=0; i<100;i++)
182
        printf(".");
182
        printf(".");
183
    printf("\n");
183
    printf("\n");
184
    ipc_wait_for_call(&data);
184
    ipc_wait_for_call(&data);
185
    printf("Received call???\n");
185
    printf("Received call???\n");
186
}
186
}
187
 
187
 
188
 
188
 
189
static void got_answer_2(void *private, int retval, ipc_call_t *data)
189
static void got_answer_2(void *private, int retval, ipc_call_t *data)
190
{
190
{
191
    printf("Pong\n");
191
    printf("Pong\n");
192
}
192
}
193
static void test_advanced_ipc(void)
193
static void test_advanced_ipc(void)
194
{
194
{
195
    int res;
195
    int res;
196
    ipcarg_t phonead;
196
    ipcarg_t phonead;
197
    ipc_callid_t callid;
197
    ipc_callid_t callid;
198
    ipc_call_t data;
198
    ipc_call_t data;
199
    int i;
199
    int i;
200
 
200
 
201
    printf("Asking 0 to connect to me...\n");
201
    printf("Asking 0 to connect to me...\n");
202
    res = ipc_connect_to_me(0, 1, 2, &phonead);
202
    res = ipc_connect_to_me(0, 1, 2, &phonead);
203
    printf("Result: %d - phonead: %llu\n", res, phonead);
203
    printf("Result: %d - phonead: %llu\n", res, phonead);
204
    for (i=0; i < 100; i++) {
204
    for (i=0; i < 100; i++) {
205
        printf("----------------\n");
205
        printf("----------------\n");
206
        ipc_call_async(PHONE_NS, NS_PING_SVC, 0, "prov",
206
        ipc_call_async(PHONE_NS, NS_PING_SVC, 0, "prov",
207
                   got_answer_2);
207
                   got_answer_2);
208
        callid = ipc_wait_for_call(&data);
208
        callid = ipc_wait_for_call(&data);
209
        printf("Received ping\n");
209
        printf("Received ping\n");
210
        ipc_answer_fast(callid, 0, 0, 0);
210
        ipc_answer_fast(callid, 0, 0, 0);
211
    }
211
    }
212
//  callid = ipc_wait_for_call(&data, NULL);
212
//  callid = ipc_wait_for_call(&data, NULL);
213
}
213
}
214
 
214
 
215
static void test_connection_ipc(void)
215
static void test_connection_ipc(void)
216
{
216
{
217
    int res;
217
    int res;
218
    ipcarg_t result;
218
    ipcarg_t result;
219
    int phoneid;
219
    int phoneid;
220
 
220
 
221
    printf("Starting connect...\n");
221
    printf("Starting connect...\n");
222
    res = ipc_connect_me_to(PHONE_NS, 10, 20);
222
    res = ipc_connect_me_to(PHONE_NS, 10, 20);
223
    printf("Connected: %d\n", res);
223
    printf("Connected: %d\n", res);
224
    printf("pinging.\n");
224
    printf("pinging.\n");
225
    res = ipc_call_sync(res, NS_PING, 0xbeef,&result);
225
    res = ipc_call_sync(res, NS_PING, 0xbeef,&result);
226
    printf("Retval: %d - received: %X\n", res, result);
226
    printf("Retval: %d - received: %X\n", res, result);
227
   
227
   
228
}
228
}
229
 
229
 
230
static void test_hangup(void)
230
static void test_hangup(void)
231
{
231
{
232
    int phoneid;
232
    int phoneid;
233
    ipc_call_t data;
233
    ipc_call_t data;
234
    ipc_callid_t callid;
234
    ipc_callid_t callid;
235
    int i;
235
    int i;
236
 
236
 
237
    printf("Starting connect...\n");
237
    printf("Starting connect...\n");
238
    phoneid = ipc_connect_me_to(PHONE_NS, 10, 20);
238
    phoneid = ipc_connect_me_to(PHONE_NS, 10, 20);
239
    printf("Phoneid: %d, pinging\n", phoneid);
239
    printf("Phoneid: %d, pinging\n", phoneid);
240
    ipc_call_async_2(PHONE_NS, NS_PING, 1, 0xbeefbee2,
240
    ipc_call_async_2(PHONE_NS, NS_PING, 1, 0xbeefbee2,
241
             "Pong1", got_answer);
241
             "Pong1", got_answer);
242
    printf("Hangin up\n");
242
    printf("Hangin up\n");
243
    ipc_hangup(phoneid);
243
    ipc_hangup(phoneid);
244
    printf("Connecting\n");
244
    printf("Connecting\n");
245
    phoneid = ipc_connect_me_to(PHONE_NS, 10, 20);
245
    phoneid = ipc_connect_me_to(PHONE_NS, 10, 20);
246
    printf("Newphid: %d\n", phoneid);
246
    printf("Newphid: %d\n", phoneid);
247
    for (i=0; i < 1000; i++) {
247
    for (i=0; i < 1000; i++) {
248
        if ((callid=ipc_trywait_for_call(&data)))
248
        if ((callid=ipc_trywait_for_call(&data)))
249
            printf("callid: %d\n");
249
            printf("callid: %d\n");
250
    }
250
    }
251
    printf("New new phoneid: %d\n", ipc_connect_me_to(PHONE_NS, 10, 20));
251
    printf("New new phoneid: %d\n", ipc_connect_me_to(PHONE_NS, 10, 20));
252
}
252
}
253
 
253
 
254
static void test_slam(void)
254
static void test_slam(void)
255
{
255
{
256
    int i;
256
    int i;
257
    ipc_call_t data;
257
    ipc_call_t data;
258
    ipc_callid_t callid;
258
    ipc_callid_t callid;
259
 
259
 
260
    printf("ping");
260
    printf("ping");
261
    ipc_call_async_2(PHONE_NS, NS_PING, 1, 0xbeefbee2,
261
    ipc_call_async_2(PHONE_NS, NS_PING, 1, 0xbeefbee2,
262
             "Pong1", got_answer);
262
             "Pong1", got_answer);
263
    printf("slam");
263
    printf("slam");
264
    ipc_call_async_2(PHONE_NS, NS_HANGUP, 1, 0xbeefbee2,
264
    ipc_call_async_2(PHONE_NS, NS_HANGUP, 1, 0xbeefbee2,
265
             "Hang", got_answer);
265
             "Hang", got_answer);
266
    printf("ping2\n");
266
    printf("ping2\n");
267
    ipc_call_async_2(PHONE_NS, NS_PING, 1, 0xbeefbee2,
267
    ipc_call_async_2(PHONE_NS, NS_PING, 1, 0xbeefbee2,
268
             "Ping2", got_answer);
268
             "Ping2", got_answer);
269
   
269
   
270
    for (i=0; i < 1000; i++) {
270
    for (i=0; i < 1000; i++) {
271
        if ((callid=ipc_trywait_for_call(&data)))
271
        if ((callid=ipc_trywait_for_call(&data)))
272
            printf("callid: %d\n");
272
            printf("callid: %d\n");
273
    }
273
    }
274
    ipc_call_async_2(PHONE_NS, NS_PING, 1, 0xbeefbee2,
274
    ipc_call_async_2(PHONE_NS, NS_PING, 1, 0xbeefbee2,
275
             "Pong1", got_answer);
275
             "Pong1", got_answer);
276
    printf("Closing file\n");
276
    printf("Closing file\n");
277
    ipc_hangup(PHONE_NS);
277
    ipc_hangup(PHONE_NS);
278
    ipc_call_async_2(PHONE_NS, NS_PING, 1, 0xbeefbee2,
278
    ipc_call_async_2(PHONE_NS, NS_PING, 1, 0xbeefbee2,
279
             "Pong1", got_answer);
279
             "Pong1", got_answer);
280
    ipc_wait_for_call(&data);
280
    ipc_wait_for_call(&data);
281
}
281
}
282
 
282
 
283
static int ptest(void *arg)
283
static int ptest(void *arg)
284
{
284
{
285
    stage = 1;
285
    stage = 1;
286
    printf("Pseudo thread stage%d.\n", stage);
286
    printf("Pseudo thread stage%d.\n", stage);
287
    stage++;
287
    stage++;
288
    psthread_schedule_next();
288
    psthread_schedule_next();
289
    printf("Pseudo thread stage%d.\n", stage);
289
    printf("Pseudo thread stage%d.\n", stage);
290
    stage++;
290
    stage++;
291
    psthread_schedule_next();
291
    psthread_schedule_next();
292
    printf("Pseudo thread stage%d.\n", stage);
292
    printf("Pseudo thread stage%d.\n", stage);
293
    psthread_schedule_next();
293
    psthread_schedule_next();
294
    stage++;
294
    stage++;
295
    printf("Pseudo thread stage%d.\n", stage);
295
    printf("Pseudo thread stage%d.\n", stage);
296
    psthread_schedule_next();
296
    psthread_schedule_next();
297
    printf("Pseudo thread exiting.\n");
297
    printf("Pseudo thread exiting.\n");
298
    return 0;  
298
    return 0;  
299
}
299
}
300
 
300
 
301
static void test_kbd()
301
static void test_kbd()
302
{
302
{
303
    int res;
303
    int res;
304
    ipcarg_t result;
304
    ipcarg_t result;
305
    int phoneid;
305
    int phoneid;
306
 
306
 
307
    printf("Test: Starting connect...\n");
307
    printf("Test: Starting connect...\n");
308
    while ((phoneid = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0)) < 0) {
308
    while ((phoneid = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0)) < 0) {
309
    };
309
    };
310
   
310
   
311
    printf("Test: Connected: %d\n", res);
311
    printf("Test: Connected: %d\n", res);
312
    printf("Test: pinging.\n");
312
    printf("Test: pinging.\n");
313
/*  while (1) {
313
/*  while (1) {
314
       
314
       
315
        res = ipc_call_sync(phoneid, KBD_GETCHAR, 0xbeef,&result);
315
        res = ipc_call_sync(phoneid, KBD_GETCHAR, 0xbeef,&result);
316
//      printf("Test: Retval: %d - received: %c\n", res, result);
316
//      printf("Test: Retval: %d - received: %c\n", res, result);
317
        printf("%c", result);
317
        printf("%c", result);
318
    }
318
    }
319
*/ 
319
*/ 
320
    printf("Test: Hangin up\n");
320
    printf("Test: Hangin up\n");
321
    ipc_hangup(phoneid);
321
    ipc_hangup(phoneid);
322
}
322
}
323
 
323
 
324
static void test_async_kbd()
324
static void test_async_kbd()
325
{
325
{
326
    int res;
326
    int res;
327
    ipcarg_t result;
327
    ipcarg_t result;
328
    ipc_call_t kbddata;
328
    ipc_call_t kbddata;
329
    int phoneid;
329
    int phoneid;
330
    aid_t aid;
330
    aid_t aid;
331
 
331
 
332
    printf("Test: Starting connect...\n");
332
    printf("Test: Starting connect...\n");
333
    while ((phoneid = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0)) < 0) {
333
    while ((phoneid = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0)) < 0) {
334
    };
334
    };
335
   
335
   
336
    printf("Test: Connected: %d\n", res);
336
    printf("Test: Connected: %d\n", res);
337
    printf("Test: pinging.\n");
337
    printf("Test: pinging.\n");
338
 
338
 
339
 
339
 
340
    while (1) {
340
    while (1) {
341
    }
341
    }
342
   
342
   
343
    printf("Test: Hangin up\n");
343
    printf("Test: Hangin up\n");
344
    ipc_hangup(phoneid);
344
    ipc_hangup(phoneid);
345
}
345
}
346
 
346
 
347
static void test_pci()
347
static void test_pci()
348
{
348
{
349
    int phone;
349
    int phone;
350
    while ((phone = ipc_connect_me_to(PHONE_NS, SERVICE_PCI, 0)) < 0)
350
    while ((phone = ipc_connect_me_to(PHONE_NS, SERVICE_PCI, 0)) < 0)
351
        ;
351
        ;
352
    printf("Connected to PCI service through phone %d.\n", phone);
352
    printf("Connected to PCI service through phone %d.\n", phone);
353
}
353
}
354
 
354
 
355
static int test_as_area_send()
355
static int test_as_area_send()
356
{
356
{
357
    char *as_area;
357
    char *as_area;
358
    int retval;
358
    int retval;
359
    ipcarg_t result;
359
    ipcarg_t result;
360
 
360
 
361
    as_area = as_area_create((void *)(1024*1024), 16384, AS_AREA_READ | AS_AREA_WRITE);
361
    as_area = as_area_create((void *)(1024*1024), 16384, AS_AREA_READ | AS_AREA_WRITE);
362
    if (!as_area) {
362
    if (!as_area) {
363
        printf("Error creating as_area.\n");
363
        printf("Error creating as_area.\n");
364
        return 0;
364
        return 0;
365
    }
365
    }
366
 
366
 
367
    memcpy(as_area, "Hello world.\n", 14);
367
    memcpy(as_area, "Hello world.\n", 14);
368
 
368
 
369
    retval = ipc_call_sync_3(PHONE_NS, IPC_M_AS_AREA_SEND, (sysarg_t) as_area, 0, AS_AREA_READ,
369
    retval = ipc_call_sync_3(PHONE_NS, IPC_M_AS_AREA_SEND, (sysarg_t) as_area, 0, AS_AREA_READ,
370
        NULL, NULL, NULL);
370
        NULL, NULL, NULL);
371
    if (retval) {
371
    if (retval) {
372
        printf("AS_AREA_SEND failed.\n");
372
        printf("AS_AREA_SEND failed.\n");
373
        return 0;
373
        return 0;
374
    }
374
    }
375
    printf("Done\n");
375
    printf("Done\n");
376
}
376
}
377
 
377
 
378
static void test_fb()
378
static void test_fb()
379
{
379
{
380
    int res;
380
    int res;
381
    ipcarg_t result;
381
    ipcarg_t result;
382
    int phoneid;
382
    int phoneid;
-
 
383
    int vp;
383
 
384
 
384
//  printf("Test: Starting connect...\n");
385
//  printf("Test: Starting connect...\n");
385
 
386
 
386
    phoneid = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0);
-
 
387
 
-
 
388
    while ((phoneid = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0)) < 0) {
387
    while ((phoneid = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0)) < 0) {
389
        volatile int a;
388
        volatile int a;
390
        for(a=0;a<1048576;a++);
389
        for(a=0;a<1048576;a++);
391
    };
390
    };
392
   
391
   
393
//  printf("Test: Connected: %d\n", res);
-
 
394
//  printf("Test: pinging.\n");
-
 
395
    while (1) {
392
    usleep(100000);
-
 
393
    vp = ipc_call_sync_3(phoneid, FB_VIEWPORT_CREATE, (200 << 16) | 300, (200 << 16) | 150,0,NULL,NULL,NULL);
396
        res = ipc_call_sync(phoneid, FB_GET_VFB, 0xbeef,&result);
394
    if (! ipc_call_sync(phoneid, FB_VIEWPORT_SWITCH, vp, NULL)) {
397
//      printf("Test: Retval: %d - received: %c\n", res, result);
395
        ipc_call_sync_2(phoneid, FB_SET_STYLE, 0, 0xffffff, NULL, NULL);
398
//      printf("%c", result);
396
        ipc_call_sync(phoneid, FB_CLEAR, 0, NULL);
-
 
397
        ipc_call_sync_3(phoneid, FB_PUTCHAR, 'X', 0,0, NULL, NULL, NULL);
399
    }
398
    }
400
   
399
 
401
//  printf("Test: Hangin up\n");
-
 
402
    ipc_hangup(phoneid);
400
    ipc_hangup(phoneid);
403
}
401
}
404
 
402
 
405
static void test_time(void)
403
static void test_time(void)
406
{
404
{
407
    int rc;
405
    int rc;
408
    struct timeval tv;
406
    struct timeval tv;
409
    struct timezone tz;
407
    struct timezone tz;
410
 
408
 
411
    while (1) {
409
    while (1) {
412
        rc = gettimeofday(&tv, &tz);
410
        rc = gettimeofday(&tv, &tz);
413
        printf("Rc: %d, Secs: %d, Usecs: %d\n", rc, tv.tv_sec,
411
        printf("Rc: %d, Secs: %d, Usecs: %d\n", rc, tv.tv_sec,
414
               tv.tv_usec);
412
               tv.tv_usec);
415
    }
413
    }
416
}
414
}
417
 
415
 
418
static void test_console(void)
416
static void test_console(void)
419
{
417
{
420
    int c;
418
    int c;
421
 
419
 
422
    while ((c = getchar()) != EOF)
420
    while ((c = getchar()) != EOF)
423
        putchar(c);
421
        putchar(c);
424
}
422
}
425
 
423
 
426
 
424
 
427
int main(int argc, char *argv[])
425
int main(int argc, char *argv[])
428
{
426
{
429
    pstid_t ptid;
427
    pstid_t ptid;
430
    int tid;
428
    int tid;
431
   
429
   
432
//  version_print();
430
//  version_print();
433
 
431
 
434
    printf("Hello\nThis is Init\n");
432
    printf("Hello\nThis is Init\n");
435
   
433
   
436
//  test_printf();
434
//  test_printf();
437
//  test_printf2();
435
//  test_printf2();
438
//  test_ping();
436
//  test_ping();
439
//  test_async_ipc();
437
//  test_async_ipc();
440
//  test_advanced_ipc();
438
//  test_advanced_ipc();
441
//  test_connection_ipc();
439
//  test_connection_ipc();
442
//  test_hangup();
440
//  test_hangup();
443
//  test_slam();
441
//  test_slam();
444
//  test_as_area_send();
442
//  test_as_area_send();
445
//  test_pci();
443
//  test_pci();
446
//  test_kbd();
444
//  test_kbd();
447
//  test_time();
445
//  test_time();
448
//  test_async_kbd();
446
//  test_async_kbd();
449
//  test_fb();
447
//  test_fb();
450
    test_console();
448
//  test_console();
451
 
449
 
452
    printf("\nBye.\n");
450
    printf("\nBye.\n");
453
 
451
 
454
/* 
452
/* 
455
    printf("Userspace task, taskid=%llX\n", task_get_id());
453
    printf("Userspace task, taskid=%llX\n", task_get_id());
456
 
454
 
457
    futex_initialize(&ftx, 1);
455
    futex_initialize(&ftx, 1);
458
    if (futex_down(&ftx) < 0)
456
    if (futex_down(&ftx) < 0)
459
        printf("Futex failed.\n");
457
        printf("Futex failed.\n");
460
    if (futex_up(&ftx) < 0)
458
    if (futex_up(&ftx) < 0)
461
        printf("Futex failed.\n");
459
        printf("Futex failed.\n");
462
 
460
 
463
    if (futex_down(&ftx) < 0)
461
    if (futex_down(&ftx) < 0)
464
        printf("Futex failed.\n");
462
        printf("Futex failed.\n");
465
 
463
 
466
    if ((tid = thread_create(utest, NULL, "utest")) != -1) {
464
    if ((tid = thread_create(utest, NULL, "utest")) != -1) {
467
        printf("Created thread tid=%d\n", tid);
465
        printf("Created thread tid=%d\n", tid);
468
    }
466
    }
469
 
467
 
470
    if ((tid = thread_create(utest, NULL, "utest")) != -1) {
468
    if ((tid = thread_create(utest, NULL, "utest")) != -1) {
471
        printf("Created thread tid=%d\n", tid);
469
        printf("Created thread tid=%d\n", tid);
472
    }
470
    }
473
 
471
 
474
    int i;
472
    int i;
475
 
473
 
476
    for (i = 0; i < 50000000; i++)
474
    for (i = 0; i < 50000000; i++)
477
        ;
475
        ;
478
       
476
       
479
    if (futex_up(&ftx) < 0)
477
    if (futex_up(&ftx) < 0)
480
        printf("Futex failed.\n");
478
        printf("Futex failed.\n");
481
 
479
 
482
 
480
 
483
    printf("Creating pseudo thread.\n");
481
    printf("Creating pseudo thread.\n");
484
    stage = 1;
482
    stage = 1;
485
    ptid = psthread_create(ptest, NULL);
483
    ptid = psthread_create(ptest, NULL);
486
    printf("Main thread stage%d.\n", stage);
484
    printf("Main thread stage%d.\n", stage);
487
    stage++;
485
    stage++;
488
    psthread_schedule_next();;
486
    psthread_schedule_next();;
489
    printf("Main thread stage%d.\n", stage);
487
    printf("Main thread stage%d.\n", stage);
490
    stage++;
488
    stage++;
491
    psthread_schedule_next();;
489
    psthread_schedule_next();;
492
    printf("Main thread stage%d.\n", stage);
490
    printf("Main thread stage%d.\n", stage);
493
 
491
 
494
    psthread_join(ptid);
492
    psthread_join(ptid);
495
 
493
 
496
    printf("Main thread exiting.\n");
494
    printf("Main thread exiting.\n");
497
*/
495
*/
498
 
496
 
499
    return 0;
497
    return 0;
500
}
498
}
501
 
499