void fs_sis_try_unlink_hash_file(struct fs *fs, struct fs *super, const char *path) { struct stat st1, st2; const char *dir, *hash, *hash_path, *hash_dir; if (fs_sis_path_parse(fs, path, &dir, &hash) == 0 && fs_stat(super, path, &st1) == 0 && st1.st_nlink == 2) { /* this may be the last link. if hashes/ file is the same, delete it. */ hash_path = t_strdup_printf("%s/"HASH_DIR_NAME"/%s", dir, hash); if (fs_stat(super, hash_path, &st2) == 0 && st1.st_ino == st2.st_ino && CMP_DEV_T(st1.st_dev, st2.st_dev)) { if (fs_unlink(super, hash_path) < 0) i_error("%s", fs_last_error(super)); else { /* try to rmdir the hashes/ directory */ hash_dir = t_strdup_printf("%s/"HASH_DIR_NAME, dir); (void)fs_rmdir(super, hash_dir); } } } }
static bool fs_sis_try_link(struct sis_fs_file *file) { const char *path = fs_file_path(&file->file); const struct stat *st; struct stat st2; st = i_stream_stat(file->hash_input, FALSE); /* we can use the existing file */ if (fs_link(file->super->fs, file->hash_path, path) < 0) { if (errno != ENOENT && errno != EMLINK) i_error("fs-sis: %s", fs_last_error(file->super->fs)); /* failed to use link(), continue as if it hadn't been equal */ return FALSE; } if (fs_stat(file->super->fs, path, &st2) < 0) { i_error("fs-sis: %s", fs_last_error(file->super->fs)); if (fs_unlink(file->super->fs, path) < 0) i_error("fs-sis: %s", fs_last_error(file->super->fs)); return FALSE; } if (st->st_ino != st2.st_ino) { /* the hashes/ file was already replaced with something else */ if (fs_unlink(file->super->fs, path) < 0) i_error("fs-sis: %s", fs_last_error(file->super->fs)); return FALSE; } return TRUE; }
static char * wiki_html_cache() { char *cache_file = clib_search_file(); if (NULL == cache_file) return NULL; fs_stats *stats = fs_stat(cache_file); if (NULL == stats) goto set_cache; long now = (long) time(NULL); long modified = stats->st_mtime; long delta = now - modified; free(stats); if (delta < CLIB_SEARCH_CACHE_TIME) { char *data = fs_read(cache_file); free(cache_file); return data; } set_cache:; http_get_response_t *res = http_get(CLIB_WIKI_URL); if (!res->ok) return NULL; char *html = strdup(res->data); if (NULL == html) return NULL; http_get_free(res); if (NULL == html) return html; fs_write(cache_file, html); free(cache_file); return html; }
/* * Gets information about the file path that is supplied and returns it to the * requestor * * TLVs: * * req: TLV_TYPE_FILE_PATH - The file path that is to be stat'd */ DWORD request_fs_stat(Remote *remote, Packet *packet) { Packet *response = packet_create_response(packet); struct meterp_stat buf; LPCSTR filePath; LPSTR expanded = NULL; DWORD result = ERROR_SUCCESS; filePath = packet_get_tlv_value_string(packet, TLV_TYPE_FILE_PATH); // Validate parameters if (!filePath) result = ERROR_INVALID_PARAMETER; else if (!(expanded = fs_expand_path(filePath))) result = ERROR_NOT_ENOUGH_MEMORY; else { result = fs_stat(expanded, &buf); if (0 == result) packet_add_tlv_raw(response, TLV_TYPE_STAT_BUF, &buf, sizeof(buf)); } // Set the result and transmit the response packet_add_tlv_uint(response, TLV_TYPE_RESULT, result); packet_transmit(remote, response, NULL); if (expanded) free(expanded); return result; }
void unlink_device(char *sym_name, enum FS_STO_TYPE type) { char mount_name[16]; // like "/mnt/uda1" struct stat st; if(fs_stat(sym_name, &st) == 0) { fs_readlink(sym_name, mount_name, 16); switch(type) { case MNT_TYPE_IDE: if(mount_name[5] == 'h') fs_unlink(sym_name); break; case MNT_TYPE_SD: if((mount_name[5] == 's') && (mount_name[6] == 'd')) fs_unlink(sym_name); break; case MNT_TYPE_USB: if(mount_name[5] == 'u') fs_unlink(sym_name); break; case MNT_TYPE_SATA: if((mount_name[5] == 's') && (mount_name[6] == 'h')) fs_unlink(sym_name); break; default: break; } } }
static int storage_init(struct device *unused) { static const struct bt_storage storage = { .read = storage_read, .write = storage_write, .clear = storage_clear }; struct fs_dirent entry; int err; err = fs_stat(STORAGE_ROOT, &entry); if (err) { BT_WARN("%s doesn't seem to exist (err %d). Creating it.", STORAGE_ROOT, err); err = fs_mkdir(STORAGE_ROOT); if (err) { BT_ERR("Unable to create %s (err %d)", STORAGE_ROOT, err); return err; } } bt_storage_register(&storage); return 0; }
/* * Gets information about the file path that is supplied and returns it to the * requestor * * req: TLV_TYPE_FILE_PATH - The file path that is to be stat'd */ DWORD request_fs_stat(Remote *remote, Packet *packet) { Packet *response = packet_create_response(packet); struct meterp_stat buf; char *filePath; char *expanded = NULL; DWORD result = ERROR_SUCCESS; filePath = packet_get_tlv_value_string(packet, TLV_TYPE_FILE_PATH); if (!filePath) { result = ERROR_INVALID_PARAMETER; goto out; } expanded = fs_expand_path(filePath); if (expanded == NULL) { result = ERROR_NOT_ENOUGH_MEMORY; goto out; } result = fs_stat(expanded, &buf); if (0 == result) { packet_add_tlv_raw(response, TLV_TYPE_STAT_BUF, &buf, sizeof(buf)); } free(expanded); out: return packet_transmit_response(result, remote, response); }
todo_t * todo_init (char *path, int warn) { fs_stats *stats; todo_t *todo = malloc(sizeof(todo_t *)); if (NULL == todo) return NULL; strcat(path, "/.todo"); todo->is_fresh = 1; if ((stats = fs_stat(path)) && 1 == warn) { todo->is_fresh = 0; todo_ferror("todo is already initialized in '%s'", path); } char *db_path = strdup(path); strcat(db_path, "/db"); fs_mkdir(path, S_IRWXU|S_IRWXG|S_IROTH|S_IXOTH); todo->path = strdup(path); todo->db = todo_db_new(db_path); // fatal if (-1 == todo_db_open(todo->db)) { todo_error("Failed to open todo database"); exit(1); } free(stats); return todo; }
static char * wiki_html_cache() { fs_stats *stats = fs_stat(CLIB_SEARCH_CACHE); if (NULL == stats) goto set_cache; long now = (long) time(NULL); long modified = stats->st_mtime; long delta = now - modified; free(stats); if (delta < CLIB_SEARCH_CACHE_TIME) return fs_read(CLIB_SEARCH_CACHE); set_cache: ; http_get_response_t *res = http_get(CLIB_WIKI_URL); if (!res->ok) return NULL; char *html = str_copy(res->data); if (NULL == html) return NULL; http_get_free(res); if (NULL == html) return html; fs_write(CLIB_SEARCH_CACHE, html); return html; }
/** * Perform the equivalent of a stat() system call on the given path. * * def stat(path) */ static mp_obj_t os_stat(mp_obj_t path_in) { const char *path_p; struct fs_stat_t stat; mp_obj_tuple_t *stat_p; int res; path_p = mp_obj_str_get_str(path_in); res = fs_stat(path_p, &stat); if (res != 0) { nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, "Failed to stat '%s'", path_p)); } stat_p = mp_obj_new_tuple(10, NULL); stat_p->items[0] = MP_OBJ_NEW_SMALL_INT(0); /* st_mode */ stat_p->items[1] = MP_OBJ_NEW_SMALL_INT(0); /* st_ino */ stat_p->items[2] = MP_OBJ_NEW_SMALL_INT(0); /* st_dev */ stat_p->items[3] = MP_OBJ_NEW_SMALL_INT(0); /* st_nlink */ stat_p->items[4] = MP_OBJ_NEW_SMALL_INT(0); /* st_uid */ stat_p->items[5] = MP_OBJ_NEW_SMALL_INT(0); /* st_gid */ stat_p->items[6] = MP_OBJ_NEW_SMALL_INT(stat.size); /* st_size */ stat_p->items[7] = MP_OBJ_NEW_SMALL_INT(0); /* st_atime */ stat_p->items[8] = MP_OBJ_NEW_SMALL_INT(0); /* st_mtime */ stat_p->items[9] = MP_OBJ_NEW_SMALL_INT(0); /* st_ctime */ return (stat_p); }
int sys_fstat(void * scallStructPtr) { struct fstatSyscall s; struct stat st; ugets(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct fstatSyscall), 0, (unsigned int *)&s); fs_stat(&(cProc->openFiles[s.fd]->node), &st); uputs(cProc, (size_t)s.buf, 0, 14, sizeof(struct stat), 0, (unsigned int *)&st); uputs(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct fstatSyscall), 0, (unsigned int *)&s); return 0; }
void fs_sis_try_unlink_hash_file(struct fs *sis_fs, struct fs_file *super_file) { struct fs_file *hash_file; struct stat st1, st2; const char *dir, *hash, *hash_path; if (fs_sis_path_parse(sis_fs, super_file->path, &dir, &hash) == 0 && fs_stat(super_file, &st1) == 0 && st1.st_nlink == 2) { /* this may be the last link. if hashes/ file is the same, delete it. */ hash_path = t_strdup_printf("%s/"HASH_DIR_NAME"/%s", dir, hash); hash_file = fs_file_init(super_file->fs, hash_path, FS_OPEN_MODE_READONLY); if (fs_stat(hash_file, &st2) == 0 && st1.st_ino == st2.st_ino && CMP_DEV_T(st1.st_dev, st2.st_dev)) { if (fs_delete(hash_file) < 0) i_error("%s", fs_last_error(hash_file->fs)); } fs_file_deinit(&hash_file); } }
static void link_device(char *vol_name, char *link_name) { struct stat st; int ret; ret = fs_stat(link_name, &st); if(ret < 0) { ret = fs_symlink(vol_name, link_name); if( ret < 0) { FS_PRINTF("link %s -> %s failed! err code = %d!\n", vol_name, link_name, ret); } } return; }
void request_fs_ls_cb(void *arg, char *name, char *short_name, char *path) { Packet *response = arg; struct meterp_stat s; /* * Add the file name, full path and stat information */ packet_add_tlv_string(response, TLV_TYPE_FILE_NAME, name); packet_add_tlv_string(response, TLV_TYPE_FILE_PATH, path); if (short_name) { packet_add_tlv_string(response, TLV_TYPE_FILE_SHORT_NAME, short_name); } if (fs_stat(path, &s) >= 0) { packet_add_tlv_raw(response, TLV_TYPE_STAT_BUF, &s, sizeof(s)); } }
static int do_mkdir(const char *path) { struct stat st; if (fs_stat(path, &st, 0) < 0) { /* Directory does not exist. EEXIST for race condition */ if (fs_mkdir(path) != 0/* && errno != EEXIST*/) return -1; } else if (!(st.st_mode & S_IFDIR)) { errno = ENOTDIR; return -1; } return 0; }
static int storage_open(const bt_addr_le_t *addr, uint16_t key, enum storage_access access, fs_file_t *file) { char path[STORAGE_PATH_MAX]; if (addr) { #if MAX_FILE_NAME >= STORAGE_FILE_NAME_LEN int len; len = snprintk(path, sizeof(path), STORAGE_ROOT "/%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X%u", addr->a.val[5], addr->a.val[4], addr->a.val[3], addr->a.val[2], addr->a.val[1], addr->a.val[0], addr->type); /* Create the subdirectory if necessary */ if (access == STORAGE_WRITE) { struct fs_dirent entry; int err; err = fs_stat(path, &entry); if (err) { err = fs_mkdir(path); if (err) { return err; } } } snprintk(path + len, sizeof(path) - len, "/%04x", key); #else return -ENAMETOOLONG; #endif } else { snprintk(path, sizeof(path), STORAGE_ROOT "/%04x", key); } return fs_open(file, path); }
static char *check_save_state(int slot) { char *title = NULL; char *state_file = get_state_file(slot, "uss"); fs_emu_log("check %s\n", state_file); if (fs_path_exists(state_file)) { fs_emu_log("exists\n"); struct fs_stat buf; if (fs_stat(state_file, &buf) == 0) { //GDate date; //g_date_clear(&date, 1); //g_date_set_time_t(&date, buf.mtime); struct tm tm_struct; fs_localtime_r(&buf.mtime, &tm_struct); char strbuf[32]; //g_date_strftime(strbuf, 32, ""); strftime(strbuf, 32, "%Y-%m-%d %H:%M:%S", &tm_struct); //title = fs_strdup_printf("%d", buf.mtime); title = g_strdup(strbuf); } } g_free(state_file); return title; }
static void test_fs_metawrap_stat(void) { struct fs *fs; struct fs_file *file; struct test_fs_file *test_file; struct istream *input; struct stat st; const char *error; unsigned int i; test_begin("fs metawrap stat"); if (fs_init("metawrap", "test", &fs_set, &fs, &error) < 0) i_fatal("fs_init() failed: %s", error); for (i = 0; i < 2; i++) { file = fs_file_init(fs, "foo", FS_OPEN_MODE_READONLY); test_file = test_fs_file_get(fs, "foo"); str_append(test_file->contents, "key:value\n\n12345678901234567890"); if (i == 0) { input = fs_read_stream(file, 2); test_istream_set_max_buffer_size(test_file->input, 2); } else { input = NULL; } test_assert_idx(fs_stat(file, &st) == 0 && st.st_size == 20, i); if (input != NULL) i_stream_unref(&input); fs_file_deinit(&file); } fs_deinit(&fs); test_end(); }
/* * Gets the contents of a given directory path and returns the list of file * names to the requestor. * * TLVs: * * req: TLV_TYPE_DIRECTORY_PATH - The directory that should be listed */ DWORD request_fs_ls(Remote *remote, Packet *packet) { Packet *response = packet_create_response(packet); LPCSTR directory; DWORD result = ERROR_SUCCESS; LPSTR expanded = NULL, tempFile = NULL; DWORD tempFileSize = 0; LPSTR baseDirectory = NULL; struct meterp_stat buf; directory = packet_get_tlv_value_string(packet, TLV_TYPE_DIRECTORY_PATH); // Enumerate the directory if one was provided if (!directory) result = ERROR_INVALID_PARAMETER; else { #ifdef _WIN32 WIN32_FIND_DATA data; HANDLE ctx = NULL; #else DIR *ctx; struct dirent *data; #endif BOOLEAN freeDirectory = FALSE; LPSTR tempDirectory = (LPSTR)directory; #ifdef _WIN32 // If there is not wildcard mask on the directory, create a version of the // directory with a mask appended if (!strrchr(directory, '*')) { if (!(tempDirectory = (LPSTR)malloc(strlen(directory) + 3))) { result = ERROR_NOT_ENOUGH_MEMORY; goto out; } sprintf(tempDirectory, "%s\\*", directory); // Dupe! if (!(baseDirectory = _strdup(directory))) { result = ERROR_NOT_ENOUGH_MEMORY; goto out; } } // Otherwise, if it does have an asterisk, we need to scan back and find // the base directory. If there is no slash, it means we're listing the // cwd. else { PCHAR slash = strrchr(directory, '\\'); if (slash) { *slash = 0; if (!(baseDirectory = _strdup(directory))) { result = ERROR_NOT_ENOUGH_MEMORY; goto out; } *slash = '\\'; } } // Expand the path if (!(expanded = fs_expand_path(tempDirectory))) { result = ERROR_NOT_ENOUGH_MEMORY; goto out; } // Start the find operation ctx = FindFirstFile(expanded, &data); #define DF_NAME data.cFileName #else expanded = 0; ctx = opendir(tempDirectory); if(ctx == NULL) { result = errno; goto out; } data = readdir(ctx); #define DF_NAME data->d_name #endif do { DWORD fullSize = (baseDirectory ? strlen(baseDirectory) : 0) + strlen(DF_NAME) + 2; // No context? Sucktastic if (ctx == INVALID_HANDLE_VALUE) { result = GetLastError(); break; } // Allocate temporary storage to stat the file if ((!tempFile) || (tempFileSize < fullSize)) { if (tempFile) free(tempFile); // No memory means we suck a lot like spoon's mom if (!(tempFile = (LPSTR)malloc(fullSize))) { result = ERROR_NOT_ENOUGH_MEMORY; break; } // Update the tempFileSize so that we don't allocate if we don't // need to like a true efficient ninja tempFileSize = fullSize; } // Build the full path if (baseDirectory) sprintf(tempFile, "%s\\%s", baseDirectory, DF_NAME); else sprintf(tempFile, "%s", DF_NAME); // Add the file name to the response packet_add_tlv_string(response, TLV_TYPE_FILE_NAME, DF_NAME); // Add the full path packet_add_tlv_string(response, TLV_TYPE_FILE_PATH, tempFile); // Stat the file to get more information about it. if (fs_stat(tempFile, &buf) >= 0) packet_add_tlv_raw(response, TLV_TYPE_STAT_BUF, &buf, sizeof(buf)); #ifdef _WIN32 } while (FindNextFile(ctx, &data)); #else } while (data = readdir(ctx)); #endif #undef DF_NAME // Clean up resources if (freeDirectory) free(tempDirectory); if (ctx) #ifdef _WIN32 FindClose(ctx); #else closedir(ctx); #endif }
// INT 80h Handler, kernel entry. void int_80() { if(krn) { return; } krn++; int systemCall = kernel_buffer[0]; int fd = kernel_buffer[1]; int buffer = kernel_buffer[2]; int count = kernel_buffer[3]; int i, j; Process * current; Process * p; int inode; int _fd; // Yeah, wanna know why we don't access an array directly? ... Because of big bugs we might have. switch(systemCall) { case READY: kernel_buffer[KERNEL_RETURN] = kernel_ready(); break; case WRITE: current = getp(); kernel_buffer[KERNEL_RETURN] = fd_write(current->file_descriptors[fd],(char *)buffer,count); break; case READ: current = getp(); kernel_buffer[KERNEL_RETURN] = fd_read(current->file_descriptors[fd],(char *)buffer,count); break; case MKFIFO: _fd = process_getfreefd(); fd = fd_open(_FD_FIFO, (void *)kernel_buffer[1],kernel_buffer[2]); if(_fd != -1 && fd != -1) { getp()->file_descriptors[_fd] = fd; kernel_buffer[KERNEL_RETURN] = _fd; } else { kernel_buffer[KERNEL_RETURN] = -1; } break; case OPEN: _fd = process_getfreefd(); fd = fd_open(_FD_FILE, (void *) kernel_buffer[1], kernel_buffer[2]); if(_fd != -1 && fd >= 0) { getp()->file_descriptors[_fd] = fd; kernel_buffer[KERNEL_RETURN] = _fd; } else { kernel_buffer[KERNEL_RETURN] = fd; } break; case CLOSE: kernel_buffer[KERNEL_RETURN] = fd_close(getp()->file_descriptors[fd]); break; case PCREATE: kernel_buffer[KERNEL_RETURN] = sched_pcreate(kernel_buffer[1],kernel_buffer[2],kernel_buffer[3]); break; case PRUN: kernel_buffer[KERNEL_RETURN] = sched_prun(kernel_buffer[1]); break; case PDUP2: kernel_buffer[KERNEL_RETURN] = sched_pdup2(kernel_buffer[1],kernel_buffer[2],kernel_buffer[3]); break; case GETPID: kernel_buffer[KERNEL_RETURN] = sched_getpid(); break; case WAITPID: kernel_buffer[KERNEL_RETURN] = sched_waitpid(kernel_buffer[1]); break; case PTICKS: kernel_buffer[KERNEL_RETURN] = (int) storage_index(); break; case PNAME: p = process_getbypid(kernel_buffer[1]); if(p == NULL) { kernel_buffer[KERNEL_RETURN] = (int) NULL; } else { kernel_buffer[KERNEL_RETURN] = (int) p->name; } break; case PSTATUS: p = process_getbypid(kernel_buffer[1]); if(p == NULL) { kernel_buffer[KERNEL_RETURN] = (int) -1; } else { kernel_buffer[KERNEL_RETURN] = (int) p->state; } break; case PPRIORITY: p = process_getbypid(kernel_buffer[1]); if(p == NULL) { kernel_buffer[KERNEL_RETURN] = (int) -1; } else { kernel_buffer[KERNEL_RETURN] = (int) p->priority; } break; case PGID: p = process_getbypid(kernel_buffer[1]); if(p == NULL) { kernel_buffer[KERNEL_RETURN] = (int) -1; } else { kernel_buffer[KERNEL_RETURN] = (int) p->gid; } break; case PGETPID_AT: p = process_getbypindex(kernel_buffer[1]); if (p->state != -1) { kernel_buffer[KERNEL_RETURN] = (int) p->pid; } else { kernel_buffer[KERNEL_RETURN] = -1; } break; case KILL: kernel_buffer[KERNEL_RETURN - 1] = kernel_buffer[1]; kernel_buffer[KERNEL_RETURN - 2] = kernel_buffer[2]; break; case PSETP: p = process_getbypid(kernel_buffer[1]); if(p == NULL) { kernel_buffer[KERNEL_RETURN] = (int) -1; } else { if(kernel_buffer[2] <= 4 && kernel_buffer[2] >= 0) { p->priority = kernel_buffer[2]; } kernel_buffer[KERNEL_RETURN] = (int) p->gid; } break; case SETSCHED: sched_set_mode(kernel_buffer[1]); break; case PWD: kernel_buffer[KERNEL_RETURN] = (int) fs_pwd(); break; case CD: kernel_buffer[KERNEL_RETURN] = (int) fs_cd(kernel_buffer[1]); break; case FINFO: fs_finfo(kernel_buffer[1], kernel_buffer[2]); break; case MOUNT: fs_init(); break; case MKDIR: kernel_buffer[KERNEL_RETURN] = (int) fs_mkdir(kernel_buffer[1],current_ttyc()->pwd); break; case RM: inode = fs_indir(kernel_buffer[1],current_ttyc()->pwd); if (inode) { kernel_buffer[KERNEL_RETURN] = (int) fs_rm(inode,0); } else { kernel_buffer[KERNEL_RETURN] = ERR_NO_EXIST; } break; case GETUID: if(kernel_buffer[1] == 0) { kernel_buffer[KERNEL_RETURN] = (int) current_ttyc()->uid; } else { kernel_buffer[KERNEL_RETURN] = (int) user_exists(kernel_buffer[1]); } break; case GETGID: if(kernel_buffer[1] == 0) { kernel_buffer[KERNEL_RETURN] = (int) user_gid(current_ttyc()->uid); } else { kernel_buffer[KERNEL_RETURN] = (int) user_gid(kernel_buffer[1]); } break; case MAKEUSER: kernel_buffer[KERNEL_RETURN] = user_create(kernel_buffer[1], kernel_buffer[2], user_gid(current_ttyc()->uid)); break; case SETGID: kernel_buffer[KERNEL_RETURN] = user_setgid(kernel_buffer[1], kernel_buffer[2]); break; case UDELETE: kernel_buffer[KERNEL_RETURN] = user_delete(kernel_buffer[1]); break; case UEXISTS: kernel_buffer[KERNEL_RETURN] = user_exists(kernel_buffer[1]); break; case ULOGIN: kernel_buffer[KERNEL_RETURN] = user_login(kernel_buffer[1], kernel_buffer[2]); break; case ULOGOUT: kernel_buffer[KERNEL_RETURN] = user_logout(); break; case CHOWN: kernel_buffer[KERNEL_RETURN] = fs_chown(kernel_buffer[1], kernel_buffer[2]); break; case CHMOD: kernel_buffer[KERNEL_RETURN] = fs_chmod(kernel_buffer[1], kernel_buffer[2]); break; case GETOWN: kernel_buffer[KERNEL_RETURN] = fs_getown(kernel_buffer[1]); break; case GETMOD: kernel_buffer[KERNEL_RETURN] = fs_getmod(kernel_buffer[1]); break; case CP: kernel_buffer[KERNEL_RETURN] = fs_cp(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd, current_ttyc()->pwd); break; case MV: kernel_buffer[KERNEL_RETURN] = fs_mv(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd); break; case LINK: kernel_buffer[KERNEL_RETURN] = fs_open_link(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd); break; case FSSTAT: kernel_buffer[KERNEL_RETURN] = fs_stat(kernel_buffer[1]); break; case SLEEP: kernel_buffer[KERNEL_RETURN] = scheduler_sleep(kernel_buffer[1]); break; default: break; } krn--; }
__declspec(noinline) bool benchmark_ntp_trySubmit_fs_stat() { NewThreadPoolApi::PrivatePoolEnvironment ppe; ppe.setMin(numProcessors); ppe.setMax(numProcessors); ppe.setPriority(TP_CALLBACK_PRIORITY::TP_CALLBACK_PRIORITY_HIGH); for(int r = 0; r < numBenchmarkRepetitions; r++) { auto start = __rdtsc(); for(int i = 0; i < numRequests; i++) { ppe.trySubmit(reinterpret_cast<PVOID>(i), [](PTP_CALLBACK_INSTANCE Instance, PVOID Context) { fs_stat(); }); } ppe.closeMembers(); auto finish = __rdtsc(); wprintf(L"start to finish: %f seconds\n", static_cast<double_t>(finish - start) / 3300000000.0); } return false; }
__declspec(noinline) bool benchmark_ntp_workQueue_fs_stat() { NewThreadPoolApi::PrivatePoolEnvironment ppe; ppe.setMin(numProcessors); ppe.setMax(numProcessors); ppe.setPriority(TP_CALLBACK_PRIORITY::TP_CALLBACK_PRIORITY_HIGH); //auto waitQueue = ppe.createWaitQueue(); //auto workQueue = ppe.createWorkQueue(WorkCallback, nullptr); auto workQueue = ppe.createWorkQueue([](PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_WORK Work) { fs_stat(); }); //auto timerQueue = ppe.createTimerQueue(); for(int r = 0; r < numBenchmarkRepetitions; r++) { auto start = __rdtsc(); for(int i = 0; i < numRequests; i++) { workQueue.submit(); } workQueue.waitAll(); auto finish = __rdtsc(); wprintf(L"start to finish: %f seconds\n", static_cast<double_t>(finish - start) / 3300000000.0); } return false; }