![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to systemcall.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / clients / net-snk / kernel|
Return to systemcall.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / clients / net-snk / kernel |
1.1 root 1: /******************************************************************************
2: * Copyright (c) 2004, 2008 IBM Corporation
3: * All rights reserved.
4: * This program and the accompanying materials
5: * are made available under the terms of the BSD License
6: * which accompanies this distribution, and is available at
7: * http://www.opensource.org/licenses/bsd-license.php
8: *
9: * Contributors:
10: * IBM Corporation - initial implementation
11: *****************************************************************************/
12:
13:
14: #include <of.h>
15: #include <systemcall.h>
16: #include <stdarg.h>
17: #include <netdriver_int.h>
18: #include <string.h>
19: #include <fileio.h>
20:
21: //extern ihandle_t fd_array[32];
22: extern snk_module_t *get_module_by_type(int type);
23: extern int vsprintf(char *, const char *, va_list);
24: extern void _exit(int status);
25:
26: int printk(const char*, ...);
27:
28: static int
29: _syscall_open(const char* name, int flags)
30: {
31: int fd, i;
32:
33: /* search free file descriptor */
34: for(fd=0; fd<FILEIO_MAX; ++fd) {
35: if(fd_array[fd].type == FILEIO_TYPE_EMPTY) {
36: break;
37: }
38: }
39: if(fd == FILEIO_MAX) {
40: printk ("Can not open \"%s\" because file descriptor list is full\n", name);
41: /* there is no free file descriptor avaliable */
42: return -2;
43: }
44:
45: for(i=0; i<MODULES_MAX; ++i) {
46: if(!snk_modules[i] || !snk_modules[i]->open) {
47: continue;
48: }
49:
50: if(snk_modules[i]->running == 0) {
51: snk_modules[i]->init();
52: }
53:
54: if(snk_modules[i]->open(&fd_array[fd], name, flags) == 0)
55: break;
56: }
57:
58: if(i==MODULES_MAX) {
59: /* file not found */
60: return -1;
61: }
62:
63: return fd;
64: }
65:
66: static int
67: _syscall_socket(int domain, int type, int proto, char *mac_addr)
68: {
69: snk_module_t *net_module;
70:
71: net_module = get_module_by_type(MOD_TYPE_NETWORK);
72: if( !net_module || !net_module->init) {
73: printk("No net_init function available");
74: return -1;
75: }
76:
77: /* Init net device driver */
78: if(net_module->running == 0) {
79: net_module->init();
80: }
81:
82: if(net_module->running == 0)
83: return -2;
84:
85: memcpy(mac_addr, &net_module->mac_addr[0], 6);
86: return 0;
87: }
88:
89: static int
90: _syscall_close(int fd)
91: {
92: if(fd < 0 || fd >= FILEIO_MAX
93: || fd_array[fd].type == FILEIO_TYPE_EMPTY
94: || fd_array[fd].close == 0)
95: return -1;
96:
97: return fd_array[fd].close(&fd_array[fd]);
98: }
99:
100: static long
101: _syscall_read (int fd, char *buf, long len)
102: {
103: if(fd < 0 || fd >= FILEIO_MAX
104: || fd_array[fd].type == FILEIO_TYPE_EMPTY
105: || fd_array[fd].read == 0)
106: return -1;
107:
108: return fd_array[fd].read(&fd_array[fd], buf, len);
109: }
110:
111: static long
112: _syscall_write (int fd, char *buf, long len)
113: {
114: char dest_buf[512];
115: char *dest_buf_ptr;
116: int i;
117: if (fd == 1 || fd == 2)
118: {
119: dest_buf_ptr = &dest_buf[0];
120: for (i = 0; i < len && i < 256; i++)
121: {
122: *dest_buf_ptr++ = *buf++;
123: if (buf[-1] == '\n')
124: *dest_buf_ptr++ = '\r';
125: }
126: len = dest_buf_ptr - &dest_buf[0];
127: buf = &dest_buf[0];
128: }
129:
130: if(fd < 0 || fd >= FILEIO_MAX
131: || fd_array[fd].type == FILEIO_TYPE_EMPTY
132: || fd_array[fd].write == 0)
133: return -1;
134:
135: return fd_array[fd].write(&fd_array[fd], buf, len);
136: }
137:
138: static long
139: _syscall_lseek (int fd, long offset, int whence)
140: {
141: return 0; // this syscall is unused !!!
142: #if 0
143: if (whence != 0)
144: return -1;
145:
146: of_seek (fd_array[fd], (unsigned int) (offset>>32), (unsigned int) (offset & 0xffffffffULL));
147:
148: return offset;
149: #endif
150: }
151:
152: static int
153: _syscall_ioctl (int fd, int request, void* data)
154: {
155: if (fd < 0
156: || fd >= FILEIO_MAX
157: || fd_array[fd].type == FILEIO_TYPE_EMPTY)
158: return -1;
159: if (!fd_array[fd].ioctl) { /* for backwards compatibility with network modules */
160: snk_module_t *net_module;
161:
162: net_module = get_module_by_type(MOD_TYPE_NETWORK);
163: if ( !net_module || !net_module->ioctl ) {
164: printk("No net_ioctl function available");
165: return -1;
166: }
167:
168: return net_module->ioctl(request, data);
169: }
170:
171: return fd_array[fd].ioctl(&fd_array[fd], request, data);
172: }
173:
174: static long
175: _syscall_recv(int fd, void *packet, int packet_len, int flags)
176: {
177: snk_module_t *net_module;
178:
179: net_module = get_module_by_type(MOD_TYPE_NETWORK);
180: if( !net_module || !net_module->read ) {
181: printk("No net_receive function available");
182: return -1;
183: }
184:
185: return net_module->read(packet, packet_len);
186: }
187:
188: static long
189: _syscall_send(int fd, void *packet, int packet_len, int flags)
190: {
191: snk_module_t *net_module;
192:
193: net_module = get_module_by_type(MOD_TYPE_NETWORK);
194: if( !net_module || !net_module->write ) {
195: printk("No net_xmit function available");
196: return -1;
197: }
198:
199: return net_module->write(packet, packet_len);
200: }
201:
202: static long
203: _syscall_sendto(int fd, void *packet, int packet_len, int flags,
204: void *sock_addr, int sock_addr_len)
205: {
206: return _syscall_send(fd, packet, packet_len, flags);
207: }
208:
209:
210:
211:
212:
213:
214:
215:
216: long
217: _system_call(long arg0, long arg1, long arg2, long arg3,
218: long arg4, long arg5, long arg6, int nr)
219: {
220: long rc = -1;
221:
222: switch (nr)
223: {
224: case _open_sc_nr:
225: rc = _syscall_open ((void *) arg0, arg1);
226: break;
227: case _read_sc_nr:
228: rc = _syscall_read (arg0, (void *) arg1, arg2);
229: break;
230: case _close_sc_nr:
231: _syscall_close (arg0);
232: break;
233: case _lseek_sc_nr:
234: rc = _syscall_lseek (arg0, arg1, arg2);
235: break;
236: case _write_sc_nr:
237: rc = _syscall_write (arg0, (void *) arg1, arg2);
238: break;
239: case _ioctl_sc_nr:
240: rc = _syscall_ioctl (arg0, arg1, (void *) arg2);
241: break;
242: case _socket_sc_nr:
243: switch (arg0)
244: {
245: case _sock_sc_nr:
246: rc = _syscall_socket (arg1, arg2, arg3, (char*) arg4);
247: break;
248: case _recv_sc_nr:
249: rc = _syscall_recv (arg1, (void *) arg2, arg3, arg4);
250: break;
251: case _send_sc_nr:
252: rc = _syscall_send (arg1, (void *) arg2, arg3, arg4);
253: break;
254: case _sendto_sc_nr:
255: rc = _syscall_sendto (arg1, (void *) arg2, arg3, arg4, (void *) arg5, arg6);
256: break;
257: default:
258: break;
259: }
260: break;
261: default:
262: break;
263: }
264:
265: return rc;
266: }
267:
268: void
269: exit(int status)
270: {
271: _exit(status);
272: }
273:
274: int
275: printk(const char* fmt, ...)
276: {
277: int count;
278: va_list ap;
279: char buffer[256];
280: va_start (ap, fmt);
281: count=vsprintf(buffer, fmt, ap);
282: _syscall_write (1, buffer, count);
283: va_end (ap);
284: return count;
285: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.