/* VM_IDENTIFY -- Identify the current process to the VM cache server when * opening a new client connection. */ static void vm_identify (void) { char buf[SZ_CMDBUF]; if (vm_write (vm_server, vm_client, strlen(vm_client)) < 0) vm_shutdown(); if (read (vm_server, buf, SZ_CMDBUF) <= 0) { if (vm_debug) fprintf (stderr, "vmclient (%s): server not responding\n", vm_client); vm_shutdown(); } }
/* * Shutdown sequence. Opposite to boot(). */ static void shutdown(void) { kprintf("Shutting down.\n"); vfs_clearbootfs(); vfs_clearcurdir(); vfs_unmountall(); #if OPT_A3 vmstats_print(); #endif splhigh(); #if OPT_A3 vm_shutdown(); shutdownSwapOps(); #endif scheduler_shutdown(); thread_shutdown(); }
/* VM_RESERVESPACE -- Reserve VM space for file data. This directive is * useful if VM is being used but the VM space could not be preallocated * at file access time, e.g., when opening a new file. */ int vm_reservespace (long nbytes) { char buf[SZ_CMDBUF]; int status; if (!vm_initialized) vm_initialize(); if (!vm_enabled || vm_dioenabled) return (-1); if (vm_connect() < 0) return (-1); /* Format and send the file access directive to the VMcache daemon. * The status from the server is returned as an ascii integer value * on the same socket. */ sprintf (buf, "reservespace %ld\n", nbytes); if (vm_debug) fprintf (stderr, "vmclient (%s): %s", vm_client, buf); if (vm_write (vm_server, buf, strlen(buf)) < 0) { vm_shutdown(); return (-1); } if (read (vm_server, buf, SZ_CMDBUF) <= 0) { if (vm_debug) fprintf (stderr, "vmclient (%s): server not responding\n", vm_client); vm_shutdown(); return (-1); } status = atoi (buf); return (status); }
void vm_error(enum error_code err, char *fmt, ...) { char *myfmt = (char*)malloc(32 + strlen(fmt)); sprintf(myfmt, "Error: %s", fmt); va_list args; va_start(args, fmt); vprintf(myfmt, args); va_end(args); switch(err) { case VM_ERR_FATAL: vm_shutdown(EXIT_FAILURE); break; } }
/* * Class: java/lang/Runtime * Method: exitInternal * Signature: (I)V */ JNIEXPORT void JNICALL Java_java_lang_Runtime_exitInternal(JNIEnv *env, jobject _this, jint status) { vm_shutdown(status); }
void vm_shutdown_during_initialization(const char* error, const char* message) { vm_notify_during_shutdown(error, message); vm_shutdown(); }
/* VM_DELETE -- Delete any VM space used by a file, e.g., because the file * is being physically deleted. This should be called before the file is * actually deleted so that the cache can determine its device and inode * values. */ int vm_delete (char *fname, int force) { struct stat st; char buf[SZ_COMMAND]; char pathname[SZ_PATHNAME]; int status = 0; /* One-time process initialization. */ if (!vm_initialized) vm_initialize(); if (stat (fname, &st) < 0) { status = -1; goto done; } /* If VMcache is not being used we are done. */ if (vm_dioenabled && (st.st_size >= dio_threshold)) goto done; else if (!vm_enabled || st.st_size < vm_threshold) goto done; /* Don't delete the VM space used by the file if it has hard links * and only a link is being deleted (force flag will override). */ if (st.st_nlink > 1 && !force) goto done; /* Connect to the VMcache server if not already connected. */ if (!vm_server) if (vm_connect() < 0) { status = -1; goto done; } /* Format and send the delete directive to the VMcache daemon. * The status from the server is returned as an ascii integer value * on the same socket. */ sprintf (buf, "delete %s\n", realpath(fname,pathname)); if (vm_write (vm_server, buf, strlen(buf)) < 0) { vm_shutdown(); status = -1; goto done; } if (read (vm_server, buf, SZ_CMDBUF) <= 0) { if (vm_debug) fprintf (stderr, "vmclient (%s): server not responding\n", vm_client); vm_shutdown(); status = -1; goto done; } status = atoi (buf); done: if (vm_debug) fprintf (stderr, "vmclient (%s): delete `%s' -> %d\n", vm_client, fname, status); return (status < 0 ? -1 : status); }
/* VM_ACCESS -- Access a file via the VM subsystem. A return value of 1 * indicates that the file is (or will be) "cached" in virtual memory, i.e., * that normal virtual memory file system (normal file i/o) should be used * to access the file. A return value of 0 indicates that direct i/o should * be used to access the file, bypassing the virtual memory file system. */ int vm_access (char *fname, int mode) { struct stat st; char *modestr = NULL, buf[SZ_COMMAND]; char pathname[SZ_PATHNAME]; int status; /* One-time process initialization. */ if (!vm_initialized) vm_initialize(); if (stat (fname, &st) < 0) { status = DEF_ACCESSVAL; goto done; } /* If directio is enabled and the file exceeds the directio threshold * use directio to access the file (access=0). If vmcache is * disabled use normal VM-based i/o to access the file (access=1). * If VMcache is enabled we still only use it if the file size * exceeds vm_threshold. */ if (vm_dioenabled) { status = (st.st_size >= dio_threshold) ? 0 : 1; goto done; } else if (!vm_enabled || st.st_size < vm_threshold) { status = DEF_ACCESSVAL; goto done; } /* Use of VMcache is enabled and the file equals or exceeds the * minimum size threshold. Initialization has already been performed. * Open a VMcache daemon server connection if we don't already have * one. If the server connection fails we are done, but we will try * to open a connection again in the next file access. */ if (!vm_server) if (vm_connect() < 0) { status = DEF_ACCESSVAL; goto done; } /* Compute the mode string for the server request. */ switch (mode) { case READ_ONLY: modestr = "ro"; break; case NEW_FILE: case READ_WRITE: case APPEND: modestr = "rw"; break; } /* Format and send the file access directive to the VMcache daemon. * The status from the server is returned as an ascii integer value * on the same socket. */ sprintf (buf, "access %s %s\n", realpath(fname,pathname), modestr); if (vm_write (vm_server, buf, strlen(buf)) < 0) { vm_shutdown(); status = DEF_ACCESSVAL; goto done; } if (read (vm_server, buf, SZ_CMDBUF) <= 0) { if (vm_debug) fprintf (stderr, "vmclient (%s): server not responding\n", vm_client); vm_shutdown(); status = DEF_ACCESSVAL; goto done; } status = atoi (buf); done: if (vm_debug) fprintf (stderr, "vmclient (%s): access `%s' -> %d\n", vm_client, fname, status); return (status < 0 ? DEF_ACCESSVAL : status); }