File system files to new folder and use FixedBufferStream for initrd
Fixed non-header aligned sizes When allocating a size that isn't aligned to the Header, then we get a incorrect alignment. To fix this, added additional alignment padding to the next free header. Fixed adding strings to build options
This commit is contained in:
DrDeano
parent
f9244c63cd
commit
7b5f921d9f
5 changed files with 189 additions and 160 deletions
670
src/kernel/filesystem/initrd.zig
Normal file
670
src/kernel/filesystem/initrd.zig
Normal file
|
|
@ -0,0 +1,670 @@
|
|||
const std = @import("std");
|
||||
const builtin = @import("builtin");
|
||||
const is_test = builtin.is_test;
|
||||
const expect = std.testing.expect;
|
||||
const expectEqual = std.testing.expectEqual;
|
||||
const expectError = std.testing.expectError;
|
||||
const expectEqualSlices = std.testing.expectEqualSlices;
|
||||
const build_options = @import("build_options");
|
||||
const mock_path = build_options.mock_path;
|
||||
const Allocator = std.mem.Allocator;
|
||||
const AutoHashMap = std.AutoHashMap;
|
||||
const vfs = @import("vfs.zig");
|
||||
const mem = if (is_test) @import("../" ++ mock_path ++ "mem_mock.zig") else @import("../mem.zig");
|
||||
const panic = if (is_test) @import("../" ++ mock_path ++ "panic_mock.zig").panic else @import("../panic.zig").panic;
|
||||
|
||||
/// The Initrd file system struct.
|
||||
/// Format of raw ramdisk:
|
||||
/// (NumOfFiles:usize)[(name_length:usize)(name:u8[name_length])(content_length:usize)(content:u8[content_length])]*
|
||||
pub const InitrdFS = struct {
|
||||
/// The ramdisk header that stores pointers for the name and file content.
|
||||
const InitrdHeader = struct {
|
||||
/// The name of the file
|
||||
name: []u8,
|
||||
|
||||
/// The content of the file
|
||||
content: []u8,
|
||||
};
|
||||
|
||||
/// The error set for the ramdisk file system.
|
||||
const Error = error{
|
||||
/// The error for an invalid raw ramdisk when
|
||||
/// parsing.
|
||||
InvalidRamDisk,
|
||||
};
|
||||
|
||||
const Self = @This();
|
||||
|
||||
/// A mapping of opened files so can easily retrieved opened files for reading.
|
||||
opened_files: AutoHashMap(*const vfs.Node, *InitrdHeader),
|
||||
|
||||
/// The underlying file system
|
||||
fs: *vfs.FileSystem,
|
||||
|
||||
/// The allocator used for allocating memory for opening and reading.
|
||||
allocator: *Allocator,
|
||||
|
||||
/// The list of files in the ram disk. These will be pointers into the raw ramdisk to save on
|
||||
/// allocations.
|
||||
files: []InitrdHeader,
|
||||
|
||||
/// The root node for the ramdisk file system. This is just a root directory as there is not
|
||||
/// subdirectories.
|
||||
root_node: *vfs.Node,
|
||||
|
||||
/// See vfs.FileSystem.instance
|
||||
instance: usize,
|
||||
|
||||
/// See vfs.FileSystem.getRootNode
|
||||
fn getRootNode(fs: *const vfs.FileSystem) *const vfs.DirNode {
|
||||
var self = @fieldParentPtr(InitrdFS, "instance", fs.instance);
|
||||
return &self.root_node.Dir;
|
||||
}
|
||||
|
||||
/// See vfs.FileSystem.close
|
||||
fn close(fs: *const vfs.FileSystem, node: *const vfs.FileNode) void {
|
||||
var self = @fieldParentPtr(InitrdFS, "instance", fs.instance);
|
||||
const cast_node = @ptrCast(*const vfs.Node, node);
|
||||
// As close can't error, if provided with a invalid Node that isn't opened or try to close
|
||||
// the same file twice, will just do nothing.
|
||||
if (self.opened_files.contains(cast_node)) {
|
||||
_ = self.opened_files.remove(cast_node);
|
||||
self.allocator.destroy(node);
|
||||
}
|
||||
}
|
||||
|
||||
/// See vfs.FileSystem.read
|
||||
fn read(fs: *const vfs.FileSystem, node: *const vfs.FileNode, len: usize) (Allocator.Error || vfs.Error)![]u8 {
|
||||
var self = @fieldParentPtr(InitrdFS, "instance", fs.instance);
|
||||
const cast_node = @ptrCast(*const vfs.Node, node);
|
||||
const file_header = self.opened_files.get(cast_node) orelse return vfs.Error.NotOpened;
|
||||
const length = std.math.min(len, file_header.content.len);
|
||||
const buff = try self.allocator.alloc(u8, length);
|
||||
std.mem.copy(u8, buff, file_header.content[0..length]);
|
||||
return buff;
|
||||
}
|
||||
|
||||
/// See vfs.FileSystem.write
|
||||
fn write(fs: *const vfs.FileSystem, node: *const vfs.FileNode, bytes: []const u8) (Allocator.Error || vfs.Error)!void {}
|
||||
|
||||
/// See vfs.FileSystem.open
|
||||
fn open(fs: *const vfs.FileSystem, dir: *const vfs.DirNode, name: []const u8, flags: vfs.OpenFlags) (Allocator.Error || vfs.Error)!*vfs.Node {
|
||||
var self = @fieldParentPtr(InitrdFS, "instance", fs.instance);
|
||||
switch (flags) {
|
||||
.CREATE_DIR, .CREATE_FILE => return vfs.Error.InvalidFlags,
|
||||
.NO_CREATION => {
|
||||
for (self.files) |*file| {
|
||||
if (std.mem.eql(u8, file.name, name)) {
|
||||
// Opening 2 files of the same name, will create 2 different Nodes
|
||||
// Create a node
|
||||
var file_node = try self.allocator.create(vfs.Node);
|
||||
file_node.* = .{ .File = .{ .fs = self.fs } };
|
||||
try self.opened_files.put(file_node, file);
|
||||
return file_node;
|
||||
}
|
||||
}
|
||||
return vfs.Error.NoSuchFileOrDir;
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
///
|
||||
/// Free all memory allocated.
|
||||
///
|
||||
/// Arguments:
|
||||
/// IN self: *Self - Self
|
||||
///
|
||||
pub fn deinit(self: *Self) void {
|
||||
// If there are any files open, then we have a error.
|
||||
std.debug.assert(self.opened_files.items().len == 0);
|
||||
self.allocator.destroy(self.root_node);
|
||||
self.allocator.destroy(self.fs);
|
||||
self.opened_files.deinit();
|
||||
for (self.files) |entry| {
|
||||
self.allocator.free(entry.name);
|
||||
self.allocator.free(entry.content);
|
||||
}
|
||||
self.allocator.free(self.files);
|
||||
self.allocator.destroy(self);
|
||||
}
|
||||
|
||||
///
|
||||
/// Initialise a ramdisk file system from a raw ramdisk in memory provided by the bootloader in a stream.
|
||||
/// Any memory allocated will be freed.
|
||||
///
|
||||
/// Arguments:
|
||||
/// IN stream: *std.io.FixedBufferStream([]u8) - The stream that contains the raw ramdisk data.
|
||||
/// IN allocator: *Allocator - The allocator used for initialising any memory needed.
|
||||
///
|
||||
/// Return: *InitrdFS
|
||||
/// A pointer to the ram disk file system.
|
||||
///
|
||||
/// Error: Error || error{EndOfStream} || Allocator.Error || std.io.FixedBufferStream([]u8).ReadError
|
||||
/// error.InvalidRamDisk - If the provided raw ramdisk is invalid. This can be due to a
|
||||
/// mis-match of the number of files to the length of the raw
|
||||
/// ramdisk or the wrong length provided to cause undefined parsed
|
||||
/// lengths for other parts of the ramdisk.
|
||||
/// error.EndOfStream - When reading from the stream, we reach the end of the stream
|
||||
/// before completing the read.
|
||||
/// error.OutOfMemory - If there isn't enough memory for initialisation. Any memory
|
||||
/// allocated will be freed.
|
||||
///
|
||||
pub fn init(stream: *std.io.FixedBufferStream([]u8), allocator: *Allocator) (Error || error{EndOfStream} || Allocator.Error)!*InitrdFS {
|
||||
std.log.info(.initrd, "Init\n", .{});
|
||||
defer std.log.info(.initrd, "Done\n", .{});
|
||||
|
||||
// First @sizeOf(usize) bytes is the number of files
|
||||
const num_of_files = try stream.reader().readIntNative(usize);
|
||||
var headers = try allocator.alloc(InitrdHeader, num_of_files);
|
||||
errdefer allocator.free(headers);
|
||||
|
||||
// Populate the headers
|
||||
var i: usize = 0;
|
||||
|
||||
// If we error, then free any headers that we allocated.
|
||||
errdefer {
|
||||
var j: usize = 0;
|
||||
while (j < i) : (j += 1) {
|
||||
allocator.free(headers[j].name);
|
||||
allocator.free(headers[j].content);
|
||||
}
|
||||
}
|
||||
|
||||
while (i < num_of_files) : (i += 1) {
|
||||
// We don't need to store the lengths any more as we have the slice.len
|
||||
const name_len = try stream.reader().readIntNative(usize);
|
||||
if (name_len == 0) {
|
||||
return Error.InvalidRamDisk;
|
||||
}
|
||||
headers[i].name = try allocator.alloc(u8, name_len);
|
||||
errdefer allocator.free(headers[i].name);
|
||||
if ((try stream.reader().readAll(headers[i].name)) != name_len) {
|
||||
return Error.InvalidRamDisk;
|
||||
}
|
||||
const content_len = try stream.reader().readIntNative(usize);
|
||||
if (content_len == 0) {
|
||||
return Error.InvalidRamDisk;
|
||||
}
|
||||
headers[i].content = try allocator.alloc(u8, content_len);
|
||||
errdefer allocator.free(headers[i].content);
|
||||
if ((try stream.reader().readAll(headers[i].content)) != content_len) {
|
||||
return Error.InvalidRamDisk;
|
||||
}
|
||||
}
|
||||
|
||||
// If we aren't at the end, error.
|
||||
if ((try stream.getPos()) != (try stream.getEndPos())) {
|
||||
return Error.InvalidRamDisk;
|
||||
}
|
||||
|
||||
var rd_fs = try allocator.create(InitrdFS);
|
||||
errdefer allocator.destroy(rd_fs);
|
||||
var fs = try allocator.create(vfs.FileSystem);
|
||||
errdefer allocator.destroy(fs);
|
||||
var root_node = try allocator.create(vfs.Node);
|
||||
|
||||
root_node.* = .{ .Dir = .{ .fs = fs, .mount = null } };
|
||||
fs.* = .{ .open = open, .close = close, .read = read, .write = write, .instance = &rd_fs.instance, .getRootNode = getRootNode };
|
||||
|
||||
rd_fs.* = .{
|
||||
.opened_files = AutoHashMap(*const vfs.Node, *InitrdHeader).init(allocator),
|
||||
.fs = fs,
|
||||
.allocator = allocator,
|
||||
.files = headers,
|
||||
.root_node = root_node,
|
||||
.instance = 1,
|
||||
};
|
||||
|
||||
switch (build_options.test_mode) {
|
||||
.Initialisation => runtimeTests(rd_fs),
|
||||
else => {},
|
||||
}
|
||||
|
||||
return rd_fs;
|
||||
}
|
||||
};
|
||||
|
||||
///
|
||||
/// Crate a raw ramdisk in memory to be used to initialise the ramdisk file system. This create
|
||||
/// three files: test1.txt, test2.txt and test3.txt.
|
||||
///
|
||||
/// Arguments:
|
||||
/// IN allocator: *Allocator - The allocator to alloc the raw ramdisk.
|
||||
///
|
||||
/// Return: []u8
|
||||
/// The bytes of the raw ramdisk in memory.
|
||||
///
|
||||
/// Error: Allocator.Error
|
||||
/// error.OutOfMemory - If there isn't enough memory for the in memory ramdisk.
|
||||
///
|
||||
fn createInitrd(allocator: *Allocator) (Allocator.Error || std.io.FixedBufferStream([]u8).WriteError)![]u8 {
|
||||
// Create 3 valid ramdisk files in memory
|
||||
const file_names = [_][]const u8{ "test1.txt", "test2.txt", "test3.txt" };
|
||||
const file_contents = [_][]const u8{ "This is a test", "This is a test: part 2", "This is a test: the prequel" };
|
||||
|
||||
// Ensure these two arrays are the same length
|
||||
std.debug.assert(file_names.len == file_contents.len);
|
||||
|
||||
var sum: usize = 0;
|
||||
const files_length = for ([_]usize{ 0, 1, 2 }) |i| {
|
||||
sum += @sizeOf(usize) + file_names[i].len + @sizeOf(usize) + file_contents[i].len;
|
||||
} else sum;
|
||||
|
||||
const total_ramdisk_len = @sizeOf(usize) + files_length;
|
||||
var ramdisk_bytes = try allocator.alloc(u8, total_ramdisk_len);
|
||||
var ramdisk_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
|
||||
// Copy the data into the allocated memory
|
||||
try ramdisk_stream.writer().writeIntNative(usize, file_names.len);
|
||||
inline for ([_]usize{ 0, 1, 2 }) |i| {
|
||||
// Name len
|
||||
try ramdisk_stream.writer().writeIntNative(usize, file_names[i].len);
|
||||
// Name
|
||||
try ramdisk_stream.writer().writeAll(file_names[i]);
|
||||
// File len
|
||||
try ramdisk_stream.writer().writeIntNative(usize, file_contents[i].len);
|
||||
// File content
|
||||
try ramdisk_stream.writer().writeAll(file_contents[i]);
|
||||
}
|
||||
// Make sure we are full
|
||||
expectEqual(try ramdisk_stream.getPos(), total_ramdisk_len);
|
||||
expectEqual(try ramdisk_stream.getPos(), try ramdisk_stream.getEndPos());
|
||||
return ramdisk_bytes;
|
||||
}
|
||||
|
||||
test "init with files valid" {
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
var fs = try InitrdFS.init(&initrd_stream, std.testing.allocator);
|
||||
defer fs.deinit();
|
||||
|
||||
expectEqual(fs.files.len, 3);
|
||||
expectEqualSlices(u8, fs.files[0].name, "test1.txt");
|
||||
expectEqualSlices(u8, fs.files[1].content, "This is a test: part 2");
|
||||
expectEqual(fs.opened_files.items().len, 0);
|
||||
}
|
||||
|
||||
test "init with files invalid - invalid number of files" {
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
// Override the number of files
|
||||
std.mem.writeIntSlice(usize, ramdisk_bytes[0..], 10, builtin.endian);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
expectError(error.InvalidRamDisk, InitrdFS.init(&initrd_stream, std.testing.allocator));
|
||||
|
||||
// Override the number of files
|
||||
std.mem.writeIntSlice(usize, ramdisk_bytes[0..], 0, builtin.endian);
|
||||
expectError(error.InvalidRamDisk, InitrdFS.init(&initrd_stream, std.testing.allocator));
|
||||
}
|
||||
|
||||
test "init with files invalid - mix - bad" {
|
||||
// TODO: Craft a ramdisk that would parse but is invalid
|
||||
// This is possible, but will think about this another time
|
||||
// Challenge, make this a effective security vulnerability
|
||||
// P.S. I don't know if adding magics will stop this
|
||||
{
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
// Override the first file name length, make is shorter
|
||||
std.mem.writeIntSlice(usize, ramdisk_bytes[4..], 2, builtin.endian);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
expectError(error.InvalidRamDisk, InitrdFS.init(&initrd_stream, std.testing.allocator));
|
||||
}
|
||||
|
||||
{
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
// Override the first file name length, make is 4 shorter
|
||||
std.mem.writeIntSlice(usize, ramdisk_bytes[4..], 5, builtin.endian);
|
||||
// Override the second file name length, make is 4 longer
|
||||
std.mem.writeIntSlice(usize, ramdisk_bytes[35..], 13, builtin.endian);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
expectError(error.InvalidRamDisk, InitrdFS.init(&initrd_stream, std.testing.allocator));
|
||||
}
|
||||
}
|
||||
|
||||
/// The number of allocations that the init function make.
|
||||
const init_allocations: usize = 10;
|
||||
|
||||
test "init with files cleans memory if OutOfMemory" {
|
||||
var i: usize = 0;
|
||||
while (i < init_allocations) : (i += 1) {
|
||||
{
|
||||
var fa = std.testing.FailingAllocator.init(std.testing.allocator, i);
|
||||
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
expectError(error.OutOfMemory, InitrdFS.init(&initrd_stream, &fa.allocator));
|
||||
}
|
||||
|
||||
// Ensure we have freed any memory allocated
|
||||
try std.testing.allocator_instance.validate();
|
||||
}
|
||||
}
|
||||
|
||||
test "getRootNode" {
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
var fs = try InitrdFS.init(&initrd_stream, std.testing.allocator);
|
||||
defer fs.deinit();
|
||||
|
||||
expectEqual(fs.fs.getRootNode(fs.fs), &fs.root_node.Dir);
|
||||
}
|
||||
|
||||
test "open valid file" {
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
var fs = try InitrdFS.init(&initrd_stream, std.testing.allocator);
|
||||
defer fs.deinit();
|
||||
|
||||
vfs.setRoot(fs.root_node);
|
||||
|
||||
var file1 = try vfs.openFile("/test1.txt", .NO_CREATION);
|
||||
defer file1.close();
|
||||
|
||||
var file1_node = @ptrCast(*const vfs.Node, file1);
|
||||
|
||||
expectEqual(fs.opened_files.items().len, 1);
|
||||
expectEqualSlices(u8, fs.opened_files.get(file1_node).?.name, "test1.txt");
|
||||
|
||||
var file3_node = try vfs.open("/test3.txt", .NO_CREATION);
|
||||
defer file3_node.File.close();
|
||||
|
||||
expectEqual(fs.opened_files.items().len, 2);
|
||||
expectEqualSlices(u8, fs.opened_files.get(file3_node).?.content, "This is a test: the prequel");
|
||||
|
||||
var dir1 = try vfs.openDir("/", .NO_CREATION);
|
||||
expectEqual(&fs.root_node.Dir, dir1);
|
||||
var file2 = &(try dir1.open("test2.txt", .NO_CREATION)).File;
|
||||
defer file2.close();
|
||||
|
||||
expectEqual(fs.opened_files.items().len, 3);
|
||||
}
|
||||
|
||||
test "open fail with invalid flags" {
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
var fs = try InitrdFS.init(&initrd_stream, std.testing.allocator);
|
||||
defer fs.deinit();
|
||||
|
||||
vfs.setRoot(fs.root_node);
|
||||
|
||||
expectError(error.InvalidFlags, vfs.openFile("/text10.txt", .CREATE_DIR));
|
||||
expectError(error.InvalidFlags, vfs.openFile("/text10.txt", .CREATE_FILE));
|
||||
expectError(error.InvalidFlags, vfs.openDir("/text10.txt", .CREATE_DIR));
|
||||
expectError(error.InvalidFlags, vfs.openDir("/text10.txt", .CREATE_FILE));
|
||||
expectError(error.InvalidFlags, vfs.openFile("/test/", .CREATE_DIR));
|
||||
expectError(error.InvalidFlags, vfs.openFile("/test/", .CREATE_FILE));
|
||||
expectError(error.InvalidFlags, vfs.openDir("/test/", .CREATE_DIR));
|
||||
expectError(error.InvalidFlags, vfs.openDir("/test/", .CREATE_FILE));
|
||||
}
|
||||
|
||||
test "open fail with NoSuchFileOrDir" {
|
||||
expectError(error.NoSuchFileOrDir, vfs.openFile("/text10.txt", .NO_CREATION));
|
||||
expectError(error.NoSuchFileOrDir, vfs.openDir("/temp/", .NO_CREATION));
|
||||
}
|
||||
|
||||
test "open a file, out of memory" {
|
||||
var fa = std.testing.FailingAllocator.init(std.testing.allocator, init_allocations);
|
||||
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
var fs = try InitrdFS.init(&initrd_stream, &fa.allocator);
|
||||
defer fs.deinit();
|
||||
|
||||
vfs.setRoot(fs.root_node);
|
||||
|
||||
expectError(error.OutOfMemory, vfs.openFile("/test1.txt", .NO_CREATION));
|
||||
}
|
||||
|
||||
test "open two of the same file" {
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
var fs = try InitrdFS.init(&initrd_stream, std.testing.allocator);
|
||||
defer fs.deinit();
|
||||
|
||||
vfs.setRoot(fs.root_node);
|
||||
|
||||
const file1 = try vfs.openFile("/test1.txt", .NO_CREATION);
|
||||
defer file1.close();
|
||||
|
||||
const file2 = try vfs.openFile("/test1.txt", .NO_CREATION);
|
||||
defer file2.close();
|
||||
|
||||
expectEqual(fs.opened_files.items().len, 2);
|
||||
expect(file1 != file2);
|
||||
|
||||
const b1 = try file1.read(128);
|
||||
defer std.testing.allocator.free(b1);
|
||||
const b2 = try file2.read(128);
|
||||
defer std.testing.allocator.free(b2);
|
||||
expectEqualSlices(u8, b1, b2);
|
||||
}
|
||||
|
||||
test "close a file" {
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
var fs = try InitrdFS.init(&initrd_stream, std.testing.allocator);
|
||||
defer fs.deinit();
|
||||
|
||||
vfs.setRoot(fs.root_node);
|
||||
|
||||
var file1 = try vfs.openFile("/test1.txt", .NO_CREATION);
|
||||
|
||||
var file1_node = @ptrCast(*const vfs.Node, file1);
|
||||
|
||||
expectEqual(fs.opened_files.items().len, 1);
|
||||
|
||||
var file3_node = try vfs.open("/test3.txt", .NO_CREATION);
|
||||
|
||||
expectEqual(fs.opened_files.items().len, 2);
|
||||
file1.close();
|
||||
expectEqual(fs.opened_files.items().len, 1);
|
||||
|
||||
var dir1 = try vfs.openDir("/", .NO_CREATION);
|
||||
expectEqual(&fs.root_node.Dir, dir1);
|
||||
var file2 = &(try dir1.open("test2.txt", .NO_CREATION)).File;
|
||||
defer file2.close();
|
||||
|
||||
expectEqual(fs.opened_files.items().len, 2);
|
||||
file3_node.File.close();
|
||||
expectEqual(fs.opened_files.items().len, 1);
|
||||
}
|
||||
|
||||
test "close a non-opened file" {
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
var fs = try InitrdFS.init(&initrd_stream, std.testing.allocator);
|
||||
defer fs.deinit();
|
||||
|
||||
vfs.setRoot(fs.root_node);
|
||||
|
||||
// Open a valid file
|
||||
var file1 = try vfs.openFile("/test1.txt", .NO_CREATION);
|
||||
defer file1.close();
|
||||
|
||||
// Only one file open
|
||||
expectEqual(fs.opened_files.items().len, 1);
|
||||
|
||||
// Craft a Node
|
||||
var fake_node = try std.testing.allocator.create(vfs.Node);
|
||||
defer std.testing.allocator.destroy(fake_node);
|
||||
fake_node.* = .{ .File = .{ .fs = fs.fs } };
|
||||
fake_node.File.close();
|
||||
|
||||
// Still only one file open
|
||||
expectEqual(fs.opened_files.items().len, 1);
|
||||
}
|
||||
|
||||
test "read a file" {
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
var fs = try InitrdFS.init(&initrd_stream, std.testing.allocator);
|
||||
defer fs.deinit();
|
||||
|
||||
vfs.setRoot(fs.root_node);
|
||||
|
||||
var file1 = try vfs.openFile("/test1.txt", .NO_CREATION);
|
||||
defer file1.close();
|
||||
|
||||
const bytes1 = try file1.read(128);
|
||||
defer std.testing.allocator.free(bytes1);
|
||||
|
||||
expectEqualSlices(u8, bytes1, "This is a test");
|
||||
|
||||
const bytes2 = try file1.read(5);
|
||||
defer std.testing.allocator.free(bytes2);
|
||||
|
||||
expectEqualSlices(u8, bytes2, "This ");
|
||||
}
|
||||
|
||||
test "read a file, out of memory" {
|
||||
var fa = std.testing.FailingAllocator.init(std.testing.allocator, init_allocations + 2);
|
||||
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
var fs = try InitrdFS.init(&initrd_stream, &fa.allocator);
|
||||
defer fs.deinit();
|
||||
|
||||
vfs.setRoot(fs.root_node);
|
||||
|
||||
var file1 = try vfs.openFile("/test1.txt", .NO_CREATION);
|
||||
defer file1.close();
|
||||
|
||||
expectError(error.OutOfMemory, file1.read(1));
|
||||
}
|
||||
|
||||
test "read a file, invalid/not opened/crafted *const Node" {
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
var fs = try InitrdFS.init(&initrd_stream, std.testing.allocator);
|
||||
defer fs.deinit();
|
||||
|
||||
vfs.setRoot(fs.root_node);
|
||||
|
||||
// Open a valid file
|
||||
var file1 = try vfs.openFile("/test1.txt", .NO_CREATION);
|
||||
defer file1.close();
|
||||
|
||||
// Only one file open
|
||||
expectEqual(fs.opened_files.items().len, 1);
|
||||
|
||||
// Craft a Node
|
||||
var fake_node = try std.testing.allocator.create(vfs.Node);
|
||||
defer std.testing.allocator.destroy(fake_node);
|
||||
fake_node.* = .{ .File = .{ .fs = fs.fs } };
|
||||
|
||||
expectError(error.NotOpened, fake_node.File.read(128));
|
||||
|
||||
// Still only one file open
|
||||
expectEqual(fs.opened_files.items().len, 1);
|
||||
}
|
||||
|
||||
test "write does nothing" {
|
||||
var ramdisk_bytes = try createInitrd(std.testing.allocator);
|
||||
defer std.testing.allocator.free(ramdisk_bytes);
|
||||
|
||||
var initrd_stream = std.io.fixedBufferStream(ramdisk_bytes);
|
||||
var fs = try InitrdFS.init(&initrd_stream, std.testing.allocator);
|
||||
defer fs.deinit();
|
||||
|
||||
vfs.setRoot(fs.root_node);
|
||||
|
||||
// Open a valid file
|
||||
var file1 = try vfs.openFile("/test1.txt", .NO_CREATION);
|
||||
defer file1.close();
|
||||
|
||||
try file1.write("Blah");
|
||||
|
||||
// Unchanged file content
|
||||
expectEqualSlices(u8, fs.opened_files.get(@ptrCast(*const vfs.Node, file1)).?.content, "This is a test");
|
||||
}
|
||||
|
||||
/// See std.testing.expectEqualSlices. As need our panic.
|
||||
fn expectEqualSlicesClone(comptime T: type, expected: []const T, actual: []const T) void {
|
||||
if (expected.len != actual.len) {
|
||||
panic(@errorReturnTrace(), "slice lengths differ. expected {}, found {}", .{ expected.len, actual.len });
|
||||
}
|
||||
var i: usize = 0;
|
||||
while (i < expected.len) : (i += 1) {
|
||||
if (!std.meta.eql(expected[i], actual[i])) {
|
||||
panic(@errorReturnTrace(), "index {} incorrect. expected {}, found {}", .{ i, expected[i], actual[i] });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
///
|
||||
/// Test that we can open, read and close a file
|
||||
///
|
||||
/// Arguments:
|
||||
/// IN allocator: *Allocator - The allocator used for reading.
|
||||
///
|
||||
fn rt_openReadClose(allocator: *Allocator) void {
|
||||
const f1 = vfs.openFile("/ramdisk_test1.txt", .NO_CREATION) catch |e| {
|
||||
panic(@errorReturnTrace(), "FAILURE: Failed to open file: {}\n", .{e});
|
||||
};
|
||||
const bytes1 = f1.read(128) catch |e| {
|
||||
panic(@errorReturnTrace(), "FAILURE: Failed to read file: {}\n", .{e});
|
||||
};
|
||||
defer f1.close();
|
||||
expectEqualSlicesClone(u8, bytes1, "Testing ram disk");
|
||||
|
||||
const f2 = vfs.openFile("/ramdisk_test2.txt", .NO_CREATION) catch |e| {
|
||||
panic(@errorReturnTrace(), "Failed to open file: {}\n", .{e});
|
||||
};
|
||||
const bytes2 = f2.read(128) catch |e| {
|
||||
panic(@errorReturnTrace(), "FAILURE: Failed to read file: {}\n", .{e});
|
||||
};
|
||||
defer f2.close();
|
||||
expectEqualSlicesClone(u8, bytes2, "Testing ram disk for the second time");
|
||||
|
||||
// Try open a non-existent file
|
||||
_ = vfs.openFile("/nope.txt", .NO_CREATION) catch |e| switch (e) {
|
||||
error.NoSuchFileOrDir => {},
|
||||
else => panic(@errorReturnTrace(), "FAILURE: Expected error\n", .{}),
|
||||
};
|
||||
std.log.info(.initrd, "Opened, read and closed\n", .{});
|
||||
}
|
||||
|
||||
///
|
||||
/// The ramdisk runtime tests that will test the ramdisks functionality.
|
||||
///
|
||||
/// Arguments:
|
||||
/// IN rd_fs: *InitrdFS - The initialised ramdisk to play with.
|
||||
///
|
||||
fn runtimeTests(rd_fs: *InitrdFS) void {
|
||||
// There will be test files provided for the runtime tests
|
||||
// Need to init the VFS. This will be overridden after the tests.
|
||||
vfs.setRoot(rd_fs.root_node);
|
||||
rt_openReadClose(rd_fs.allocator);
|
||||
if (rd_fs.opened_files.items().len != 0) {
|
||||
panic(@errorReturnTrace(), "FAILURE: Didn't close all files\n", .{});
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue