kernel/arch/i386/syscall.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2007  Tomas 'ZeXx86' Jedrzejek (zexx86@gmail.com)
   4  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@gmail.com)
   5  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@gmail.com)
   6  *  Copyright (C) 2009  Martin 'povik' Poviser (martin.povik@gmail.com)
   7  *
   8  *  This program is free software: you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation, either version 3 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22
  23 #include <system.h>
  24 #include <arch/io.h>
  25 #include <string.h>
  26 #include <tty.h>
  27 #include <proc.h>
  28 #include <net/socket.h>
  29 #include <file.h>
  30 #include <signal.h>
  31 #include <module.h>
  32 #include <rs232.h>
  33 #include <ioctl.h>
  34 #include <fd.h>
  35 #include <paging.h>
  36 #include <pipe.h>
  37 #include <errno.h>
  38
  39 extern task_t *_curr_task;
  40
  41 void sys_exit (struct regs *r)
  42 {
  43         task_t *taskc = task_find (0);
  44
  45         if (!taskc)
  46                 return;
  47
  48         page_dir_switch (taskc->page_cover->page_dir);
  49
  50         proc_t *proc = proc_find (_curr_task);
  51
  52         if (!proc)
  53                 return;
  54
  55         task_t *task = proc->tty->task;
  56
  57         proc->pid = 0;
  58
  59         if (int_disable ())
  60                 longjmp (task->state, 1);
  61         else
  62                 while (1)
  63                         schedule ();
  64 }
  65
  66 void sys_getch (struct regs *r)
  67 {
  68         proc_t *proc = proc_find (_curr_task);
  69
  70         if (!proc)
  71                 return;
  72
  73         if (proc->tty != currtty)
  74                 return;
  75
  76         unsigned char c = (unsigned char) getkey ();
  77
  78         if (c)
  79                 setkey (0);
  80
  81         //r->eax = (unsigned) &c;
  82
  83         unsigned char *memptr = (unsigned char *) 0x905d;
  84         *memptr = c;
  85 }
  86
  87 extern unsigned long timer_ticks;
  88 void sys_sleep (struct regs *r)
  89 {
  90         unsigned long timer_start = timer_ticks + ((unsigned) r->ebx * 1000);
  91
  92         while (timer_start > timer_ticks)
  93                 schedule ();
  94 }
  95
  96 void sys_putch (struct regs *r)
  97 {
  98         task_t *taskc = task_find (0);
  99
 100         if (!taskc)
 101                 return;
 102
 103         //page_dir_switch (taskc->page_cover->page_dir);
 104
 105         proc_t *proc = proc_find (_curr_task);
 106
 107         if (!proc)
 108                 return;
 109
 110         int c = r->ebx;
 111
 112         tty_putnch (proc->tty, c);
 113
 114         //page_dir_switch (proc->task->page_cover->page_dir);
 115 }
 116
 117 void sys_color (struct regs *r)
 118 {
 119         video_color (r->ebx, r->ecx);
 120 }
 121
 122
 123 void sys_cls (struct regs *r)
 124 {
 125         proc_t *proc = proc_find (_curr_task);
 126
 127         if (!proc)
 128                 return;
 129
 130         if (proc->tty != currtty)
 131                 return;
 132
 133         /* NOTE: Why we should disable interrupts ? Nobody know, but works better */
 134         if (int_disable ()) {
 135                 tty_cls (proc->tty);
 136                 int_enable ();
 137         }
 138 }
 139
 140 extern unsigned char scancode;
 141 void sys_getkey (struct regs *r)
 142 {
 143         proc_t *proc = proc_find (_curr_task);
 144
 145         if (!proc)
 146                 return;
 147
 148         if (proc->tty != currtty)
 149                 return;
 150
 151         unsigned char c = (unsigned char) scancode;
 152
 153         scancode = 0;
 154
 155         unsigned char *memptr = (unsigned char *) 0x9060;
 156         *memptr = c;
 157 }
 158
 159 void sys_gotoxy (struct regs *r)
 160 {
 161         proc_t *proc = proc_find (_curr_task);
 162
 163         if (!proc)
 164                 return;
 165
 166         tty_gotoxy (proc->tty, r->ebx, r->ecx);
 167 }
 168
 169 void sys_fork (struct regs *r)
 170 {
 171         unsigned short *where;
 172         unsigned char c = (unsigned char) fork ();
 173
 174         unsigned short *memptr = (unsigned short *) 0x9000;
 175         where = memptr;
 176         *where = c;
 177 }
 178
 179 void sys_schedule (struct regs *r)
 180 {
 181         schedule ();
 182 }
 183
 184 extern kbd_quaue kbd_q;
 185 void sys_write (struct regs *r)
 186 {
 187         unsigned len = r->ecx;
 188         unsigned fd = r->edx;
 189
 190         unsigned char *buf = (unsigned char *) r->ebx;
 191
 192         if (!buf)
 193                 return;
 194
 195 //      kprintf ("#buf: 0x%x / '%s'\n", buf, buf);
 196
 197         /*char buf[len+1];
 198         if (!memcpy_to_user (&buf, (char *) r->ebx, len))
 199                 return;*/
 200
 201         int ret = 0;
 202
 203         proc_t *proc = 0;
 204         char *mem = 0;
 205
 206         switch (fd) {
 207                 case 0:
 208                         proc = proc_find (_curr_task);
 209
 210                         if (!proc) {
 211                                 ret = -1;
 212                                 break;
 213                         }
 214
 215                         //if (buf >= proc->data && buf < (proc->data+proc->data_off)) {
 216                         //      kprintf ("Je to staticky retezec :) - 0x%x - '%s'\n", buf+proc->code, buf+proc->code);
 217                         //}
 218
 219                         mem = (char *) buf;//vmem_proc_check (proc, buf);
 220
 221                         //if (proc->tty != currtty)
 222                         //      return;
 223
 224                         //printf ("data: 0x%x | 0x%x\n", buf, proc->data);
 225
 226                         //if (!memtest_data (buf, (void *) proc->data, proc->data_off))
 227                         tty_write (proc->tty, (char *) mem, len);
 228                         //else {
 229                         //      tty_write (proc->tty, (char *) buf+proc->code, len);
 230                         //}
 231                         ret = len;
 232                         //timer_wait (5000);
 233
 234                         break;
 235                 case 1:
 236                         proc = proc_find (_curr_task);
 237
 238                         if (!proc) {
 239                                 ret = -1;
 240                                 break;
 241                         }
 242
 243                         if (len > KBD_MAX_QUAUE)
 244                                 len = KBD_MAX_QUAUE;
 245
 246                         mem = (char *) buf;
 247
 248                         int i = 0;
 249                         for (i = len; i >= 0; i --)
 250                                 setkey (buf[i]);
 251
 252                         mem[len] = '\0';
 253
 254                         ret = len;
 255                         break;
 256                 default:
 257                         mem = (char *) buf;
 258                         //printf ("hehe: 0x%x / '%s' len: %d\n", mem, mem, len);
 259                         ret = write (fd, (char *) mem, len);
 260                         break;
 261         }
 262
 263         int *memptr = (int *) 0x9000;
 264         *memptr = ret;
 265 }
 266
 267 void sys_socket (struct regs *r)
 268 {
 269         int ret = socket (r->ebx, r->ecx, r->edx);
 270
 271         int *memptr = (int *) 0x9000;
 272         *memptr = ret;
 273 }
 274
 275 void sys_connect (struct regs *r)
 276 {
 277         sockaddr *addr = (sockaddr *) r->ebx;
 278
 279         int ret = connect (r->ecx, addr, r->edx);
 280
 281         int *memptr = (int *) 0x9000;
 282         *memptr = ret;
 283 }
 284
 285 void sys_malloc (struct regs *r)
 286 {
 287         proc_t *proc = proc_find (_curr_task);
 288
 289         paging_disable ();
 290         r->eax = (unsigned) umalloc (proc, (int) r->ebx);
 291         paging_enable ();
 292
 293         DPRINT ("malloc (): 0x%x", r->eax);
 294 }
 295
 296 void sys_send (struct regs *r)
 297 {
 298 /*      char msg[r->edx+1];
 299         if (!memcpy_to_user (&msg, (char *) r->ebx, r->edx))
 300                 return;*/
 301
 302         int ret = send ((int) r->ecx, (char *) r->ebx, (unsigned) r->edx, 0);
 303
 304         int *memptr = (int *) 0x9000;
 305         *memptr = ret;
 306 }
 307
 308 void sys_recv (struct regs *r)
 309 {
 310         unsigned char *msg = (unsigned char *) r->ebx;
 311         unsigned size = (unsigned) r->edx;
 312         int fd = (int) r->ecx;
 313
 314         int ret = recv (fd, (char *) msg, size, 0);
 315
 316 /*      if (ret > 0) {
 317                 printf ("recv> r->ebx: %d, r->edx: %u, ret: %d\n", (int) r->ecx, (unsigned) r->edx, ret);
 318         }*/
 319
 320         //printf ("recv> r->ebx: %d, r->edx: %u, ret: %d\n", (int) r->ecx, (unsigned) r->edx, ret);
 321
 322         int *memptr = (int *) 0x9030;
 323         *memptr = ret;
 324 }
 325
 326 void sys_close (struct regs *r)
 327 {
 328         close (r->ebx);
 329 }
 330
 331 void sys_open (struct regs *r)
 332 {
 333         unsigned char *pathname = (unsigned char *) r->ebx;
 334
 335         int ret = open ((char *) pathname, (unsigned) r->ecx);
 336
 337 //      printf ("%d = sys_open (%s, %u)\n", ret, (char *) pathname, (unsigned) r->ecx);
 338
 339         int *memptr = (int *) 0x9000;
 340         *memptr = ret;
 341 }
 342
 343 void sys_pcspk (struct regs *r)
 344 {
 345         dev_t *dev = dev_find ("/dev/pcspk");
 346
 347         if (dev)
 348                 dev->handler (DEV_ACT_PLAY, (unsigned) r->ebx);
 349 }
 350
 351 void sys_usleep (struct regs *r)
 352 {
 353         //unsigned long timer_start = timer_ticks + ((unsigned) r->ebx);
 354
 355         //while (timer_start > timer_ticks)
 356         //      schedule ();
 357         usleep ((unsigned) r->ebx);
 358 }
 359
 360 void sys_read (struct regs *r)
 361 {
 362         unsigned fd = r->ecx;
 363         unsigned len = r->edx;
 364
 365         unsigned char *buf = (unsigned char *) r->ebx;
 366
 367         int ret = 0;
 368
 369         proc_t *proc = 0;
 370
 371         switch (fd) {
 372                 case 0:
 373                         break;
 374                 case 1:
 375                         proc = proc_find (_curr_task);
 376
 377                         if (!proc)
 378                                 break;
 379
 380                         //if (proc->tty != currtty)
 381                         //      return;
 382
 383                         ret = tty_read (proc->tty, (char *) buf, len);
 384                         break;
 385                 default:
 386                         ret = read (fd, (char *) buf, len);
 387                         break;
 388         }
 389
 390         int *memptr = (int *) 0x9000;
 391         *memptr = ret;
 392 }
 393
 394 void sys_time (struct regs *r)
 395 {
 396         time_t *memptr = (time_t *) 0x9005;
 397
 398         tm *t = rtc_getcurrtime ();
 399
 400         if (t)
 401                 *memptr = (time_t) t->__tm_gmtoff;
 402 }
 403
 404 void sys_system (struct regs *r)
 405 {
 406         task_t *task = task_find (0);
 407
 408         if (!task)
 409                 return;
 410
 411         proc_t *proc = proc_find (_curr_task);
 412
 413         if (!proc)
 414                 return;
 415
 416         task_t *oldtask = _curr_task;
 417
 418         page_dir_switch (task->page_cover->page_dir);
 419
 420         unsigned char *cmd = (unsigned char *) r->ebx;
 421
 422         command_parser ((char *) cmd, strlen (cmd));
 423
 424         page_dir_switch (oldtask->page_cover->page_dir);
 425
 426         /* needed for correct scheduling (when you execute new process, _curr_task is tasj of current tty) */
 427          _curr_task = oldtask;
 428
 429         schedule ();
 430
 431 }
 432
 433 void sys_chdir (struct regs *r)
 434 {
 435         unsigned char *dir = (unsigned char *) r->ebx;
 436
 437         cd ((char *) dir);
 438 }
 439
 440 void sys_getdir (struct regs *r)
 441 {
 442         r->eax = (unsigned) vfs_dirent ();
 443 }
 444
 445 void sys_procarg (struct regs *r)
 446 {
 447         proc_t *proc = proc_find (_curr_task);
 448
 449         if (!proc)
 450                 return;
 451
 452         switch (r->ecx) {
 453                 case 0:
 454                         r->eax = (unsigned) proc->argv;
 455                         break;
 456                 case 1:
 457                         r->eax = (unsigned) proc->argc;
 458                         break;
 459                 default:
 460                         r->eax = 0;
 461         }
 462 }
 463
 464 void sys_signal (struct regs *r)
 465 {
 466         signal (r->ebx, (sighandler_t) r->ecx);
 467 }
 468
 469 void sys_mount (struct regs *r)
 470 {
 471         partition_t *p = partition_find ((char *) r->ebx);
 472
 473         if (p) {
 474                 mount (p, "", (char *) r->ecx);
 475                 r->eax = 1;
 476         } else
 477                 r->eax = 0;
 478 }
 479
 480 void sys_kputs (struct regs *r)
 481 {
 482         int_disable ();
 483
 484         module_t *kmod = module_find (_curr_task);
 485
 486         if (!kmod)
 487                 return;
 488
 489         if (kmod->task != _curr_task)
 490                 return;
 491
 492         unsigned char *buf = (unsigned char *) r->ebx;
 493         kprintf (buf);
 494
 495         //kprintf ("yeah, sys_kputs: '%s' '0x%x'\n", buf, buf);
 496
 497         int_enable ();
 498 }
 499
 500 void sys_bind (struct regs *r)
 501 {
 502         int ret = bind (r->ecx, (sockaddr *) r->ebx, r->edx);
 503
 504         int *memptr = (int *) 0x9000;
 505         *memptr = ret;
 506 }
 507
 508 void sys_listen (struct regs *r)
 509 {
 510         int ret = listen (r->ebx, r->ecx);
 511
 512         int *memptr = (int *) 0x9000;
 513         *memptr = ret;
 514 }
 515
 516 void sys_accept (struct regs *r)
 517 {
 518         int ret = accept (r->ecx, r->ebx, r->edx);
 519
 520         int *memptr = (int *) 0x9000;
 521         *memptr = ret;
 522 }
 523
 524 void sys_fcntl (struct regs *r)
 525 {
 526         int ret = fcntl (r->ebx, r->ecx, r->edx);
 527
 528         int *memptr = (int *) 0x9000;
 529         *memptr = ret;
 530 }
 531
 532 void sys_gvgafb (struct regs *r)
 533 {
 534         proc_t *proc = proc_find (_curr_task);
 535
 536         if (!proc)
 537                 return;
 538
 539         if (vgagui != 2) {
 540                 printf ("Please start this program in graphical VESA mode\n");
 541                 sys_exit (r);
 542                 return;
 543         }
 544
 545         unsigned *memptr = (unsigned *) 0x900a;
 546         *memptr = (unsigned) init_vgafb ();
 547 }
 548
 549 void sys_gcls (struct regs *r)
 550 {
 551         //gcls (r->ebx);
 552 }
 553
 554 void sys_gfbswap (struct regs *r)
 555 {
 556         proc_t *proc = proc_find (_curr_task);
 557
 558         if (!proc)
 559                 return;
 560
 561         if (proc->tty == currtty)
 562                 video_gfx_fbswap ();
 563
 564         schedule ();
 565 }
 566
 567 void sys_rs232read (struct regs *r)
 568 {
 569         char *memptr = (char *) 0x9000;
 570         *memptr = rs232_read ();
 571 }
 572
 573 void sys_rs232write (struct regs *r)
 574 {
 575         rs232_write ((char) r->ebx);
 576 }
 577
 578 void sys_gttyexit (struct regs *r)
 579 {
 580         proc_t *proc = proc_find (_curr_task);
 581
 582         if (!proc)
 583                 return;
 584
 585         tty_change (proc->tty);
 586 }
 587
 588 void sys_gexit (struct regs *r)
 589 {
 590         video_gfx_exit ();
 591 }
 592
 593 extern unsigned char vgagui;
 594 extern tty_t *gtty;
 595 void sys_gttyinit (struct regs *r)
 596 {
 597         tty_t *tty = gtty_init ();
 598
 599         if (!tty)
 600                 return;
 601
 602         r->eax = (unsigned) &tty->screen;
 603 }
 604
 605 void sys_free (struct regs *r)
 606 {
 607         proc_t *proc = proc_find (_curr_task);
 608
 609         paging_disable ();
 610
 611         ufree (proc, (void *) r->ebx);
 612
 613         DPRINT ("free (): 0x%x", r->ebx);
 614
 615         paging_enable ();
 616 }
 617
 618 void sys_realloc (struct regs *r)
 619 {
 620         proc_t *proc = proc_find (_curr_task);
 621
 622         paging_disable ();
 623
 624         r->eax = (unsigned) urealloc (proc, (void *) r->ebx, (size_t) r->ecx);
 625
 626         DPRINT ("realloc (): 0x%x", r->eax);
 627
 628         paging_enable ();
 629 }
 630
 631 void sys_gethostbyname (struct regs *r)
 632 {
 633         char *buf = (char *) r->ebx;
 634
 635         if (!buf) {
 636                 r->eax = 0;
 637                 return;
 638         }
 639
 640         r->eax = (unsigned) gethostbyname (buf);
 641 }
 642
 643 void sys_procmap (struct regs *r)
 644 {
 645         proc_t *proc = proc_find (_curr_task);
 646
 647         if (!proc)
 648                 return;
 649
 650         printf ("LOL: '%s'\n", proc->data-0x1000);
 651         //proc_vmem_map (proc);
 652 }
 653
 654 void sys_sendto (struct regs *r)
 655 {
 656         /* HACK: bleeh, there is problem with fourth argument,
 657                 so we need to use another way to getting address */
 658         unsigned *addr = (unsigned *) 0x9020;
 659
 660         sockaddr_in *to = (sockaddr_in *) *addr;
 661
 662         int ret = sendto ((int) r->ecx, (char *) r->ebx, (unsigned) r->edx, 0, to, 0);
 663
 664         int *memptr = (int *) 0x9000;
 665         *memptr = ret;
 666 }
 667
 668 void sys_recvfrom (struct regs *r)
 669 {
 670         unsigned char *msg = (unsigned char *) r->ebx;
 671
 672         /* HACK: bleeh, there is problem with fourth argument,
 673                 so we need to use another way to getting address */
 674         unsigned *addr = (unsigned *) 0x9010;
 675
 676         sockaddr_in *from = (sockaddr_in *) *addr;
 677
 678         int ret = recvfrom ((int) r->ecx, (char *) msg, (unsigned) r->edx, 0, from, 0);
 679
 680         int *memptr = (int *) 0x9000;
 681         *memptr = ret;
 682 }
 683
 684 void sys_getchar (struct regs *r)
 685 {
 686         proc_t *proc = proc_find (_curr_task);
 687
 688         int i = 1;
 689         unsigned char s = '\n';
 690
 691         int *memptr = (int *) 0x9064;
 692
 693         /* non-blocking mode */
 694         if (stdin->flags & O_NONBLOCK) {
 695                 if (!proc)
 696                         return;
 697
 698                 if (proc->tty != currtty)
 699                         return;
 700
 701                 unsigned char c = getkey ();
 702
 703                 if (!c) {
 704                         *memptr = -1;
 705                         return;
 706                 }
 707
 708                 tty_putnch (proc->tty, c);
 709
 710                 *memptr = c;
 711
 712                 return;
 713         }
 714
 715         /* blocking - clasical mode */
 716         while (1) {
 717                 if (!proc)
 718                         return;
 719
 720                 if (proc->tty != currtty)
 721                         return;
 722
 723                 char c = getkey ();
 724
 725                 if (c) {
 726                         if (i > 0 && c != '\b')
 727                                 tty_write (proc->tty, &c, 1);
 728
 729                         if (c == '\n')
 730                                 break;
 731                         else if (i == 1)
 732                                 s = c;
 733
 734                         if (c == '\b') {
 735                                 if (i > 1) {
 736                                         i --;
 737                                         tty_write (proc->tty, "\b", 1);
 738                                 }
 739                         } else
 740                                 i ++;
 741                 }
 742         }
 743
 744         *memptr = (int) s;
 745 }
 746
 747 void sys_threadopen (struct regs *r)
 748 {
 749         void *ptr = (void *) r->ebx;
 750
 751         unsigned *memptr = (unsigned *) 0x9050;
 752
 753         unsigned ret = proc_thread_create (ptr, (void *) *memptr);
 754
 755         *memptr = ret;
 756 }
 757
 758 void sys_threadclose (struct regs *r)
 759 {
 760         proc_t *proc = proc_find (_curr_task);
 761
 762         if (!proc)
 763                 return;
 764
 765         unsigned *memptr = (unsigned *) 0x9050;
 766
 767         task_t *task = _curr_task;
 768
 769         /* free child process thread */
 770         *memptr = proc_thread_destroy (proc, task);
 771
 772         task = proc->tty->task;
 773
 774         if (int_disable ())
 775                 longjmp (task->state, 1);
 776         else
 777                 while (1)
 778                         schedule ();
 779
 780 }
 781
 782 void sys_ioctl (struct regs *r)
 783 {
 784         void *s = (void *) r->ebx;
 785         unsigned id = r->ecx;
 786         int l = r->edx;
 787
 788         int ret = ioctl_call (id, s, l);
 789
 790         r->eax = (int) &ret;
 791 }
 792
 793 void sys_getpid (struct regs *r)
 794 {
 795         proc_t *proc = proc_find (_curr_task);
 796
 797         if (!proc)
 798                 return;
 799
 800         r->eax = (int) &proc->pid;
 801 }
 802
 803 void sys_lseek (struct regs *r)
 804 {
 805         int fd = r->ebx;
 806         long offset = r->ecx;
 807         int whence = r->edx;
 808
 809         long ret = lseek (fd, offset, whence);
 810
 811         long *memptr = (long *) 0x9006;
 812
 813         *memptr = ret;
 814 }
 815
 816 void sys_pipe (struct regs *r)
 817 {
 818         int *p = (int *) r->ebx;
 819
 820         int ret = pipe (p);
 821
 822         r->eax = (int) &ret;
 823 }
 824
 825 void sys_creat (struct regs *r)
 826 {
 827         char *file = (char *) r->ebx;
 828         unsigned mode = r->ecx; /* TODO: mode */
 829
 830         int ret = -1;
 831
 832         if (file) {
 833                 if (mode == O_CREAT)
 834                         ret = (touch (file) == 1) ? 0 : -1;
 835         } else
 836                 errno_set (EFAULT);
 837
 838         r->eax = (int) &ret;
 839 }
 840
 841 void sys_mkdir (struct regs *r)
 842 {
 843         char *dir = (char *) r->ebx;
 844         unsigned mode = r->ecx; /* TODO: mode */
 845
 846         int ret = -1;
 847
 848         if (dir) {
 849                 if (mode)
 850                         ret = (mkdir (dir) == 1) ? 0 : -1;
 851         } else
 852                 errno_set (EFAULT);
 853
 854         r->eax = (int) &ret;
 855 }
 856
 857 void sys_rmdir (struct regs *r)
 858 {
 859         char *dir = (char *) r->ebx;
 860
 861         int ret = -1;
 862
 863         if (dir) {
 864                 ret = (rm (dir) == 1) ? 0 : -1;
 865         } else
 866                 errno_set (EFAULT);
 867
 868         r->eax = (int) &ret;
 869 }
 870
 871 void syscall_handler (struct regs *r)
 872 {
 873         switch (r->eax) {
 874                 case 1:
 875                         return sys_exit (r);
 876                 case 2:
 877                         return sys_getch (r);
 878                 case 3:
 879                         return sys_sleep (r);
 880                 case 4:
 881                         return sys_putch (r);
 882                 case 5:
 883                         return sys_color (r);
 884                 case 6:
 885                         return sys_cls (r);
 886                 case 7:
 887                         return sys_getkey (r);
 888                 case 8:
 889                         return sys_gotoxy (r);
 890                 case 9:
 891                         return sys_fork (r);
 892                 case 10:
 893                         return sys_schedule (r);
 894                 case 11:
 895                         return sys_write (r);
 896                 case 12:
 897                         return sys_socket (r);
 898                 case 13:
 899                         return sys_connect (r);
 900                 case 14:
 901                         return sys_malloc (r);
 902                 case 15:
 903                         return sys_send (r);
 904                 case 16:
 905                         return sys_recv (r);
 906                 case 17:
 907                         return sys_close (r);
 908                 case 18:
 909                         return sys_open (r);
 910                 case 19:
 911                         return sys_pcspk (r);
 912                 case 20:
 913                         return sys_usleep (r);
 914                 case 21:
 915                         return sys_read (r);
 916                 case 22:
 917                         return sys_time (r);
 918                 case 23:
 919                         return sys_system (r);
 920                 case 24:
 921                         return sys_chdir (r);
 922                 case 25:
 923                         return sys_getdir (r);
 924                 case 26:
 925                         return sys_procarg (r);
 926                 case 27:
 927                         return sys_signal (r);
 928                 case 28:
 929                         return sys_mount (r);
 930                 case 29:
 931                         return sys_kputs (r);
 932                 case 30:
 933                         return sys_bind (r);
 934                 case 31:
 935                         return sys_listen (r);
 936                 case 32:
 937                         return sys_accept (r);
 938                 case 33:
 939                         return sys_fcntl (r);
 940                 case 34:
 941                         return sys_gvgafb (r);
 942                 case 35:
 943                         return sys_gcls (r);
 944                 case 36:
 945                         return sys_gfbswap (r);
 946                 case 37:
 947                         return sys_rs232read (r);
 948                 case 38:
 949                         return sys_rs232write (r);
 950                 case 39:
 951                         return sys_gttyexit (r);
 952                 case 40:
 953                         return sys_gexit (r);
 954                 case 41:
 955                         return sys_gttyinit (r);
 956                 case 42:
 957                         return;
 958                 case 43:
 959                         return sys_free (r);
 960                 case 44:
 961                         return sys_realloc (r);
 962                 case 45:
 963                         return sys_gethostbyname (r);
 964                 case 46:
 965                         return sys_procmap (r);
 966                 case 47:
 967                         return sys_sendto (r);
 968                 case 48:
 969                         return sys_recvfrom (r);
 970                 case 49:
 971                         return sys_getchar (r);
 972                 case 50:
 973                         return sys_threadopen (r);
 974                 case 51:
 975                         return sys_threadclose (r);
 976                 case 52:
 977                         return sys_ioctl (r);
 978                 case 53:
 979                         return sys_getpid (r);
 980                 case 54:
 981                         return sys_lseek (r);
 982                 case 55:
 983                         return sys_pipe (r);
 984                 case 56:
 985                         return sys_creat (r);
 986                 case 57:
 987                         return sys_mkdir (r);
 988                 case 58:
 989                         return sys_rmdir (r);
 990         }
 991 }