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;
}
