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