1 /* 2 * a loop that gets messages requesting work, carries out the work, and sends 3 * replies. 4 * 5 * The entry points into this file are: 6 * main: main program of the Virtual File System 7 * reply: send a reply to a process after the requested work is done 8 * 9 */ 10 11 #include "fs.h" 12 #include <fcntl.h> 13 #include <string.h> 14 #include <stdio.h> 15 #include <signal.h> 16 #include <assert.h> 17 #include <stdlib.h> 18 #include <sys/ioc_memory.h> 19 #include <sys/svrctl.h> 20 #include <sys/select.h> 21 #include <minix/callnr.h> 22 #include <minix/com.h> 23 #include <minix/const.h> 24 #include <minix/endpoint.h> 25 #include <minix/safecopies.h> 26 #include <minix/debug.h> 27 #include <minix/vfsif.h> 28 #include "file.h" 29 #include "scratchpad.h" 30 #include "vmnt.h" 31 #include "vnode.h" 32 33 #if ENABLE_SYSCALL_STATS 34 EXTERN unsigned long calls_stats[NR_VFS_CALLS]; 35 #endif 36 37 /* Thread related prototypes */ 38 static void do_reply(struct worker_thread *wp); 39 static void do_work(void); 40 static void do_init_root(void); 41 static void handle_work(void (*func)(void)); 42 static void reply(message *m_out, endpoint_t whom, int result); 43 44 static void get_work(void); 45 static void service_pm(void); 46 static int unblock(struct fproc *rfp); 47 48 /* SEF functions and variables. */ 49 static void sef_local_startup(void); 50 static int sef_cb_init_fresh(int type, sef_init_info_t *info); 51 static endpoint_t receive_from; 52 53 /*===========================================================================* 54 * main * 55 *===========================================================================*/ 56 int main(void) 57 { 58 /* This is the main program of the file system. The main loop consists of 59 * three major activities: getting new work, processing the work, and sending 60 * the reply. This loop never terminates as long as the file system runs. 61 */ 62 int transid; 63 struct worker_thread *wp; 64 65 /* SEF local startup. */ 66 sef_local_startup(); 67 68 printf("Started VFS: %d worker thread(s)\n", NR_WTHREADS); 69 70 if (OK != (sys_getkinfo(&kinfo))) 71 panic("couldn't get kernel kinfo"); 72 73 /* This is the main loop that gets work, processes it, and sends replies. */ 74 while (TRUE) { 75 yield_all(); /* let other threads run */ 76 self = NULL; 77 send_work(); 78 get_work(); 79 80 transid = TRNS_GET_ID(m_in.m_type); 81 if (IS_VFS_FS_TRANSID(transid)) { 82 wp = worker_get((thread_t) transid - VFS_TRANSID); 83 if (wp == NULL || wp->w_fp == NULL) { 84 printf("VFS: spurious message %d from endpoint %d\n", 85 m_in.m_type, m_in.m_source); 86 continue; 87 } 88 m_in.m_type = TRNS_DEL_ID(m_in.m_type); 89 do_reply(wp); 90 continue; 91 } else if (who_e == PM_PROC_NR) { /* Calls from PM */ 92 /* Special control messages from PM */ 93 service_pm(); 94 continue; 95 } else if (is_notify(call_nr)) { 96 /* A task ipc_notify()ed us */ 97 switch (who_e) { 98 case DS_PROC_NR: 99 /* Start a thread to handle DS events, if no thread 100 * is pending or active for it already. DS is not 101 * supposed to issue calls to VFS or be the subject of 102 * postponed PM requests, so this should be no problem. 103 */ 104 if (worker_can_start(fp)) 105 handle_work(ds_event); 106 break; 107 case KERNEL: 108 mthread_stacktraces(); 109 break; 110 case CLOCK: 111 /* Timer expired. Used only for select(). Check it. */ 112 expire_timers(m_in.m_notify.timestamp); 113 break; 114 default: 115 printf("VFS: ignoring notification from %d\n", who_e); 116 } 117 continue; 118 } else if (who_p < 0) { /* i.e., message comes from a task */ 119 /* We're going to ignore this message. Tasks should 120 * send ipc_notify()s only. 121 */ 122 printf("VFS: ignoring message from %d (%d)\n", who_e, call_nr); 123 continue; 124 } 125 126 if (IS_BDEV_RS(call_nr)) { 127 /* We've got results for a block device request. */ 128 bdev_reply(); 129 } else if (IS_CDEV_RS(call_nr)) { 130 /* We've got results for a character device request. */ 131 cdev_reply(); 132 } else { 133 /* Normal syscall. This spawns a new thread. */ 134 handle_work(do_work); 135 } 136 } 137 return(OK); /* shouldn't come here */ 138 } 139 140 /*===========================================================================* 141 * handle_work * 142 *===========================================================================*/ 143 static void handle_work(void (*func)(void)) 144 { 145 /* Handle asynchronous device replies and new system calls. If the originating 146 * endpoint is an FS endpoint, take extra care not to get in deadlock. */ 147 struct vmnt *vmp = NULL; 148 endpoint_t proc_e; 149 int use_spare = FALSE; 150 151 proc_e = m_in.m_source; 152 153 if (fp->fp_flags & FP_SRV_PROC) { 154 vmp = find_vmnt(proc_e); 155 if (vmp != NULL) { 156 /* A callback from an FS endpoint. Can do only one at once. */ 157 if (vmp->m_flags & VMNT_CALLBACK) { 158 replycode(proc_e, EAGAIN); 159 return; 160 } 161 /* Already trying to resolve a deadlock? Can't handle more. */ 162 if (worker_available() == 0) { 163 replycode(proc_e, EAGAIN); 164 return; 165 } 166 /* A thread is available. Set callback flag. */ 167 vmp->m_flags |= VMNT_CALLBACK; 168 if (vmp->m_flags & VMNT_MOUNTING) { 169 vmp->m_flags |= VMNT_FORCEROOTBSF; 170 } 171 } 172 173 /* Use the spare thread to handle this request if needed. */ 174 use_spare = TRUE; 175 } 176 177 worker_start(fp, func, &m_in, use_spare); 178 } 179 180 181 /*===========================================================================* 182 * do_reply * 183 *===========================================================================*/ 184 static void do_reply(struct worker_thread *wp) 185 { 186 struct vmnt *vmp = NULL; 187 188 if(who_e != VM_PROC_NR && (vmp = find_vmnt(who_e)) == NULL) 189 panic("Couldn't find vmnt for endpoint %d", who_e); 190 191 if (wp->w_task != who_e) { 192 printf("VFS: tid %d: expected %d to reply, not %d\n", 193 wp->w_tid, wp->w_task, who_e); 194 } 195 *wp->w_sendrec = m_in; 196 wp->w_task = NONE; 197 if(vmp) vmp->m_comm.c_cur_reqs--; /* We've got our reply, make room for others */ 198 worker_signal(wp); /* Continue this thread */ 199 } 200 201 /*===========================================================================* 202 * do_pending_pipe * 203 *===========================================================================*/ 204 static void do_pending_pipe(void) 205 { 206 int r, op; 207 struct filp *f; 208 tll_access_t locktype; 209 210 f = scratch(fp).file.filp; 211 assert(f != NULL); 212 scratch(fp).file.filp = NULL; 213 214 locktype = (job_call_nr == VFS_READ) ? VNODE_READ : VNODE_WRITE; 215 op = (job_call_nr == VFS_READ) ? READING : WRITING; 216 lock_filp(f, locktype); 217 218 r = rw_pipe(op, who_e, f, scratch(fp).io.io_buffer, scratch(fp).io.io_nbytes); 219 220 if (r != SUSPEND) /* Do we have results to report? */ 221 replycode(fp->fp_endpoint, r); 222 223 unlock_filp(f); 224 } 225 226 /*===========================================================================* 227 * do_work * 228 *===========================================================================*/ 229 static void do_work(void) 230 { 231 unsigned int call_index; 232 int error; 233 234 if (fp->fp_pid == PID_FREE) { 235 /* Process vanished before we were able to handle request. 236 * Replying has no use. Just drop it. 237 */ 238 return; 239 } 240 241 memset(&job_m_out, 0, sizeof(job_m_out)); 242 243 /* At this point we assume that we're dealing with a call that has been 244 * made specifically to VFS. Typically it will be a POSIX call from a 245 * normal process, but we also handle a few calls made by drivers such 246 * such as UDS and VND through here. Call the internal function that 247 * does the work. 248 */ 249 if (IS_VFS_CALL(job_call_nr)) { 250 call_index = (unsigned int) (job_call_nr - VFS_BASE); 251 252 if (call_index < NR_VFS_CALLS && call_vec[call_index] != NULL) { 253 #if ENABLE_SYSCALL_STATS 254 calls_stats[call_index]++; 255 #endif 256 error = (*call_vec[call_index])(); 257 } else 258 error = ENOSYS; 259 } else 260 error = ENOSYS; 261 262 /* Copy the results back to the user and send reply. */ 263 if (error != SUSPEND) reply(&job_m_out, fp->fp_endpoint, error); 264 } 265 266 /*===========================================================================* 267 * sef_local_startup * 268 *===========================================================================*/ 269 static void sef_local_startup() 270 { 271 /* Register init callbacks. */ 272 sef_setcb_init_fresh(sef_cb_init_fresh); 273 sef_setcb_init_restart(sef_cb_init_fail); 274 275 /* No live update support for now. */ 276 277 /* Let SEF perform startup. */ 278 sef_startup(); 279 } 280 281 /*===========================================================================* 282 * sef_cb_init_fresh * 283 *===========================================================================*/ 284 static int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *info) 285 { 286 /* Initialize the virtual file server. */ 287 int s, i; 288 struct fproc *rfp; 289 message mess; 290 struct rprocpub rprocpub[NR_BOOT_PROCS]; 291 292 receive_from = ANY; 293 self = NULL; 294 verbose = 0; 295 296 /* Initialize proc endpoints to NONE */ 297 for (rfp = &fproc[0]; rfp < &fproc[NR_PROCS]; rfp++) { 298 rfp->fp_endpoint = NONE; 299 rfp->fp_pid = PID_FREE; 300 } 301 302 /* Initialize the process table with help of the process manager messages. 303 * Expect one message for each system process with its slot number and pid. 304 * When no more processes follow, the magic process number NONE is sent. 305 * Then, stop and synchronize with the PM. 306 */ 307 do { 308 if ((s = sef_receive(PM_PROC_NR, &mess)) != OK) 309 panic("VFS: couldn't receive from PM: %d", s); 310 311 if (mess.m_type != VFS_PM_INIT) 312 panic("unexpected message from PM: %d", mess.m_type); 313 314 if (NONE == mess.VFS_PM_ENDPT) break; 315 316 rfp = &fproc[mess.VFS_PM_SLOT]; 317 rfp->fp_flags = FP_NOFLAGS; 318 rfp->fp_pid = mess.VFS_PM_PID; 319 rfp->fp_endpoint = mess.VFS_PM_ENDPT; 320 rfp->fp_grant = GRANT_INVALID; 321 rfp->fp_blocked_on = FP_BLOCKED_ON_NONE; 322 rfp->fp_realuid = (uid_t) SYS_UID; 323 rfp->fp_effuid = (uid_t) SYS_UID; 324 rfp->fp_realgid = (gid_t) SYS_GID; 325 rfp->fp_effgid = (gid_t) SYS_GID; 326 rfp->fp_umask = ~0; 327 } while (TRUE); /* continue until process NONE */ 328 mess.m_type = OK; /* tell PM that we succeeded */ 329 s = ipc_send(PM_PROC_NR, &mess); /* send synchronization message */ 330 331 system_hz = sys_hz(); 332 333 /* Subscribe to block and character driver events. */ 334 s = ds_subscribe("drv\\.[bc]..\\..*", DSF_INITIAL | DSF_OVERWRITE); 335 if (s != OK) panic("VFS: can't subscribe to driver events (%d)", s); 336 337 /* Initialize worker threads */ 338 worker_init(); 339 340 /* Initialize global locks */ 341 if (mthread_mutex_init(&bsf_lock, NULL) != 0) 342 panic("VFS: couldn't initialize block special file lock"); 343 344 init_dmap(); /* Initialize device table. */ 345 346 /* Map all the services in the boot image. */ 347 if ((s = sys_safecopyfrom(RS_PROC_NR, info->rproctab_gid, 0, 348 (vir_bytes) rprocpub, sizeof(rprocpub))) != OK){ 349 panic("sys_safecopyfrom failed: %d", s); 350 } 351 for (i = 0; i < NR_BOOT_PROCS; i++) { 352 if (rprocpub[i].in_use) { 353 if ((s = map_service(&rprocpub[i])) != OK) { 354 panic("VFS: unable to map service: %d", s); 355 } 356 } 357 } 358 359 /* Initialize locks and initial values for all processes. */ 360 for (rfp = &fproc[0]; rfp < &fproc[NR_PROCS]; rfp++) { 361 if (mutex_init(&rfp->fp_lock, NULL) != 0) 362 panic("unable to initialize fproc lock"); 363 rfp->fp_worker = NULL; 364 #if LOCK_DEBUG 365 rfp->fp_vp_rdlocks = 0; 366 rfp->fp_vmnt_rdlocks = 0; 367 #endif 368 369 /* Initialize process directories. mount_fs will set them to the 370 * correct values. 371 */ 372 for (i = 0; i < OPEN_MAX; i++) 373 rfp->fp_filp[i] = NULL; 374 rfp->fp_rd = NULL; 375 rfp->fp_wd = NULL; 376 } 377 378 init_vnodes(); /* init vnodes */ 379 init_vmnts(); /* init vmnt structures */ 380 init_select(); /* init select() structures */ 381 init_filps(); /* Init filp structures */ 382 mount_pfs(); /* mount Pipe File Server */ 383 384 /* Mount initial ramdisk as file system root. */ 385 receive_from = MFS_PROC_NR; 386 worker_start(fproc_addr(VFS_PROC_NR), do_init_root, &mess /*unused*/, 387 FALSE /*use_spare*/); 388 389 return(OK); 390 } 391 392 /*===========================================================================* 393 * do_init_root * 394 *===========================================================================*/ 395 static void do_init_root(void) 396 { 397 int r; 398 char *mount_type = "mfs"; /* FIXME: use boot image process name instead */ 399 char *mount_label = "fs_imgrd"; /* FIXME: obtain this from RS */ 400 401 r = mount_fs(DEV_IMGRD, "bootramdisk", "/", MFS_PROC_NR, 0, mount_type, 402 mount_label); 403 if (r != OK) 404 panic("Failed to initialize root"); 405 receive_from = ANY; 406 } 407 408 /*===========================================================================* 409 * lock_proc * 410 *===========================================================================*/ 411 void lock_proc(struct fproc *rfp) 412 { 413 int r; 414 struct worker_thread *org_self; 415 416 r = mutex_trylock(&rfp->fp_lock); 417 if (r == 0) return; 418 419 org_self = worker_suspend(); 420 421 if ((r = mutex_lock(&rfp->fp_lock)) != 0) 422 panic("unable to lock fproc lock: %d", r); 423 424 worker_resume(org_self); 425 } 426 427 /*===========================================================================* 428 * unlock_proc * 429 *===========================================================================*/ 430 void unlock_proc(struct fproc *rfp) 431 { 432 int r; 433 434 if ((r = mutex_unlock(&rfp->fp_lock)) != 0) 435 panic("Failed to unlock: %d", r); 436 } 437 438 /*===========================================================================* 439 * thread_cleanup * 440 *===========================================================================*/ 441 void thread_cleanup(void) 442 { 443 /* Perform cleanup actions for a worker thread. */ 444 445 #if LOCK_DEBUG 446 check_filp_locks_by_me(); 447 check_vnode_locks_by_me(fp); 448 check_vmnt_locks_by_me(fp); 449 #endif 450 451 if (fp->fp_flags & FP_SRV_PROC) { 452 struct vmnt *vmp; 453 454 if ((vmp = find_vmnt(fp->fp_endpoint)) != NULL) { 455 vmp->m_flags &= ~VMNT_CALLBACK; 456 } 457 } 458 } 459 460 /*===========================================================================* 461 * get_work * 462 *===========================================================================*/ 463 static void get_work() 464 { 465 /* Normally wait for new input. However, if 'reviving' is 466 * nonzero, a suspended process must be awakened. 467 */ 468 int r, found_one, proc_p; 469 register struct fproc *rp; 470 471 while (reviving != 0) { 472 found_one = FALSE; 473 474 /* Find a suspended process. */ 475 for (rp = &fproc[0]; rp < &fproc[NR_PROCS]; rp++) 476 if (rp->fp_pid != PID_FREE && (rp->fp_flags & FP_REVIVED)) { 477 found_one = TRUE; /* Found a suspended process */ 478 if (unblock(rp)) 479 return; /* So main loop can process job */ 480 send_work(); 481 } 482 483 if (!found_one) /* Consistency error */ 484 panic("VFS: get_work couldn't revive anyone"); 485 } 486 487 for(;;) { 488 /* Normal case. No one to revive. Get a useful request. */ 489 if ((r = sef_receive(receive_from, &m_in)) != OK) { 490 panic("VFS: sef_receive error: %d", r); 491 } 492 493 proc_p = _ENDPOINT_P(m_in.m_source); 494 if (proc_p < 0 || proc_p >= NR_PROCS) fp = NULL; 495 else fp = &fproc[proc_p]; 496 497 if (m_in.m_type == EDEADSRCDST) { 498 printf("VFS: failed ipc_sendrec\n"); 499 return; /* Failed 'ipc_sendrec' */ 500 } 501 502 /* Negative who_p is never used to access the fproc array. Negative 503 * numbers (kernel tasks) are treated in a special way. 504 */ 505 if (fp && fp->fp_endpoint == NONE) { 506 printf("VFS: ignoring request from %d: NONE endpoint %d (%d)\n", 507 m_in.m_source, who_p, m_in.m_type); 508 continue; 509 } 510 511 /* Internal consistency check; our mental image of process numbers and 512 * endpoints must match with how the rest of the system thinks of them. 513 */ 514 if (fp && fp->fp_endpoint != who_e) { 515 if (fproc[who_p].fp_endpoint == NONE) 516 printf("slot unknown even\n"); 517 518 panic("VFS: receive endpoint inconsistent (source %d, who_p " 519 "%d, stored ep %d, who_e %d).\n", m_in.m_source, who_p, 520 fproc[who_p].fp_endpoint, who_e); 521 } 522 523 return; 524 } 525 } 526 527 /*===========================================================================* 528 * reply * 529 *===========================================================================*/ 530 static void reply(message *m_out, endpoint_t whom, int result) 531 { 532 /* Send a reply to a user process. If the send fails, just ignore it. */ 533 int r; 534 535 m_out->m_type = result; 536 r = ipc_sendnb(whom, m_out); 537 if (r != OK) { 538 printf("VFS: %d couldn't send reply %d to %d: %d\n", mthread_self(), 539 result, whom, r); 540 util_stacktrace(); 541 } 542 } 543 544 /*===========================================================================* 545 * replycode * 546 *===========================================================================*/ 547 void replycode(endpoint_t whom, int result) 548 { 549 /* Send a reply to a user process. If the send fails, just ignore it. */ 550 message m_out; 551 552 memset(&m_out, 0, sizeof(m_out)); 553 554 reply(&m_out, whom, result); 555 } 556 557 /*===========================================================================* 558 * service_pm_postponed * 559 *===========================================================================*/ 560 void service_pm_postponed(void) 561 { 562 int r, term_signal; 563 vir_bytes core_path; 564 vir_bytes exec_path, stack_frame, pc, newsp, ps_str; 565 size_t exec_path_len, stack_frame_len; 566 endpoint_t proc_e; 567 message m_out; 568 569 memset(&m_out, 0, sizeof(m_out)); 570 571 switch(job_call_nr) { 572 case VFS_PM_EXEC: 573 proc_e = job_m_in.VFS_PM_ENDPT; 574 exec_path = (vir_bytes) job_m_in.VFS_PM_PATH; 575 exec_path_len = (size_t) job_m_in.VFS_PM_PATH_LEN; 576 stack_frame = (vir_bytes) job_m_in.VFS_PM_FRAME; 577 stack_frame_len = (size_t) job_m_in.VFS_PM_FRAME_LEN; 578 ps_str = (vir_bytes) job_m_in.VFS_PM_PS_STR; 579 580 assert(proc_e == fp->fp_endpoint); 581 582 r = pm_exec(exec_path, exec_path_len, stack_frame, stack_frame_len, 583 &pc, &newsp, &ps_str); 584 585 /* Reply status to PM */ 586 m_out.m_type = VFS_PM_EXEC_REPLY; 587 m_out.VFS_PM_ENDPT = proc_e; 588 m_out.VFS_PM_PC = (void *) pc; 589 m_out.VFS_PM_STATUS = r; 590 m_out.VFS_PM_NEWSP = (void *) newsp; 591 m_out.VFS_PM_NEWPS_STR = ps_str; 592 593 break; 594 595 case VFS_PM_EXIT: 596 proc_e = job_m_in.VFS_PM_ENDPT; 597 598 assert(proc_e == fp->fp_endpoint); 599 600 pm_exit(); 601 602 /* Reply dummy status to PM for synchronization */ 603 m_out.m_type = VFS_PM_EXIT_REPLY; 604 m_out.VFS_PM_ENDPT = proc_e; 605 606 break; 607 608 case VFS_PM_DUMPCORE: 609 proc_e = job_m_in.VFS_PM_ENDPT; 610 term_signal = job_m_in.VFS_PM_TERM_SIG; 611 core_path = (vir_bytes) job_m_in.VFS_PM_PATH; 612 613 assert(proc_e == fp->fp_endpoint); 614 615 r = pm_dumpcore(term_signal, core_path); 616 617 /* Reply status to PM */ 618 m_out.m_type = VFS_PM_CORE_REPLY; 619 m_out.VFS_PM_ENDPT = proc_e; 620 m_out.VFS_PM_STATUS = r; 621 622 break; 623 624 case VFS_PM_UNPAUSE: 625 proc_e = job_m_in.VFS_PM_ENDPT; 626 627 assert(proc_e == fp->fp_endpoint); 628 629 unpause(); 630 631 m_out.m_type = VFS_PM_UNPAUSE_REPLY; 632 m_out.VFS_PM_ENDPT = proc_e; 633 634 break; 635 636 default: 637 panic("Unhandled postponed PM call %d", job_m_in.m_type); 638 } 639 640 r = ipc_send(PM_PROC_NR, &m_out); 641 if (r != OK) 642 panic("service_pm_postponed: ipc_send failed: %d", r); 643 } 644 645 /*===========================================================================* 646 * service_pm * 647 *===========================================================================*/ 648 static void service_pm(void) 649 { 650 /* Process a request from PM. This function is called from the main thread, and 651 * may therefore not block. Any requests that may require blocking the calling 652 * thread must be executed in a separate thread. Aside from VFS_PM_REBOOT, all 653 * requests from PM involve another, target process: for example, PM tells VFS 654 * that a process is performing a setuid() call. For some requests however, 655 * that other process may not be idle, and in that case VFS must serialize the 656 * PM request handling with any operation is it handling for that target 657 * process. As it happens, the requests that may require blocking are also the 658 * ones where the target process may not be idle. For both these reasons, such 659 * requests are run in worker threads associated to the target process. 660 */ 661 struct fproc *rfp; 662 int r, slot; 663 message m_out; 664 665 memset(&m_out, 0, sizeof(m_out)); 666 667 switch (call_nr) { 668 case VFS_PM_SETUID: 669 { 670 endpoint_t proc_e; 671 uid_t euid, ruid; 672 673 proc_e = m_in.VFS_PM_ENDPT; 674 euid = m_in.VFS_PM_EID; 675 ruid = m_in.VFS_PM_RID; 676 677 pm_setuid(proc_e, euid, ruid); 678 679 m_out.m_type = VFS_PM_SETUID_REPLY; 680 m_out.VFS_PM_ENDPT = proc_e; 681 } 682 break; 683 684 case VFS_PM_SETGID: 685 { 686 endpoint_t proc_e; 687 gid_t egid, rgid; 688 689 proc_e = m_in.VFS_PM_ENDPT; 690 egid = m_in.VFS_PM_EID; 691 rgid = m_in.VFS_PM_RID; 692 693 pm_setgid(proc_e, egid, rgid); 694 695 m_out.m_type = VFS_PM_SETGID_REPLY; 696 m_out.VFS_PM_ENDPT = proc_e; 697 } 698 break; 699 700 case VFS_PM_SETSID: 701 { 702 endpoint_t proc_e; 703 704 proc_e = m_in.VFS_PM_ENDPT; 705 pm_setsid(proc_e); 706 707 m_out.m_type = VFS_PM_SETSID_REPLY; 708 m_out.VFS_PM_ENDPT = proc_e; 709 } 710 break; 711 712 case VFS_PM_EXEC: 713 case VFS_PM_EXIT: 714 case VFS_PM_DUMPCORE: 715 case VFS_PM_UNPAUSE: 716 { 717 endpoint_t proc_e = m_in.VFS_PM_ENDPT; 718 719 if(isokendpt(proc_e, &slot) != OK) { 720 printf("VFS: proc ep %d not ok\n", proc_e); 721 return; 722 } 723 724 rfp = &fproc[slot]; 725 726 /* PM requests on behalf of a proc are handled after the 727 * system call that might be in progress for that proc has 728 * finished. If the proc is not busy, we start a new thread. 729 */ 730 worker_start(rfp, NULL, &m_in, FALSE /*use_spare*/); 731 732 return; 733 } 734 case VFS_PM_FORK: 735 case VFS_PM_SRV_FORK: 736 { 737 endpoint_t pproc_e, proc_e; 738 pid_t child_pid; 739 uid_t reuid; 740 gid_t regid; 741 742 pproc_e = m_in.VFS_PM_PENDPT; 743 proc_e = m_in.VFS_PM_ENDPT; 744 child_pid = m_in.VFS_PM_CPID; 745 reuid = m_in.VFS_PM_REUID; 746 regid = m_in.VFS_PM_REGID; 747 748 pm_fork(pproc_e, proc_e, child_pid); 749 m_out.m_type = VFS_PM_FORK_REPLY; 750 751 if (call_nr == VFS_PM_SRV_FORK) { 752 m_out.m_type = VFS_PM_SRV_FORK_REPLY; 753 pm_setuid(proc_e, reuid, reuid); 754 pm_setgid(proc_e, regid, regid); 755 } 756 757 m_out.VFS_PM_ENDPT = proc_e; 758 } 759 break; 760 case VFS_PM_SETGROUPS: 761 { 762 endpoint_t proc_e; 763 int group_no; 764 gid_t *group_addr; 765 766 proc_e = m_in.VFS_PM_ENDPT; 767 group_no = m_in.VFS_PM_GROUP_NO; 768 group_addr = (gid_t *) m_in.VFS_PM_GROUP_ADDR; 769 770 pm_setgroups(proc_e, group_no, group_addr); 771 772 m_out.m_type = VFS_PM_SETGROUPS_REPLY; 773 m_out.VFS_PM_ENDPT = proc_e; 774 } 775 break; 776 777 case VFS_PM_REBOOT: 778 /* Reboot requests are not considered postponed PM work and are instead 779 * handled from a separate worker thread that is associated with PM's 780 * process. PM makes no regular VFS calls, and thus, from VFS's 781 * perspective, PM is always idle. Therefore, we can safely do this. 782 * We do assume that PM sends us only one VFS_PM_REBOOT message at 783 * once, or ever for that matter. :) 784 */ 785 worker_start(fproc_addr(PM_PROC_NR), pm_reboot, &m_in, 786 FALSE /*use_spare*/); 787 788 return; 789 790 default: 791 printf("VFS: don't know how to handle PM request %d\n", call_nr); 792 793 return; 794 } 795 796 r = ipc_send(PM_PROC_NR, &m_out); 797 if (r != OK) 798 panic("service_pm: ipc_send failed: %d", r); 799 } 800 801 802 /*===========================================================================* 803 * unblock * 804 *===========================================================================*/ 805 static int unblock(rfp) 806 struct fproc *rfp; 807 { 808 /* Unblock a process that was previously blocked on a pipe or a lock. This is 809 * done by reconstructing the original request and continuing/repeating it. 810 * This function returns TRUE when it has restored a request for execution, and 811 * FALSE if the caller should continue looking for work to do. 812 */ 813 int blocked_on; 814 815 blocked_on = rfp->fp_blocked_on; 816 817 /* Reconstruct the original request from the saved data. */ 818 memset(&m_in, 0, sizeof(m_in)); 819 m_in.m_source = rfp->fp_endpoint; 820 m_in.m_type = rfp->fp_block_callnr; 821 switch (m_in.m_type) { 822 case VFS_READ: 823 case VFS_WRITE: 824 assert(blocked_on == FP_BLOCKED_ON_PIPE); 825 m_in.m_lc_vfs_readwrite.fd = scratch(rfp).file.fd_nr; 826 m_in.m_lc_vfs_readwrite.buf = scratch(rfp).io.io_buffer; 827 m_in.m_lc_vfs_readwrite.len = scratch(rfp).io.io_nbytes; 828 break; 829 case VFS_FCNTL: 830 assert(blocked_on == FP_BLOCKED_ON_LOCK); 831 m_in.m_lc_vfs_fcntl.fd = scratch(rfp).file.fd_nr; 832 m_in.m_lc_vfs_fcntl.cmd = scratch(rfp).io.io_nbytes; 833 m_in.m_lc_vfs_fcntl.arg_ptr = scratch(rfp).io.io_buffer; 834 assert(m_in.m_lc_vfs_fcntl.cmd == F_SETLKW); 835 break; 836 default: 837 panic("unblocking call %d blocked on %d ??", m_in.m_type, blocked_on); 838 } 839 840 rfp->fp_blocked_on = FP_BLOCKED_ON_NONE; /* no longer blocked */ 841 rfp->fp_flags &= ~FP_REVIVED; 842 reviving--; 843 assert(reviving >= 0); 844 845 /* This should not be device I/O. If it is, it'll 'leak' grants. */ 846 assert(!GRANT_VALID(rfp->fp_grant)); 847 848 /* Pending pipe reads/writes cannot be repeated as is, and thus require a 849 * special resumption procedure. 850 */ 851 if (blocked_on == FP_BLOCKED_ON_PIPE) { 852 worker_start(rfp, do_pending_pipe, &m_in, FALSE /*use_spare*/); 853 return(FALSE); /* Retrieve more work */ 854 } 855 856 /* A lock request. Repeat the original request as though it just came in. */ 857 fp = rfp; 858 return(TRUE); /* We've unblocked a process */ 859 } 860