259 lines
8.5 KiB
C
259 lines
8.5 KiB
C
// Native file metadata smoke test.
|
|
// Verifies path stat, handle stat, directory metadata, missing paths, and invalid handles.
|
|
|
|
#include <stdint.h>
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
#include <ntlite/syscall.h>
|
|
|
|
#define TEST_FILE_SIZE 1537u
|
|
|
|
static uint8_t gPattern[TEST_FILE_SIZE];
|
|
|
|
// Prints one NUL-terminated string to the kernel console.
|
|
static void print(const char* s) {
|
|
SYS_WRITE_CONSOLE_REQUEST req = { SysSvFromCstr(s) };
|
|
SysWriteConsole(&req);
|
|
}
|
|
|
|
// Prints one unsigned integer to the kernel console.
|
|
static void print_u64(uint64_t v) {
|
|
char buf[32];
|
|
int i = 0;
|
|
if (v == 0) {
|
|
print("0");
|
|
return;
|
|
}
|
|
while (v && i < (int)sizeof(buf)) {
|
|
buf[i++] = (char)('0' + (v % 10));
|
|
v /= 10;
|
|
}
|
|
while (i--) {
|
|
char c = buf[i];
|
|
SYS_WRITE_CONSOLE_REQUEST req = { SysSvFromParts(&c, 1) };
|
|
SysWriteConsole(&req);
|
|
}
|
|
}
|
|
|
|
// Terminates the current test process.
|
|
static void exit_now(int code) {
|
|
for (;;) SysExitProcess(code);
|
|
}
|
|
|
|
// Fails the test with one plain message.
|
|
static void fail(const char* msg) {
|
|
print("file_stat_smoke: ");
|
|
print(msg);
|
|
print("\n");
|
|
exit_now(1);
|
|
}
|
|
|
|
// Fails the test with one status value.
|
|
static void fail_status(const char* what, uint32_t status) {
|
|
print("file_stat_smoke: ");
|
|
print(what);
|
|
print(" failed status=");
|
|
print_u64(status);
|
|
print("\n");
|
|
exit_now(1);
|
|
}
|
|
|
|
// Removes a file path if it already exists.
|
|
static void delete_file_path(const char* path) {
|
|
SYS_PATH_REQUEST req = { SysSvFromCstr(path) };
|
|
(void)SysDeleteFile(&req);
|
|
}
|
|
|
|
// Removes a directory path if it already exists.
|
|
static void remove_dir_path(const char* path) {
|
|
SYS_PATH_REQUEST req = { SysSvFromCstr(path) };
|
|
(void)SysRemoveDir(&req);
|
|
}
|
|
|
|
// Opens a new temporary file on the first writable path that works.
|
|
static uint32_t create_temp_file(uint32_t* fileOut, const char** pathOut) {
|
|
static const char* paths[] = {
|
|
"file_stat_smoke.tmp",
|
|
"/file_stat_smoke.tmp",
|
|
"1:/file_stat_smoke.tmp",
|
|
"0:/file_stat_smoke.tmp",
|
|
};
|
|
|
|
for (size_t i = 0; i < sizeof(paths) / sizeof(paths[0]); ++i) {
|
|
uint32_t h = 0;
|
|
delete_file_path(paths[i]);
|
|
SYS_OPEN_FILE_REQUEST req = SysMakeOpenFileRequest(SysSvFromCstr(paths[i]),
|
|
SYS_FILE_ACCESS_READ | SYS_FILE_ACCESS_WRITE | SYS_FILE_ACCESS_QUERY,
|
|
SYS_FILE_CREATE_NEW,
|
|
SYS_FILE_FLAG_NONE,
|
|
&h);
|
|
uint32_t s = SysOpenFile(&req);
|
|
if (s == NTLSTATUS_SUCCESS) {
|
|
*fileOut = h;
|
|
*pathOut = paths[i];
|
|
return NTLSTATUS_SUCCESS;
|
|
}
|
|
}
|
|
|
|
return NTLSTATUS_NOT_FOUND;
|
|
}
|
|
|
|
// Creates a temporary directory on the first writable path that works.
|
|
static uint32_t create_temp_dir(const char** pathOut) {
|
|
static const char* paths[] = {
|
|
"file_stat_smoke.dir",
|
|
"/file_stat_smoke.dir",
|
|
"1:/file_stat_smoke.dir",
|
|
"0:/file_stat_smoke.dir",
|
|
};
|
|
|
|
for (size_t i = 0; i < sizeof(paths) / sizeof(paths[0]); ++i) {
|
|
remove_dir_path(paths[i]);
|
|
SYS_PATH_REQUEST req = { SysSvFromCstr(paths[i]) };
|
|
uint32_t s = SysCreateDir(&req);
|
|
if (s == NTLSTATUS_SUCCESS) {
|
|
*pathOut = paths[i];
|
|
return NTLSTATUS_SUCCESS;
|
|
}
|
|
}
|
|
|
|
return NTLSTATUS_NOT_FOUND;
|
|
}
|
|
|
|
// Fills the write pattern used by the test file.
|
|
static void fill_pattern(void) {
|
|
for (size_t i = 0; i < sizeof(gPattern); ++i)
|
|
gPattern[i] = (uint8_t)(0x31u + (uint8_t)(i * 17u + (i >> 3)));
|
|
}
|
|
|
|
// Writes the test file contents and flushes them to the filesystem.
|
|
static void write_test_file(uint32_t file) {
|
|
size_t done = 0;
|
|
SYS_FILE_IO_REQUEST writeReq = SysMakeFileIoRequest(file, gPattern, sizeof(gPattern), &done);
|
|
uint32_t s = SysWriteFile(&writeReq);
|
|
if (s != NTLSTATUS_SUCCESS) fail_status("write test file", s);
|
|
if (done != sizeof(gPattern)) fail("short write");
|
|
|
|
s = SysFlushFile(file);
|
|
if (s != NTLSTATUS_SUCCESS) fail_status("flush test file", s);
|
|
}
|
|
|
|
// Checks one regular-file metadata result.
|
|
static void check_regular_stat(const SYS_FILE_STAT* stat, uint64_t expectedSize, const char* what) {
|
|
if (stat->Size != sizeof(*stat)) fail("stat abi size mismatch");
|
|
if (stat->Type != SYS_FILE_TYPE_REGULAR) {
|
|
print("file_stat_smoke: ");
|
|
print(what);
|
|
print(" type=");
|
|
print_u64(stat->Type);
|
|
print("\n");
|
|
exit_now(1);
|
|
}
|
|
if ((stat->Attributes & SYS_FILE_ATTR_DIRECTORY) != 0) fail("regular file has directory attribute");
|
|
if (stat->LinkCount == 0) fail("regular file has zero links");
|
|
if (stat->FileSize != expectedSize) {
|
|
print("file_stat_smoke: ");
|
|
print(what);
|
|
print(" size=");
|
|
print_u64(stat->FileSize);
|
|
print(" expected=");
|
|
print_u64(expectedSize);
|
|
print("\n");
|
|
exit_now(1);
|
|
}
|
|
}
|
|
|
|
// Checks one directory metadata result.
|
|
static void check_directory_stat(const SYS_FILE_STAT* stat) {
|
|
if (stat->Size != sizeof(*stat)) fail("directory stat abi size mismatch");
|
|
if (stat->Type != SYS_FILE_TYPE_DIRECTORY) fail("directory stat type mismatch");
|
|
if ((stat->Attributes & SYS_FILE_ATTR_DIRECTORY) == 0) fail("directory attribute missing");
|
|
if (stat->LinkCount == 0) fail("directory has zero links");
|
|
}
|
|
|
|
// Exercises handle and path stat for one regular file.
|
|
static void test_file_stat(uint32_t file, const char* path) {
|
|
SYS_FILE_STAT byHandle;
|
|
memset(&byHandle, 0xA5, sizeof(byHandle));
|
|
uint32_t s = SysGetFileStat(file, &byHandle);
|
|
if (s != NTLSTATUS_SUCCESS) fail_status("get file stat", s);
|
|
check_regular_stat(&byHandle, sizeof(gPattern), "handle stat");
|
|
|
|
uint64_t size = 0;
|
|
s = SysGetFileSize(file, &size);
|
|
if (s != NTLSTATUS_SUCCESS) fail_status("get file size", s);
|
|
if (size != byHandle.FileSize) fail("file size and file stat disagree");
|
|
|
|
SYS_FILE_STAT byPath;
|
|
memset(&byPath, 0x5A, sizeof(byPath));
|
|
SYS_STAT_FILE_REQUEST statReq = { SysSvFromCstr(path), &byPath };
|
|
s = SysStatFile(&statReq);
|
|
if (s != NTLSTATUS_SUCCESS) fail_status("path stat", s);
|
|
check_regular_stat(&byPath, sizeof(gPattern), "path stat");
|
|
|
|
if (byHandle.VolumeId != 0 && byPath.VolumeId != 0 && byHandle.VolumeId != byPath.VolumeId)
|
|
fail("handle and path volume ids differ");
|
|
if (byHandle.FileId != 0 && byPath.FileId != 0 && byHandle.FileId != byPath.FileId)
|
|
fail("handle and path file ids differ");
|
|
}
|
|
|
|
// Exercises path stat for one directory.
|
|
static void test_directory_stat(const char* path) {
|
|
SYS_FILE_STAT stat;
|
|
memset(&stat, 0xCC, sizeof(stat));
|
|
SYS_STAT_FILE_REQUEST statReq = { SysSvFromCstr(path), &stat };
|
|
uint32_t s = SysStatFile(&statReq);
|
|
if (s != NTLSTATUS_SUCCESS) fail_status("directory stat", s);
|
|
check_directory_stat(&stat);
|
|
}
|
|
|
|
// Checks failure status paths that stat callers depend on.
|
|
static void test_failure_paths(void) {
|
|
SYS_FILE_STAT stat;
|
|
SYS_STAT_FILE_REQUEST missingReq = { SysSvFromCstr("file_stat_smoke_missing.nope"), &stat };
|
|
uint32_t s = SysStatFile(&missingReq);
|
|
if (s != NTLSTATUS_NOT_FOUND) fail_status("missing path status", s);
|
|
|
|
s = SysGetFileStat(0xFFFFFFFFu, &stat);
|
|
if (s != NTLSTATUS_INVALID_HANDLE) fail_status("invalid handle status", s);
|
|
|
|
SYS_STAT_FILE_REQUEST badReq = { SysSvFromCstr("file_stat_smoke_missing.nope"), 0 };
|
|
s = SysStatFile(&badReq);
|
|
if (s != NTLSTATUS_INVALID_PARAMETER) fail_status("null stat output status", s);
|
|
}
|
|
|
|
// Runs the native file metadata smoke test.
|
|
int main(void) {
|
|
print("file_stat_smoke: start\n");
|
|
|
|
fill_pattern();
|
|
|
|
uint32_t file = 0;
|
|
const char* filePath = 0;
|
|
uint32_t s = create_temp_file(&file, &filePath);
|
|
if (s != NTLSTATUS_SUCCESS) fail_status("create temp file", s);
|
|
|
|
write_test_file(file);
|
|
test_file_stat(file, filePath);
|
|
SysCloseHandle(file);
|
|
delete_file_path(filePath);
|
|
|
|
const char* dirPath = 0;
|
|
s = create_temp_dir(&dirPath);
|
|
if (s != NTLSTATUS_SUCCESS) fail_status("create temp dir", s);
|
|
test_directory_stat(dirPath);
|
|
remove_dir_path(dirPath);
|
|
|
|
SYS_PATH_REQUEST dirReq = { SysSvFromCstr(dirPath) };
|
|
s = SysCreateDir(&dirReq);
|
|
if (s != NTLSTATUS_SUCCESS) fail_status("recreate temp dir", s);
|
|
test_directory_stat(dirPath);
|
|
remove_dir_path(dirPath);
|
|
|
|
test_failure_paths();
|
|
|
|
print("file_stat_smoke: PASS\n");
|
|
exit_now(0);
|
|
return 0;
|
|
}
|