servers/vfs/misc.c

   1 /* This file contains a collection of miscellaneous procedures.  Some of them
   2  * perform simple system calls.  Some others do a little part of system calls
   3  * that are mostly performed by the Memory Manager.
   4  *
   5  * The entry points into this file are
   6  *   do_dup:      perform the DUP system call
   7  *   do_fcntl:    perform the FCNTL system call
   8  *   do_sync:     perform the SYNC system call
   9  *   do_fsync:    perform the FSYNC system call
  10  *   pm_reboot:   sync disks and prepare for shutdown
  11  *   pm_fork:     adjust the tables after PM has performed a FORK system call
  12  *   do_exec:     handle files with FD_CLOEXEC on after PM has done an EXEC
  13  *   do_exit:     a process has exited; note that in the tables
  14  *   do_set:      set uid or gid for some process
  15  *   do_revive:   revive a process that was waiting for something (e.g. TTY)
  16  *   do_svrctl:   file system control
  17  *   do_getsysinfo:     request copy of FS data structure
  18  *   pm_dumpcore: create a core dump
  19  */
  20
  21 #include "fs.h"
  22 #include <fcntl.h>
  23 #include <assert.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #include <minix/callnr.h>
  27 #include <minix/safecopies.h>
  28 #include <minix/endpoint.h>
  29 #include <minix/com.h>
  30 #include <minix/sysinfo.h>
  31 #include <minix/u64.h>
  32 #include <sys/ptrace.h>
  33 #include <sys/svrctl.h>
  34 #include "file.h"
  35 #include "fproc.h"
  36 #include "scratchpad.h"
  37 #include "dmap.h"
  38 #include <minix/vfsif.h>
  39 #include "vnode.h"
  40 #include "vmnt.h"
  41 #include "param.h"
  42
  43 #define CORE_NAME       "core"
  44 #define CORE_MODE       0777    /* mode to use on core image files */
  45
  46 #if ENABLE_SYSCALL_STATS
  47 unsigned long calls_stats[NCALLS];
  48 #endif
  49
  50 static void free_proc(struct fproc *freed, int flags);
  51 /*
  52 static int dumpcore(int proc_e, struct mem_map *seg_ptr);
  53 static int write_bytes(struct inode *rip, off_t off, char *buf, size_t
  54         bytes);
  55 static int write_seg(struct inode *rip, off_t off, int proc_e, int seg,
  56         off_t seg_off, phys_bytes seg_bytes);
  57 */
  58
  59 /*===========================================================================*
  60  *                              do_getsysinfo                                *
  61  *===========================================================================*/
  62 int do_getsysinfo()
  63 {
  64   vir_bytes src_addr, dst_addr;
  65   size_t len, buf_size;
  66   int what;
  67
  68   what = job_m_in.SI_WHAT;
  69   dst_addr = (vir_bytes) job_m_in.SI_WHERE;
  70   buf_size = (size_t) job_m_in.SI_SIZE;
  71
  72   /* Only su may call do_getsysinfo. This call may leak information (and is not
  73    * stable enough to be part of the API/ABI). In the future, requests from
  74    * non-system processes should be denied.
  75    */
  76
  77   if (!super_user) return(EPERM);
  78
  79   switch(what) {
  80     case SI_PROC_TAB:
  81         src_addr = (vir_bytes) fproc;
  82         len = sizeof(struct fproc) * NR_PROCS;
  83         break;
  84     case SI_DMAP_TAB:
  85         src_addr = (vir_bytes) dmap;
  86         len = sizeof(struct dmap) * NR_DEVICES;
  87         break;
  88 #if ENABLE_SYSCALL_STATS
  89     case SI_CALL_STATS:
  90         src_addr = (vir_bytes) calls_stats;
  91         len = sizeof(calls_stats);
  92         break;
  93 #endif
  94     default:
  95         return(EINVAL);
  96   }
  97
  98   if (len != buf_size)
  99         return(EINVAL);
 100
 101   return sys_datacopy(SELF, src_addr, who_e, dst_addr, len);
 102 }
 103
 104 /*===========================================================================*
 105  *                              do_dup                                       *
 106  *===========================================================================*/
 107 int do_dup()
 108 {
 109 /* Perform the dup(fd) or dup2(fd,fd2) system call. These system calls are
 110  * obsolete.  In fact, it is not even possible to invoke them using the
 111  * current library because the library routines call fcntl().  They are
 112  * provided to permit old binary programs to continue to run.
 113  */
 114
 115   int rfd, rfd2;
 116   struct filp *f;
 117   int r = OK;
 118
 119   scratch(fp).file.fd_nr = job_m_in.fd;
 120   rfd2 = job_m_in.fd2;
 121
 122   /* Is the file descriptor valid? */
 123   rfd = scratch(fp).file.fd_nr & ~DUP_MASK;     /* kill off dup2 bit, if on */
 124   if ((f = get_filp(rfd, VNODE_READ)) == NULL) return(err_code);
 125
 126   /* Distinguish between dup and dup2. */
 127   if (!(scratch(fp).file.fd_nr & DUP_MASK)) {           /* bit not on */
 128         /* dup(fd) */
 129         r = get_fd(0, 0, &rfd2, NULL);
 130   } else {
 131         /* dup2(old_fd, new_fd) */
 132         if (rfd2 < 0 || rfd2 >= OPEN_MAX) {
 133                 r = EBADF;
 134         } else if (rfd == rfd2) {       /* ignore the call: dup2(x, x) */
 135                 r = rfd2;
 136         } else {
 137                 /* All is fine, close new_fd if necessary */
 138                 unlock_filp(f);         /* or it might deadlock on do_close */
 139                 (void) close_fd(fp, rfd2);      /* cannot fail */
 140                 f = get_filp(rfd, VNODE_READ); /* lock old_fd again */
 141                 if (f == NULL) return(err_code);
 142         }
 143   }
 144
 145   if (r == OK) {
 146         /* Success. Set up new file descriptors. */
 147         f->filp_count++;
 148         fp->fp_filp[rfd2] = f;
 149         FD_SET(rfd2, &fp->fp_filp_inuse);
 150         r = rfd2;
 151   }
 152
 153   unlock_filp(f);
 154   return(r);
 155 }
 156
 157 /*===========================================================================*
 158  *                              do_fcntl                                     *
 159  *===========================================================================*/
 160 int do_fcntl()
 161 {
 162 /* Perform the fcntl(fd, request, ...) system call. */
 163
 164   register struct filp *f;
 165   int new_fd, fl, r = OK, fcntl_req, fcntl_argx;
 166   tll_access_t locktype;
 167
 168   scratch(fp).file.fd_nr = job_m_in.fd;
 169   scratch(fp).io.io_buffer = job_m_in.buffer;
 170   scratch(fp).io.io_nbytes = job_m_in.nbytes;   /* a.k.a. m_in.request */
 171   fcntl_req = job_m_in.request;
 172   fcntl_argx = job_m_in.addr;
 173
 174   /* Is the file descriptor valid? */
 175   locktype = (fcntl_req == F_FREESP) ? VNODE_WRITE : VNODE_READ;
 176   if ((f = get_filp(scratch(fp).file.fd_nr, locktype)) == NULL)
 177         return(err_code);
 178
 179   switch (fcntl_req) {
 180     case F_DUPFD:
 181         /* This replaces the old dup() system call. */
 182         if (fcntl_argx < 0 || fcntl_argx >= OPEN_MAX) r = EINVAL;
 183         else if ((r = get_fd(fcntl_argx, 0, &new_fd, NULL)) == OK) {
 184                 f->filp_count++;
 185                 fp->fp_filp[new_fd] = f;
 186                 FD_SET(new_fd, &fp->fp_filp_inuse);
 187                 r = new_fd;
 188         }
 189         break;
 190
 191     case F_GETFD:
 192         /* Get close-on-exec flag (FD_CLOEXEC in POSIX Table 6-2). */
 193         r = 0;
 194         if (FD_ISSET(scratch(fp).file.fd_nr, &fp->fp_cloexec_set))
 195                 r = FD_CLOEXEC;
 196         break;
 197
 198     case F_SETFD:
 199         /* Set close-on-exec flag (FD_CLOEXEC in POSIX Table 6-2). */
 200         if (fcntl_argx & FD_CLOEXEC)
 201                 FD_SET(scratch(fp).file.fd_nr, &fp->fp_cloexec_set);
 202         else
 203                 FD_CLR(scratch(fp).file.fd_nr, &fp->fp_cloexec_set);
 204         break;
 205
 206     case F_GETFL:
 207         /* Get file status flags (O_NONBLOCK and O_APPEND). */
 208         fl = f->filp_flags & (O_NONBLOCK | O_APPEND | O_ACCMODE);
 209         r = fl;
 210         break;
 211
 212     case F_SETFL:
 213         /* Set file status flags (O_NONBLOCK and O_APPEND). */
 214         fl = O_NONBLOCK | O_APPEND | O_REOPEN;
 215         f->filp_flags = (f->filp_flags & ~fl) | (fcntl_argx & fl);
 216         break;
 217
 218     case F_GETLK:
 219     case F_SETLK:
 220     case F_SETLKW:
 221         /* Set or clear a file lock. */
 222         r = lock_op(f, fcntl_req);
 223         break;
 224
 225     case F_FREESP:
 226      {
 227         /* Free a section of a file */
 228         off_t start, end;
 229         struct flock flock_arg;
 230         signed long offset;
 231
 232         /* Check if it's a regular file. */
 233         if (!S_ISREG(f->filp_vno->v_mode)) r = EINVAL;
 234         else if (!(f->filp_mode & W_BIT)) r = EBADF;
 235         else
 236                 /* Copy flock data from userspace. */
 237                 r = sys_datacopy(who_e, (vir_bytes) scratch(fp).io.io_buffer,
 238                                  SELF, (vir_bytes) &flock_arg,
 239                                  sizeof(flock_arg));
 240
 241         if (r != OK) break;
 242
 243         /* Convert starting offset to signed. */
 244         offset = (signed long) flock_arg.l_start;
 245
 246         /* Figure out starting position base. */
 247         switch(flock_arg.l_whence) {
 248           case SEEK_SET: start = 0; break;
 249           case SEEK_CUR:
 250                 if (ex64hi(f->filp_pos) != 0)
 251                         panic("do_fcntl: position in file too high");
 252                 start = ex64lo(f->filp_pos);
 253                 break;
 254           case SEEK_END: start = f->filp_vno->v_size; break;
 255           default: r = EINVAL;
 256         }
 257         if (r != OK) break;
 258
 259         /* Check for overflow or underflow. */
 260         if (offset > 0 && start + offset < start) r = EINVAL;
 261         else if (offset < 0 && start + offset > start) r = EINVAL;
 262         else {
 263                 start += offset;
 264                 if (start < 0) r = EINVAL;
 265         }
 266         if (r != OK) break;
 267
 268         if (flock_arg.l_len != 0) {
 269                 if (start >= f->filp_vno->v_size) r = EINVAL;
 270                 else if ((end = start + flock_arg.l_len) <= start) r = EINVAL;
 271                 else if (end > f->filp_vno->v_size) end = f->filp_vno->v_size;
 272         } else {
 273                 end = 0;
 274         }
 275         if (r != OK) break;
 276
 277         r = req_ftrunc(f->filp_vno->v_fs_e, f->filp_vno->v_inode_nr,start,end);
 278
 279         if (r == OK && flock_arg.l_len == 0)
 280                 f->filp_vno->v_size = start;
 281
 282         break;
 283      }
 284
 285     default:
 286         r = EINVAL;
 287   }
 288
 289   unlock_filp(f);
 290   return(r);
 291 }
 292
 293 /*===========================================================================*
 294  *                              do_sync                                      *
 295  *===========================================================================*/
 296 int do_sync()
 297 {
 298   struct vmnt *vmp;
 299   int r = OK;
 300
 301   for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; ++vmp) {
 302         if (vmp->m_dev != NO_DEV && vmp->m_fs_e != NONE &&
 303                  vmp->m_root_node != NULL) {
 304                 if ((r = lock_vmnt(vmp, VMNT_EXCL)) != OK)
 305                         break;
 306                 req_sync(vmp->m_fs_e);
 307                 unlock_vmnt(vmp);
 308         }
 309   }
 310
 311   return(r);
 312 }
 313
 314 /*===========================================================================*
 315  *                              do_fsync                                     *
 316  *===========================================================================*/
 317 int do_fsync()
 318 {
 319 /* Perform the fsync() system call. */
 320   struct filp *rfilp;
 321   struct vmnt *vmp;
 322   dev_t dev;
 323   int r = OK;
 324
 325   scratch(fp).file.fd_nr = job_m_in.fd;
 326
 327   if ((rfilp = get_filp(scratch(fp).file.fd_nr, VNODE_READ)) == NULL)
 328         return(err_code);
 329   dev = rfilp->filp_vno->v_dev;
 330   for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; ++vmp) {
 331         if (vmp->m_dev != NO_DEV && vmp->m_dev == dev &&
 332                 vmp->m_fs_e != NONE && vmp->m_root_node != NULL) {
 333
 334                 if ((r = lock_vmnt(vmp, VMNT_EXCL)) != OK)
 335                         break;
 336                 req_sync(vmp->m_fs_e);
 337                 unlock_vmnt(vmp);
 338         }
 339   }
 340
 341   unlock_filp(rfilp);
 342
 343   return(r);
 344 }
 345
 346 /*===========================================================================*
 347  *                              pm_reboot                                    *
 348  *===========================================================================*/
 349 void pm_reboot()
 350 {
 351   /* Perform the VFS side of the reboot call. */
 352   int i;
 353   struct fproc *rfp;
 354
 355   do_sync();
 356
 357   /* Do exit processing for all leftover processes and servers,
 358    * but don't actually exit them (if they were really gone, PM
 359    * will tell us about it).
 360    */
 361   for (i = 0; i < NR_PROCS; i++) {
 362         rfp = &fproc[i];
 363
 364         /* Don't just free the proc right away, but let it finish what it was
 365          * doing first */
 366         lock_proc(rfp, 0);
 367         if (rfp->fp_endpoint != NONE)
 368                 free_proc(rfp, 0);
 369         unlock_proc(rfp);
 370   }
 371
 372   do_sync();
 373   unmount_all();
 374 }
 375
 376 /*===========================================================================*
 377  *                              pm_fork                                      *
 378  *===========================================================================*/
 379 void pm_fork(endpoint_t pproc, endpoint_t cproc, pid_t cpid)
 380 {
 381 /* Perform those aspects of the fork() system call that relate to files.
 382  * In particular, let the child inherit its parent's file descriptors.
 383  * The parent and child parameters tell who forked off whom. The file
 384  * system uses the same slot numbers as the kernel.  Only PM makes this call.
 385  */
 386
 387   struct fproc *cp, *pp;
 388   int i, parentno, childno;
 389   mutex_t c_fp_lock;
 390
 391   /* Check up-to-dateness of fproc. */
 392   okendpt(pproc, &parentno);
 393
 394   /* PM gives child endpoint, which implies process slot information.
 395    * Don't call isokendpt, because that will verify if the endpoint
 396    * number is correct in fproc, which it won't be.
 397    */
 398   childno = _ENDPOINT_P(cproc);
 399   if (childno < 0 || childno >= NR_PROCS)
 400         panic("VFS: bogus child for forking: %d", cproc);
 401   if (fproc[childno].fp_pid != PID_FREE)
 402         panic("VFS: forking on top of in-use child: %d", childno);
 403
 404   /* Copy the parent's fproc struct to the child. */
 405   /* However, the mutex variables belong to a slot and must stay the same. */
 406   c_fp_lock = fproc[childno].fp_lock;
 407   fproc[childno] = fproc[parentno];
 408   fproc[childno].fp_lock = c_fp_lock;
 409
 410   /* Increase the counters in the 'filp' table. */
 411   cp = &fproc[childno];
 412   pp = &fproc[parentno];
 413
 414   for (i = 0; i < OPEN_MAX; i++)
 415         if (cp->fp_filp[i] != NULL) cp->fp_filp[i]->filp_count++;
 416
 417   /* Fill in new process and endpoint id. */
 418   cp->fp_pid = cpid;
 419   cp->fp_endpoint = cproc;
 420
 421   /* A forking process never has an outstanding grant, as it isn't blocking on
 422    * I/O. */
 423   if (GRANT_VALID(pp->fp_grant)) {
 424         panic("VFS: fork: pp (endpoint %d) has grant %d\n", pp->fp_endpoint,
 425                pp->fp_grant);
 426   }
 427   if (GRANT_VALID(cp->fp_grant)) {
 428         panic("VFS: fork: cp (endpoint %d) has grant %d\n", cp->fp_endpoint,
 429                cp->fp_grant);
 430   }
 431
 432   /* A child is not a process leader, not being revived, etc. */
 433   cp->fp_flags = FP_NOFLAGS;
 434
 435   /* Record the fact that both root and working dir have another user. */
 436   if (cp->fp_rd) dup_vnode(cp->fp_rd);
 437   if (cp->fp_wd) dup_vnode(cp->fp_wd);
 438 }
 439
 440 /*===========================================================================*
 441  *                              free_proc                                    *
 442  *===========================================================================*/
 443 static void free_proc(struct fproc *exiter, int flags)
 444 {
 445   int i;
 446   register struct fproc *rfp;
 447   register struct filp *rfilp;
 448   register struct vnode *vp;
 449   dev_t dev;
 450
 451   if (exiter->fp_endpoint == NONE)
 452         panic("free_proc: already free");
 453
 454   if (fp_is_blocked(exiter))
 455         unpause(exiter->fp_endpoint);
 456
 457   /* Loop on file descriptors, closing any that are open. */
 458   for (i = 0; i < OPEN_MAX; i++) {
 459         (void) close_fd(exiter, i);
 460   }
 461
 462   /* Release root and working directories. */
 463   if (exiter->fp_rd) { put_vnode(exiter->fp_rd); exiter->fp_rd = NULL; }
 464   if (exiter->fp_wd) { put_vnode(exiter->fp_wd); exiter->fp_wd = NULL; }
 465
 466   /* The rest of these actions is only done when processes actually exit. */
 467   if (!(flags & FP_EXITING)) return;
 468
 469   exiter->fp_flags |= FP_EXITING;
 470
 471   /* Check if any process is SUSPENDed on this driver.
 472    * If a driver exits, unmap its entries in the dmap table.
 473    * (unmapping has to be done after the first step, because the
 474    * dmap table is used in the first step.)
 475    */
 476   unsuspend_by_endpt(exiter->fp_endpoint);
 477   dmap_unmap_by_endpt(exiter->fp_endpoint);
 478
 479   worker_stop_by_endpt(exiter->fp_endpoint); /* Unblock waiting threads */
 480   vmnt_unmap_by_endpt(exiter->fp_endpoint); /* Invalidate open files if this
 481                                              * was an active FS */
 482
 483   /* Invalidate endpoint number for error and sanity checks. */
 484   exiter->fp_endpoint = NONE;
 485
 486   /* If a session leader exits and it has a controlling tty, then revoke
 487    * access to its controlling tty from all other processes using it.
 488    */
 489   if ((exiter->fp_flags & FP_SESLDR) && exiter->fp_tty != 0) {
 490       dev = exiter->fp_tty;
 491       for (rfp = &fproc[0]; rfp < &fproc[NR_PROCS]; rfp++) {
 492           if(rfp->fp_pid == PID_FREE) continue;
 493           if (rfp->fp_tty == dev) rfp->fp_tty = 0;
 494
 495           for (i = 0; i < OPEN_MAX; i++) {
 496                 if ((rfilp = rfp->fp_filp[i]) == NULL) continue;
 497                 if (rfilp->filp_mode == FILP_CLOSED) continue;
 498                 vp = rfilp->filp_vno;
 499                 if (!S_ISCHR(vp->v_mode)) continue;
 500                 if ((dev_t) vp->v_sdev != dev) continue;
 501                 lock_filp(rfilp, VNODE_READ);
 502                 (void) dev_close(dev, rfilp-filp); /* Ignore any errors, even
 503                                                     * SUSPEND. */
 504
 505                 rfilp->filp_mode = FILP_CLOSED;
 506                 unlock_filp(rfilp);
 507           }
 508       }
 509   }
 510
 511   /* Exit done. Mark slot as free. */
 512   exiter->fp_pid = PID_FREE;
 513   if (exiter->fp_flags & FP_PENDING)
 514         pending--;      /* No longer pending job, not going to do it */
 515   exiter->fp_flags = FP_NOFLAGS;
 516 }
 517
 518 /*===========================================================================*
 519  *                              pm_exit                                      *
 520  *===========================================================================*/
 521 void pm_exit(proc)
 522 int proc;
 523 {
 524 /* Perform the file system portion of the exit(status) system call. */
 525   int exitee_p;
 526
 527   /* Nevertheless, pretend that the call came from the user. */
 528   okendpt(proc, &exitee_p);
 529   fp = &fproc[exitee_p];
 530   free_proc(fp, FP_EXITING);
 531 }
 532
 533 /*===========================================================================*
 534  *                              pm_setgid                                    *
 535  *===========================================================================*/
 536 void pm_setgid(proc_e, egid, rgid)
 537 int proc_e;
 538 int egid;
 539 int rgid;
 540 {
 541   register struct fproc *tfp;
 542   int slot;
 543
 544   okendpt(proc_e, &slot);
 545   tfp = &fproc[slot];
 546
 547   tfp->fp_effgid =  egid;
 548   tfp->fp_realgid = rgid;
 549 }
 550
 551
 552 /*===========================================================================*
 553  *                              pm_setgroups                                 *
 554  *===========================================================================*/
 555 void pm_setgroups(proc_e, ngroups, groups)
 556 int proc_e;
 557 int ngroups;
 558 gid_t *groups;
 559 {
 560   struct fproc *rfp;
 561   int slot;
 562
 563   okendpt(proc_e, &slot);
 564   rfp = &fproc[slot];
 565   if (ngroups * sizeof(gid_t) > sizeof(rfp->fp_sgroups))
 566         panic("VFS: pm_setgroups: too much data to copy");
 567   if (sys_datacopy(who_e, (vir_bytes) groups, SELF, (vir_bytes) rfp->fp_sgroups,
 568                    ngroups * sizeof(gid_t)) == OK) {
 569         rfp->fp_ngroups = ngroups;
 570   } else
 571         panic("VFS: pm_setgroups: datacopy failed");
 572 }
 573
 574
 575 /*===========================================================================*
 576  *                              pm_setuid                                    *
 577  *===========================================================================*/
 578 void pm_setuid(proc_e, euid, ruid)
 579 int proc_e;
 580 int euid;
 581 int ruid;
 582 {
 583   struct fproc *tfp;
 584   int slot;
 585
 586   okendpt(proc_e, &slot);
 587   tfp = &fproc[slot];
 588
 589   tfp->fp_effuid =  euid;
 590   tfp->fp_realuid = ruid;
 591 }
 592
 593 /*===========================================================================*
 594  *                              do_svrctl                                    *
 595  *===========================================================================*/
 596 int do_svrctl()
 597 {
 598   unsigned int svrctl;
 599   vir_bytes ptr;
 600
 601   svrctl = job_m_in.svrctl_req;
 602   ptr = (vir_bytes) job_m_in.svrctl_argp;
 603   if (((svrctl >> 8) & 0xFF) != 'M') return(EINVAL);
 604
 605   switch (svrctl) {
 606     case VFSSETPARAM:
 607     case VFSGETPARAM:
 608         {
 609                 struct sysgetenv sysgetenv;
 610                 char search_key[64];
 611                 char val[64];
 612                 int r, s;
 613
 614                 /* Copy sysgetenv structure to VFS */
 615                 if (sys_datacopy(who_e, ptr, SELF, (vir_bytes) &sysgetenv,
 616                                  sizeof(sysgetenv)) != OK)
 617                         return(EFAULT);
 618
 619                 /* Basic sanity checking */
 620                 if (svrctl == VFSSETPARAM) {
 621                         if (sysgetenv.keylen <= 0 ||
 622                             sysgetenv.keylen > (sizeof(search_key) - 1) ||
 623                             sysgetenv.vallen <= 0 ||
 624                             sysgetenv.vallen >= sizeof(val)) {
 625                                 return(EINVAL);
 626                         }
 627                 }
 628
 629                 /* Copy parameter "key" */
 630                 if ((s = sys_datacopy(who_e, (vir_bytes) sysgetenv.key,
 631                                       SELF, (vir_bytes) search_key,
 632                                       sysgetenv.keylen)) != OK)
 633                         return(s);
 634                 search_key[sysgetenv.keylen] = '\0'; /* Limit string */
 635
 636                 /* Is it a parameter we know? */
 637                 if (svrctl == VFSSETPARAM) {
 638                         if (!strcmp(search_key, "verbose")) {
 639                                 int verbose_val;
 640                                 if ((s = sys_datacopy(who_e,
 641                                     (vir_bytes) sysgetenv.val, SELF,
 642                                     (vir_bytes) &val, sysgetenv.vallen)) != OK)
 643                                         return(s);
 644                                 val[sysgetenv.vallen] = '\0'; /* Limit string */
 645                                 verbose_val = atoi(val);
 646                                 if (verbose_val < 0 || verbose_val > 4) {
 647                                         return(EINVAL);
 648                                 }
 649                                 verbose = verbose_val;
 650                                 r = OK;
 651                         } else {
 652                                 r = ESRCH;
 653                         }
 654                 } else { /* VFSGETPARAM */
 655                         char small_buf[60];
 656
 657                         r = ESRCH;
 658                         if (!strcmp(search_key, "print_traces")) {
 659                                 mthread_stacktraces();
 660                                 sysgetenv.val = 0;
 661                                 sysgetenv.vallen = 0;
 662                                 r = OK;
 663                         } else if (!strcmp(search_key, "active_threads")) {
 664                                 int active = NR_WTHREADS - worker_available();
 665                                 snprintf(small_buf, sizeof(small_buf) - 1,
 666                                          "%d", active);
 667                                 sysgetenv.vallen = strlen(small_buf);
 668                                 r = OK;
 669                         }
 670
 671                         if (r == OK) {
 672                                 if ((s = sys_datacopy(SELF,
 673                                     (vir_bytes) &sysgetenv, who_e, ptr,
 674                                     sizeof(sysgetenv))) != OK)
 675                                         return(s);
 676                                 if (sysgetenv.val != 0) {
 677                                         if ((s = sys_datacopy(SELF,
 678                                             (vir_bytes) small_buf, who_e,
 679                                             (vir_bytes) sysgetenv.val,
 680                                             sysgetenv.vallen)) != OK)
 681                                                 return(s);
 682                                 }
 683                         }
 684                 }
 685
 686                 return(r);
 687         }
 688     default:
 689         return(EINVAL);
 690   }
 691 }
 692
 693 /*===========================================================================*
 694  *                              pm_dumpcore                                  *
 695  *===========================================================================*/
 696 int pm_dumpcore(endpoint_t proc_e, int csig, vir_bytes exe_name)
 697 {
 698   int slot, r, core_fd;
 699   struct filp *f;
 700   char core_path[PATH_MAX];
 701   char proc_name[PROC_NAME_LEN];
 702
 703   okendpt(proc_e, &slot);
 704   fp = &fproc[slot];
 705
 706   /* open core file */
 707   snprintf(core_path, PATH_MAX, "%s.%d", CORE_NAME, fp->fp_pid);
 708   core_fd = common_open(core_path, O_WRONLY | O_CREAT | O_TRUNC, CORE_MODE);
 709   if (core_fd < 0) return(core_fd);
 710
 711   /* get process' name */
 712   r = sys_datacopy(PM_PROC_NR, exe_name, VFS_PROC_NR, (vir_bytes) proc_name,
 713                         PROC_NAME_LEN);
 714   if (r != OK) return(r);
 715   proc_name[PROC_NAME_LEN - 1] = '\0';
 716
 717   if ((f = get_filp(core_fd, VNODE_WRITE)) == NULL) return(EBADF);
 718   write_elf_core_file(f, csig, proc_name);
 719   unlock_filp(f);
 720   (void) close_fd(fp, core_fd); /* ignore failure, we're exiting anyway */
 721
 722   if(csig)
 723           free_proc(fp, FP_EXITING);
 724   return(OK);
 725 }
 726
 727 /*===========================================================================*
 728  *                               ds_event                                    *
 729  *===========================================================================*/
 730 void *
 731 ds_event(void *arg)
 732 {
 733   char key[DS_MAX_KEYLEN];
 734   char *blkdrv_prefix = "drv.blk.";
 735   char *chrdrv_prefix = "drv.chr.";
 736   u32_t value;
 737   int type, r, is_blk;
 738   endpoint_t owner_endpoint;
 739
 740   struct job my_job;
 741
 742   my_job = *((struct job *) arg);
 743   fp = my_job.j_fp;
 744
 745   /* Get the event and the owner from DS. */
 746   while ((r = ds_check(key, &type, &owner_endpoint)) == OK) {
 747         /* Only check for block and character driver up events. */
 748         if (!strncmp(key, blkdrv_prefix, strlen(blkdrv_prefix))) {
 749                 is_blk = TRUE;
 750         } else if (!strncmp(key, chrdrv_prefix, strlen(chrdrv_prefix))) {
 751                 is_blk = FALSE;
 752         } else {
 753                 continue;
 754         }
 755
 756         if ((r = ds_retrieve_u32(key, &value)) != OK) {
 757                 printf("VFS: ds_event: ds_retrieve_u32 failed\n");
 758                 break;
 759         }
 760         if (value != DS_DRIVER_UP) continue;
 761
 762         /* Perform up. */
 763         dmap_endpt_up(owner_endpoint, is_blk);
 764   }
 765
 766   if (r != ENOENT) printf("VFS: ds_event: ds_check failed: %d\n", r);
 767
 768   thread_cleanup(NULL);
 769   return(NULL);
 770 }