03cc316001
The last three phases of the filesystem, which were written together and
touch the same files throughout -- kmount.c, objw.c and vfs.c are each
rewritten by all three -- so they land as one commit rather than three
that could not be built separately.
Durability. A transaction that reaches the platter out of order is worse
than one that never reached it: the uberblock can name a tree whose
blocks are still in the drive's write cache. bdirty/bflush give the
buffer layer an explicit barrier, ideflush issues ATA FLUSH CACHE and
usb_storage_flush the SCSI SYNCHRONIZE CACHE that means the same thing,
and a commit now waits for the data before it writes the root that
points at it. The uberblock groups are read newest-first with fallback,
so a volume whose newest roots are torn mounts at an older one and says
which generations were lost.
Reflink. Extents carry a refcount, so two objects can name the same
blocks and neither frees them while the other holds them. Exposed as
FICLONE -- Linux's ioctl value, so `cp --reflink` works unmodified --
and as cmd/reflink for the case where there is no cp to hand.
Attributes, and the one genuinely new idea here. attr.c stores named
values on an object, reachable through setxattr/getxattr/removexattr at
Linux's syscall numbers. On top of that, schfs_index declares an index
over an attribute name and schfs_query answers "which objects carry this
value" from the B-tree rather than by walking. A query against an
unindexed attribute is refused with an error, never silently answered by
a full scan: a query that quietly becomes a scan is worse than one that
admits it cannot help. cmd/schattr drives both.
Three bugs fixed on the way, each found by the numbers being wrong
rather than by inspection:
- statfs's f_fsid was declared int64[2]. Linux's fsid_t is two *ints*,
so every field after it landed one slot late: userland read f_frsize
out of f_namelen, got 255, and df reported a 32 MB root filesystem
as 1992 KB. It hid for as long as it did because the fields used to
be invented constants, so wrong numbers looked like the usual ones.
- struct inode's nlink was a short against SchFS's uint32, so a file
past 32767 names came back negative -- and iput frees an object
whose count reaches zero. It is an int now, signed on purpose, so an
underflow lands somewhere a check can see rather than wrapping.
- filewrite split every write to fit v1's log. That limit belongs to
the journal, not to writing, and SchFS makes one transaction of
whatever it is handed: a 1 MB write was becoming 170 commits and
170 flushes for nothing. fs_ops carries max_write now, and SchFS
sets no limit.
Also here: a real mount table, so `mount -t schfs /dev/hdb /mnt` shows
up in /proc/mounts -- df looks a path up there before it calls statfs at
all, so a mount missing from that list was invisible to it -- several
volumes mounted at once, snapshots mounted by name, and /proc/fsstat
with an rdtsc-based counter, which is the only instrument fine enough to
see inside a single syscall.
Verified: `make schfs-check` passes in full, including the sweep that
crashes the volume at each of 119 points mid-transaction and requires
every one to mount with exactly its committed data, and the case where
both newest uberblocks are rubbish and the volume still comes back. The
headless boot check passes with 27 [ok] and no failures, on a SchFS root.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
149 lines
No EOL
4.7 KiB
C
149 lines
No EOL
4.7 KiB
C
#pragma once
|
|
#ifndef USER_H
|
|
#define USER_H
|
|
|
|
#include "types.h"
|
|
#include "date.h"
|
|
|
|
struct stat;
|
|
struct rtcdate;
|
|
struct mouse_data;
|
|
|
|
// --- system calls ---
|
|
int fork(void);
|
|
void exit(void) __attribute__((noreturn));
|
|
int wait(void);
|
|
int pipe(int*);
|
|
int write(int, void*, int);
|
|
int read(int, void*, int);
|
|
int close(int);
|
|
int kill(int);
|
|
int exec(char*, char**);
|
|
int open(char*, int);
|
|
int mknod(char*, short, short);
|
|
int unlink(char*);
|
|
int fstat(int fd, struct stat*);
|
|
int link(char*, char*);
|
|
int mkdir(char*);
|
|
int chdir(char*);
|
|
int dup(int);
|
|
int dup2(int, int);
|
|
int fcntl(int, int, int);
|
|
long lseek(int, long, int);
|
|
int getpid(void);
|
|
char* sbrk(uint64);
|
|
int sleep(int);
|
|
int uptime(void);
|
|
int vga_sync(void*);
|
|
int getmouse(struct mouse_data*);
|
|
int reboot(void);
|
|
int shutdown(void);
|
|
int sigfillset(sigset_t *set);
|
|
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
|
|
int sigwait(const sigset_t *set, int *sig);
|
|
int alarm(int seconds);
|
|
int waitpid(int pid, int *status, int options);
|
|
int setsid(void);
|
|
void* mmap(void*, uint64, int, int, int, uint64);
|
|
// Shared memory. shmat returns the attach address, or a small negative value
|
|
// on failure — there is no errno in this runtime, so check for < 0.
|
|
int shmget(int key, uint64 size, int flags);
|
|
void* shmat(int id, void *addr, int flags);
|
|
int shmdt(void *addr);
|
|
int munmap(void*, uint64);
|
|
int delete(char*);
|
|
int show(char*);
|
|
int showstat(char*, struct stat*);
|
|
int ftruncate(int, int);
|
|
int truncate(char*, int);
|
|
int rename(const char*, const char*);
|
|
int symlink(char*, char*);
|
|
int readlink(char*, char*, int);
|
|
int getuid(void);
|
|
int geteuid(void);
|
|
int nanosleep(void*);
|
|
int mprotect(void*, uint64, int);
|
|
int ioctl(int, uint64, void*);
|
|
|
|
// Attributes on a file, and the index over them. Only SchFS carries these;
|
|
// anything else answers EOPNOTSUPP.
|
|
//
|
|
// schfs_query returns how many object ids it wrote, or -1 if the attribute has
|
|
// no index -- it will not fall back to walking the filesystem, because a query
|
|
// that silently becomes a full scan is worse than one that says it cannot help.
|
|
int setxattr(const char *path, const char *name, const void *val, int size,
|
|
int flags);
|
|
int getxattr(const char *path, const char *name, void *val, int size);
|
|
int removexattr(const char *path, const char *name);
|
|
int schfs_index(const char *name);
|
|
int schfs_query(const char *name, const char *value,
|
|
unsigned long long *out, int cap);
|
|
char* getcwd(char*, int);
|
|
int arch_prctl(int, uint64);
|
|
int set_tid_address(int*);
|
|
int set_robust_list(void*, int);
|
|
int futex(int*, int, int, void*, int*, int);
|
|
int clone(uint64, void*, void*, void*, void*);
|
|
void exit_group(int) __attribute__((noreturn));
|
|
int wait4(int, int*, int, void*);
|
|
int getgid(void);
|
|
int getegid(void);
|
|
int umask(int);
|
|
int writev(int, void*, int);
|
|
int readv(int, void*, int);
|
|
void* brk(void*);
|
|
int prlimit(int, int, void*, void*);
|
|
int lstat(const char*, struct stat*);
|
|
int access(const char*, int);
|
|
int openat(int, const char*, int, ...);
|
|
int fchdir(int);
|
|
int enable_linux_abi(void);
|
|
int getrlimit(int, void*);
|
|
int setuid(int);
|
|
int setgid(int);
|
|
int getsid(int);
|
|
int dup3(int, int, int);
|
|
int pipe2(int*, int);
|
|
int clock_gettime(int, void*);
|
|
int getppid(void);
|
|
int rt_sigaction(int, void*, void*, uint64);
|
|
int mount(const char *src, const char *tgt, const char *fstype, uint64 flags, void *data);
|
|
|
|
// Directory reading. The kernel has had getdents64 since the Linux ABI landed,
|
|
// but nothing declared it here, so first-party programs had no way to list a
|
|
// directory at all -- which is what schinit needs to find its job files.
|
|
//
|
|
// Records are packed: step by d_reclen, never by sizeof, because d_name is a
|
|
// flexible array and each record is only as long as its name needs.
|
|
struct dirent64 {
|
|
uint64 d_ino;
|
|
int64 d_off;
|
|
ushort d_reclen;
|
|
uchar d_type;
|
|
char d_name[];
|
|
};
|
|
#define DT_DIR 4
|
|
#define DT_REG 8
|
|
|
|
int getdents64(int fd, void *buf, int count);
|
|
|
|
// Sockets. `struct sockaddr` and the AF_*/SOCK_* constants are in socket.h;
|
|
// include it as well as this header to use them.
|
|
struct sockaddr;
|
|
int socket(int domain, int type, int protocol);
|
|
int bind(int fd, const struct sockaddr *addr, int addrlen);
|
|
int listen(int fd, int backlog);
|
|
int accept(int fd, struct sockaddr *addr, int *addrlen);
|
|
int connect(int fd, const struct sockaddr *addr, int addrlen);
|
|
int socketpair(int domain, int type, int protocol, int sv[2]);
|
|
int sendto(int fd, const void *buf, int len, int flags, const struct sockaddr*, int);
|
|
int recvfrom(int fd, void *buf, int len, int flags, struct sockaddr*, int*);
|
|
int sockshutdown(int fd, int how);
|
|
int setsockopt(int fd, int level, int opt, const void *val, int len);
|
|
int getsockopt(int fd, int level, int opt, void *val, int *len);
|
|
|
|
// --- ulib.c ---
|
|
int stat(const char*, struct stat*);
|
|
char* gets(char*, int max);
|
|
|
|
#endif // USER_H
|