kernel/core/proc.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2007  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   5  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   6  *  Copyright (C) 2010  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   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 <string.h>
  25 #include <proc.h>
  26 #include <tty.h>
  27 #include <task.h>
  28 #include <signal.h>
  29 #include <build.h>
  30 #include <paging.h>
  31 #include <vfs.h>
  32 #include <net/socket.h>
  33 #include <fd.h>
  34
  35 static void *thread_arg;
  36 static void *(*thread_entry) (void *);
  37
  38 static pid_t newpid = 0;
  39
  40 proc_t proc_list;
  41 proc_t proc_kernel;
  42
  43 extern task_t task_list;
  44 extern task_t *_curr_task;
  45 extern unsigned long timer_ticks;
  46
  47 pid_t fork ()
  48 {
  49         proc_t *p = proc_find (_curr_task);
  50
  51         if (!p)
  52                 return 0;
  53
  54 #ifdef ARCH_i386
  55         return proc_create (p->tty, p->name, p->task->state[0].JMPBUF_IP)->pid;
  56 #endif
  57 }
  58
  59 void proc_display ()
  60 {
  61         printf ("PID\tCMD\tMEM\n");
  62
  63         proc_t *proc;
  64         for (proc = proc_list.next; proc != &proc_list; proc = proc->next)
  65                 printf ("%d\t%s\t%dkB\n", proc->pid, proc->name, umem_used_proc (proc) / 1024);
  66 }
  67
  68 void proc_top ()
  69 {
  70         tty_t *tty = currtty;
  71
  72         unsigned long ltime = 0;
  73
  74         for (;;) {
  75                 if (tty != currtty) {
  76                         schedule ();
  77                         continue;
  78                 }
  79
  80                 tty_cls (tty);
  81
  82                 printf ("TID\tTASK\t\tCPU Usage\n");
  83
  84                 task_t *task;
  85                 for (task = task_list.next; task != &task_list; task = task->next) {
  86                         unsigned usage = 100 - ((task->lasttick - ltime) / 10);
  87                         char name[17];
  88                         memset (name, ' ', 16);
  89                         memcpy (name, task->name, strlen (task->name) > 16 ? 16 : strlen (task->name));
  90                         name[16] = '\0';
  91
  92                         printf ("%d\t%s%d%%\n", task->id, name, usage > 100 ? 100 : usage);
  93                         schedule ();
  94                 }
  95
  96
  97                 proc_t *proc;
  98                 for (proc = proc_list.next; proc != &proc_list; proc = proc->next) {
  99                         printf ("\nPID\tCMD\t\tMEM\tCPU Usage\n");
 100                         break;
 101                 }
 102
 103                 for (proc = proc_list.next; proc != &proc_list; proc = proc->next) {
 104                         schedule ();
 105                         unsigned usage = 100 - ((proc->task->lasttick - ltime) / 10);
 106                         char name[17];
 107                         memset (name, ' ', 16);
 108                         memcpy (name, proc->task->name, strlen (proc->task->name) > 16 ? 16 : strlen (proc->task->name));
 109                         name[16] = '\0';
 110                         printf ("%d\t%s%dkB\t%d%%\n", proc->pid, name, umem_used_proc (proc) / 1024, usage > 100 ? 100 : usage);
 111                 }
 112
 113                 unsigned long stime = timer_ticks;
 114
 115                 ltime = timer_ticks;
 116
 117                 /* timeout for 1s */
 118                 while ((stime+1000) >= timer_ticks) {
 119                         if (getkey () == 'q')
 120                                 return;
 121
 122                         schedule ();
 123                 }
 124         }
 125 }
 126
 127 proc_t *proc_find (task_t *task)
 128 {
 129         proc_t *proc;
 130         for (proc = proc_list.next; proc != &proc_list; proc = proc->next) {
 131                 if (!proc->task)
 132                         continue;
 133
 134                 if (proc->task->id == task->id)
 135                         return proc;
 136         }
 137
 138         return 0;
 139 }
 140
 141 proc_t *proc_findbypid (pid_t pid)
 142 {
 143         proc_t *proc;
 144         for (proc = proc_list.next; proc != &proc_list; proc = proc->next) {
 145                 if (proc->pid == pid)
 146                         return proc;
 147         }
 148
 149         return 0;
 150 }
 151
 152 unsigned proc_fd_close (proc_t *proc)
 153 {
 154         fd_t *f;
 155
 156         unsigned i;
 157
 158         for (;;) {
 159                 i = 0;
 160                 for (f = fd_list.next; f != &fd_list; f = f->next) {
 161                         if (f->proc == proc) {
 162                                 if (f->flags & FD_SOCK) // socket close
 163                                         sclose (f->id);
 164
 165                                 fd_delete (f);
 166
 167                                 i ++;
 168                                 break;
 169                         }
 170                 }
 171
 172                 if (!i)
 173                         return 1;
 174         }
 175
 176         return 0;
 177 }
 178
 179 proc_t *proc_create (tty_t *tty, char *name, unsigned entry)
 180 {
 181         proc_t *proc = NULL;
 182         task_t *task = (task_t *) task_create (name, entry, PROC_USER_PRIORITY);
 183
 184         if (!task) {
 185                 DPRINT (DBG_PROC, "proc_create () - !task");
 186                 return 0;
 187         }
 188
 189         /* alloc and init context */
 190         proc = (proc_t *) kmalloc (sizeof (proc_t));
 191
 192         if (!proc) {
 193                 DPRINT (DBG_PROC, "proc_create () - !proc");
 194                 return 0;
 195         }
 196
 197         /* remember task, because we need it for scheduler work */
 198         proc->task = task;
 199
 200         /* remember new pid of process */
 201         proc->pid = ++ newpid;
 202
 203         /* remember tty, where we start this process */
 204         proc->tty = tty;
 205
 206         /* setup process name */
 207         strcpy (proc->name, name);
 208
 209         /* clear process info */
 210         proc->start = 0;
 211         proc->code = 0;
 212         proc->data = 0;
 213         proc->data_off = 0;
 214         proc->bss = 0;
 215         proc->end = 0;
 216
 217         proc->argc = 0;
 218         proc->argv = 0;
 219
 220         proc->flags = 0;
 221
 222         /* add structure into process list */
 223         proc->next = &proc_list;
 224         proc->prev = proc_list.prev;
 225         proc->prev->next = proc;
 226         proc->next->prev = proc;
 227
 228         /* create virtual file in /proc with name of new process */
 229         vfs_list_add (name, VFS_FILEATTR_FILE | VFS_FILEATTR_SYSTEM, "/proc/");
 230
 231         DPRINT (DBG_PROC, "proc -> %s, pid %d, entry 0x%x", name, newpid, entry);
 232
 233         return proc;
 234 }
 235
 236 extern bool task_done (task_t *task);
 237 bool proc_done (proc_t *proc)
 238 {
 239         if (proc) {
 240                 /* verify task structure */
 241                 if (!proc->task)
 242                         return 0;
 243 #ifdef ARCH_i386
 244                 /* unmap memory pages */
 245                 proc_vmem_unmap (proc);
 246 #endif
 247                 /* delete all tasks from process context */
 248                 unsigned short id = proc->task->id;
 249
 250                 for (;;) {
 251                         task_t *task = task_find (id);
 252
 253                         if (!task)
 254                                 break;
 255
 256                         if (!task_done (task))
 257                                 return 0;
 258                 }
 259
 260                 DPRINT (DBG_PROC, "proc -> pid %d done", proc->pid);
 261
 262                 /* close all un-closed file descriptors */
 263                 proc_fd_close (proc);
 264
 265                 /* delete process from context */
 266                 proc->next->prev = proc->prev;
 267                 proc->prev->next = proc->next;
 268
 269                 proc->task = 0;
 270
 271                 /* free memory from process parameters */
 272                 proc_arg_free (proc);
 273
 274                 /* free all memory blocks allocated by process */
 275                 ufree_proc (proc);
 276
 277                 /* free process structure */
 278                 kfree (proc);
 279
 280                 return 1;
 281         }
 282
 283         return 0;
 284 }
 285
 286 bool proc_signal (proc_t *proc, unsigned signal)
 287 {
 288 #ifdef ARCH_i386
 289         if (!proc)
 290                 return 0;
 291
 292         /* check for daemon */
 293         if (proc->flags & PROC_FLAG_DAEMON)
 294                 return 0;
 295
 296         task_t *task = proc->tty->task;
 297
 298         /* this unlock tty, enable itrs, etc (see command_exec ())*/
 299         proc->pid = 0;
 300
 301         /* disable interrupts */
 302         if (!int_disable ())
 303                 return 0;
 304
 305         /* jump back from app code to kernel code (task) */
 306         longjmp (task->state, 1);
 307 #else
 308         DPRINT (DBG_PROC, "proc_signal: Not implemented for this platform !");
 309 #endif
 310         return 1;
 311 }
 312
 313 sighandler_t signal (int signum, sighandler_t handler)
 314 {
 315         /* try to search current process */
 316         proc_t *proc = proc_find (_curr_task);
 317
 318         if (!proc)
 319                 return 0;
 320
 321         if (proc->task != _curr_task)
 322                 return 0;
 323
 324         if (proc->tty != currtty)
 325                 return 0;
 326
 327         /* send signal to current process */
 328         proc_signal (proc, signum);
 329
 330         return handler;
 331 }
 332
 333 bool proc_arg_set (proc_t *proc, char *arg, unsigned argl)
 334 {
 335         if (!proc)
 336                 return 0;
 337
 338         unsigned i = 0;
 339         unsigned y = 0;
 340         unsigned x = 0;
 341
 342         if (proc->argc)
 343                 return 0;
 344
 345         /* First calculate length of array */
 346         if (argl)
 347         while (i < (argl+1)) {
 348                 if (arg[i] == ' ' || arg[i] == '\0')
 349                         x ++;
 350
 351                 i ++;
 352         }
 353
 354         proc->argv = (char **) kmalloc (sizeof (unsigned) * (x+2));
 355
 356         if (!proc->argv)
 357                 return 0;
 358
 359         proc->argc = x+1;       /* +1 because argv[0] is name of process so it is one entry */
 360
 361         /* setup program name entry */
 362         i = strlen (proc->name);
 363
 364         proc->argv[0] = (char *) kmalloc (sizeof (char) * (i+1));
 365         memcpy (proc->argv[0], proc->name, i);
 366         proc->argv[0][i] = '\0';
 367
 368         x = 1;
 369         i = 0;
 370
 371         /* assign values to array */
 372         while (i < (argl+1)) {
 373                 if (arg[i] == ' ' || arg[i] == '\0' || i == argl) {
 374                         if (!y) {
 375                                 proc->argv[x] = (char *) kmalloc (sizeof (char) * (i+1));
 376
 377                                 if (!proc->argv[x])
 378                                         return 0;
 379
 380                                 memcpy (proc->argv[x], arg, i);
 381                                 proc->argv[x][i] = '\0';
 382                         } else {
 383                                 proc->argv[x] = (char *) kmalloc (sizeof (char) * (i+1-y));
 384
 385                                 if (!proc->argv[x])
 386                                         return 0;
 387
 388                                 memcpy (proc->argv[x], arg+y+1, i-y-1);
 389                                 proc->argv[x][i-y-1] = '\0';
 390                         }
 391
 392                         y = i;
 393                         x ++;
 394                 }
 395
 396                 i ++;
 397         }
 398
 399         return 1;
 400 }
 401
 402 bool proc_arg_free (proc_t *proc)
 403 {
 404         if (!proc)
 405                 return 0;
 406
 407         if (!proc->argv || !proc->argc)
 408                 return 0;
 409
 410         unsigned i = 0;
 411
 412         while (i < proc->argc) {
 413                 kfree (proc->argv[i]);
 414                 i ++;
 415         }
 416
 417         kfree (proc->argv);
 418
 419         proc->argc = 0;
 420
 421         return 1;
 422 }
 423
 424 bool proc_arg_get (proc_t *proc, unsigned *argc, char **argv)
 425 {
 426         if (!proc)
 427                 return 0;
 428
 429         if (!proc->argv || !proc->argc || !argc)
 430                 return 0;
 431
 432         argv = proc->argv;
 433         *argc = proc->argc;
 434
 435         return 1;
 436 }
 437
 438 bool proc_flag_set (proc_t *proc, unsigned short flag)
 439 {
 440         if (!proc)
 441                 return 0;
 442
 443         if (proc->flags & flag)
 444                 return 0;
 445
 446         proc->flags |= flag;
 447
 448         return 1;
 449 }
 450
 451 unsigned proc_page_fault ()
 452 {
 453         proc_t *proc = proc_find (_curr_task);
 454
 455         if (!proc)
 456                 return 0;
 457
 458         video_color (15, 0);
 459         printf ("%s: signal SIGSEGV\n", proc->name);
 460
 461         /* send SIGSEGV signal to running process */
 462         proc_signal (proc, SIGSEGV);
 463
 464         return 1;
 465 }
 466
 467 unsigned proc_vmem_map (proc_t *proc)
 468 {
 469 #ifdef ARCH_i386
 470         /* create new page_cover "shield" for process */
 471         proc->task->page_cover = (page_ent_t *) page_cover_create ();
 472
 473         /* map kernel space */
 474         page_mmap (proc->task->page_cover, (void *) 0x0, (void *) 0x400000, 1, 0);
 475
 476         /* map VESA double buffer memory - enough for 16bit 800x600 - 1MB for framebuffer */
 477         page_mmap (proc->task->page_cover, (void *) 0x400000, (void *) proc->start, 1, 0);
 478
 479         /* calculate size of process image (binary file) */
 480         unsigned p = (unsigned) palign ((void *) (proc->end - proc->start));
 481
 482         /* map process image - app should think, that it is placed at 8MB in ram */
 483         page_mmap (proc->task->page_cover, (void *) 0x800000, (void *) 0x800000+p, 0, 1);
 484
 485         /* map end of kernel space */
 486         page_mmap (proc->task->page_cover, (void *) proc->start+p, (void *) 0x800000, 1, 0);
 487
 488         proc->heap = 0x800000;
 489 #endif
 490         return 1;
 491 }
 492
 493 unsigned proc_vmem_unmap (proc_t *proc)
 494 {
 495         if (!proc)
 496                 return 0;
 497
 498         if (!proc->task)
 499                 return 0;
 500 #ifdef ARCH_i386
 501         if (!proc->task->page_cover)
 502                 return 0;
 503
 504         page_ent_t *page_cover = proc->task->page_cover;
 505
 506         /* switch to kernel page directory */
 507         page_dir_switch (task_list.next->page_cover->page_dir);
 508
 509         /* unmap kernel area */
 510         page_unmmap (page_cover, (void *) 0x0, (void *) 0x400000);
 511
 512         /* unmap framebuffer area */
 513         //page_unmmap (page_cover, (void *) 0x400000, (void *) 0x500000);
 514
 515         /* unmap process image */
 516         page_unmmap (page_cover, (void *) 0x400000, (void *) proc->start);
 517
 518         unsigned p = (unsigned) palign ((void *) (proc->end - proc->start));
 519
 520         /* unmap end of user-space */
 521         page_unmmap (page_cover, (void *) 0x800000, (void *) 0x800000+p);
 522
 523         /* unmap the rest */
 524         page_unmmap (page_cover, (void *) proc->start+p, (void *) 0x800000);
 525
 526         /* unmap the allocated memory */
 527         page_unmmap (page_cover, (void *) 0x800000+p, (void *) proc->heap+p);
 528
 529         if (!page_cover_delete (page_cover)) {
 530                 DPRINT (DBG_PROC, "ERROR -> proc_vmem_unmap () - proc: %s", proc->name);
 531                 return 0;
 532         }
 533
 534         proc->task->page_cover = 0;
 535 #endif
 536         return 1;
 537 }
 538
 539 void proc_thread_context ()
 540 {
 541         thread_entry (thread_arg);
 542 #ifdef ARCH_i386
 543         sys_threadclose (0);
 544 #endif
 545 }
 546
 547 unsigned proc_thread_create (void *entry, void *arg)
 548 {
 549         proc_t *proc = proc_find (_curr_task);
 550
 551         if (!proc)
 552                 return 0;
 553
 554         char *name = proc->name;
 555
 556         unsigned p = (unsigned) entry;
 557
 558         thread_entry = (void *) p;
 559         thread_arg = arg;
 560
 561         /* create new process thread */
 562         task_t *task = (task_t *) task_create (name, (unsigned) &proc_thread_context, PROC_USER_PRIORITY);
 563
 564         if (!task)
 565                 return 0;
 566
 567         /* HACK: set task id same as current task (our process) */
 568         if (proc->task) {
 569                 task->id = proc->task->id;
 570 #ifdef ARCH_i386
 571                 /* use same page_cover too for correctly paging */
 572                 if (proc->task->page_cover)
 573                         task->page_cover = proc->task->page_cover;
 574 #endif
 575         }
 576
 577         DPRINT (DBG_PROC, "process: new thread '%s' : 0x%x", name, p);
 578
 579         /* NOTE: this is pretty needed, because thread argument and entry point is then same as previous */
 580         schedule ();
 581
 582         return 1;
 583 }
 584
 585 unsigned proc_thread_destroy (proc_t *proc, task_t *task)
 586 {
 587         /* we won't close main process thread */
 588         if (proc->task == task)
 589                 return 0;
 590
 591         if (!task_done (task))
 592                 return 0;
 593
 594         DPRINT (DBG_PROC, "process: close thread '%s'", task->name);
 595
 596         return 1;
 597 }
 598
 599 unsigned int init_proc (void)
 600 {
 601         proc_list.next = &proc_list;
 602         proc_list.prev = &proc_list;
 603
 604         proc_kernel.task = task_find (0);
 605 #ifdef ARCH_i386
 606         proc_kernel.heap = PAGE_MEM_HIGH;
 607 #endif
 608         proc_kernel.start = 0;
 609         proc_kernel.end = 0;
 610
 611         return 1;
 612 }