From 3808f903625f42f58aa95e43e3caca3efaa4d118 Mon Sep 17 00:00:00 2001 From: Sanjit Bhat Date: Mon, 30 Oct 2023 14:39:28 -0500 Subject: [PATCH 1/7] lock: release lab --- .gitignore | 10 + Makefile | 227 +++++++++++++++-- conf/lab.mk | 1 + grade-lab-lock | 58 +++++ gradelib.py | 628 ++++++++++++++++++++++++++++++++++++++++++++++ kernel/defs.h | 49 ++++ kernel/file.h | 8 + kernel/fs.c | 9 +- kernel/kcsan.c | 323 ++++++++++++++++++++++++ kernel/main.c | 12 +- kernel/pipe.c | 3 + kernel/riscv.h | 11 + kernel/spinlock.c | 111 +++++++- kernel/spinlock.h | 4 + kernel/sprintf.c | 91 +++++++ kernel/start.c | 5 + kernel/stats.c | 69 +++++ user/bcachetest.c | 189 ++++++++++++++ user/init.c | 1 + user/kalloctest.c | 161 ++++++++++++ user/statistics.c | 24 ++ user/stats.c | 24 ++ user/user.h | 9 + 23 files changed, 2003 insertions(+), 24 deletions(-) create mode 100644 conf/lab.mk create mode 100755 grade-lab-lock create mode 100644 gradelib.py create mode 100644 kernel/kcsan.c create mode 100644 kernel/sprintf.c create mode 100644 kernel/stats.c create mode 100644 user/bcachetest.c create mode 100644 user/kalloctest.c create mode 100644 user/statistics.c create mode 100644 user/stats.c diff --git a/.gitignore b/.gitignore index 07216f3..d036a8b 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,13 @@ mkfs kernel/kernel user/usys.S .gdbinit +*.zip +xv6.out* +.vagrant/ +submissions/ +ph +barrier +/lab-*.json +.DS_Store +*.dSYM +*.pcap diff --git a/Makefile b/Makefile index 39a99d7..8e74f52 100644 --- a/Makefile +++ b/Makefile @@ -1,14 +1,16 @@ + +# To compile and run with a lab solution, set the lab name in conf/lab.mk +# (e.g., LAB=util). Run make grade to test solution with the lab's +# grade script (e.g., grade-lab-util). + +-include conf/lab.mk + K=kernel U=user OBJS = \ $K/entry.o \ - $K/start.o \ - $K/console.o \ - $K/printf.o \ - $K/uart.o \ $K/kalloc.o \ - $K/spinlock.o \ $K/string.o \ $K/main.o \ $K/vm.o \ @@ -30,6 +32,34 @@ OBJS = \ $K/plic.o \ $K/virtio_disk.o +OBJS_KCSAN = \ + $K/start.o \ + $K/console.o \ + $K/printf.o \ + $K/uart.o \ + $K/spinlock.o + +ifdef KCSAN +OBJS_KCSAN += \ + $K/kcsan.o +endif + +ifeq ($(LAB),lock) +OBJS += \ + $K/stats.o\ + $K/sprintf.o +endif + + +ifeq ($(LAB),net) +OBJS += \ + $K/e1000.o \ + $K/net.o \ + $K/sysnet.o \ + $K/pci.o +endif + + # riscv64-unknown-elf- or riscv64-linux-gnu- # perhaps in /opt/riscv/bin #TOOLPREFIX = @@ -57,12 +87,28 @@ OBJCOPY = $(TOOLPREFIX)objcopy OBJDUMP = $(TOOLPREFIX)objdump CFLAGS = -Wall -Werror -O -fno-omit-frame-pointer -ggdb -gdwarf-2 + +ifdef LAB +LABUPPER = $(shell echo $(LAB) | tr a-z A-Z) +XCFLAGS += -DSOL_$(LABUPPER) -DLAB_$(LABUPPER) +endif + +CFLAGS += $(XCFLAGS) CFLAGS += -MD CFLAGS += -mcmodel=medany CFLAGS += -ffreestanding -fno-common -nostdlib -mno-relax CFLAGS += -I. CFLAGS += $(shell $(CC) -fno-stack-protector -E -x c /dev/null >/dev/null 2>&1 && echo -fno-stack-protector) +ifeq ($(LAB),net) +CFLAGS += -DNET_TESTS_PORT=$(SERVERPORT) +endif + +ifdef KCSAN +CFLAGS += -DKCSAN +KCSANFLAG = -fsanitize=thread -fno-inline +endif + # Disable PIE when possible (for Ubuntu 16.10 toolchain) ifneq ($(shell $(CC) -dumpspecs 2>/dev/null | grep -e '[^f]no-pie'),) CFLAGS += -fno-pie -no-pie @@ -73,11 +119,17 @@ endif LDFLAGS = -z max-page-size=4096 -$K/kernel: $(OBJS) $K/kernel.ld $U/initcode - $(LD) $(LDFLAGS) -T $K/kernel.ld -o $K/kernel $(OBJS) +$K/kernel: $(OBJS) $(OBJS_KCSAN) $K/kernel.ld $U/initcode + $(LD) $(LDFLAGS) -T $K/kernel.ld -o $K/kernel $(OBJS) $(OBJS_KCSAN) $(OBJDUMP) -S $K/kernel > $K/kernel.asm $(OBJDUMP) -t $K/kernel | sed '1,/SYMBOL TABLE/d; s/ .* / /; /^$$/d' > $K/kernel.sym +$(OBJS): EXTRAFLAG := $(KCSANFLAG) + +$K/%.o: $K/%.c + $(CC) $(CFLAGS) $(EXTRAFLAG) -c -o $@ $< + + $U/initcode: $U/initcode.S $(CC) $(CFLAGS) -march=rv64g -nostdinc -I. -Ikernel -c $U/initcode.S -o $U/initcode.o $(LD) $(LDFLAGS) -N -e start -Ttext 0 -o $U/initcode.out $U/initcode.o @@ -89,6 +141,10 @@ tags: $(OBJS) _init ULIB = $U/ulib.o $U/usys.o $U/printf.o $U/umalloc.o +ifeq ($(LAB),lock) +ULIB += $U/statistics.o +endif + _%: %.o $(ULIB) $(LD) $(LDFLAGS) -T $U/user.ld -o $@ $^ $(OBJDUMP) -S $@ > $*.asm @@ -107,7 +163,7 @@ $U/_forktest: $U/forktest.o $(ULIB) $(OBJDUMP) -S $U/_forktest > $U/forktest.asm mkfs/mkfs: mkfs/mkfs.c $K/fs.h $K/param.h - gcc -Werror -Wall -I. -o mkfs/mkfs mkfs/mkfs.c + gcc $(XCFLAGS) -Werror -Wall -I. -o mkfs/mkfs mkfs/mkfs.c # Prevent deletion of intermediate files, e.g. cat.o, after first build, so # that disk image changes after first build are persistent until clean. More @@ -133,18 +189,89 @@ UPROGS=\ $U/_wc\ $U/_zombie\ -fs.img: mkfs/mkfs README $(UPROGS) - mkfs/mkfs fs.img README $(UPROGS) + + + +ifeq ($(LAB),lock) +UPROGS += \ + $U/_stats +endif + +ifeq ($(LAB),traps) +UPROGS += \ + $U/_call\ + $U/_bttest +endif + +ifeq ($(LAB),lazy) +UPROGS += \ + $U/_lazytests +endif + +ifeq ($(LAB),cow) +UPROGS += \ + $U/_cowtest +endif + +ifeq ($(LAB),thread) +UPROGS += \ + $U/_uthread + +$U/uthread_switch.o : $U/uthread_switch.S + $(CC) $(CFLAGS) -c -o $U/uthread_switch.o $U/uthread_switch.S + +$U/_uthread: $U/uthread.o $U/uthread_switch.o $(ULIB) + $(LD) $(LDFLAGS) -N -e main -Ttext 0 -o $U/_uthread $U/uthread.o $U/uthread_switch.o $(ULIB) + $(OBJDUMP) -S $U/_uthread > $U/uthread.asm + +ph: notxv6/ph.c + gcc -o ph -g -O2 $(XCFLAGS) notxv6/ph.c -pthread + +barrier: notxv6/barrier.c + gcc -o barrier -g -O2 $(XCFLAGS) notxv6/barrier.c -pthread +endif + +ifeq ($(LAB),pgtbl) +UPROGS += \ + $U/_pgtbltest +endif + +ifeq ($(LAB),lock) +UPROGS += \ + $U/_kalloctest\ + $U/_bcachetest +endif + +ifeq ($(LAB),fs) +UPROGS += \ + $U/_bigfile +endif + + + +ifeq ($(LAB),net) +UPROGS += \ + $U/_nettests +endif + +UEXTRA= +ifeq ($(LAB),util) + UEXTRA += user/xargstest.sh +endif + + +fs.img: mkfs/mkfs README $(UEXTRA) $(UPROGS) + mkfs/mkfs fs.img README $(UEXTRA) $(UPROGS) -include kernel/*.d user/*.d -clean: - rm -f *.tex *.dvi *.idx *.aux *.log *.ind *.ilg \ +clean: + rm -rf *.tex *.dvi *.idx *.aux *.log *.ind *.ilg *.dSYM *.zip *.pcap \ */*.o */*.d */*.asm */*.sym \ - $U/initcode $U/initcode.out $K/kernel fs.img \ - mkfs/mkfs .gdbinit \ - $U/usys.S \ - $(UPROGS) + $U/initcode $U/initcode.out $U/usys.S $U/_* \ + $K/kernel \ + mkfs/mkfs fs.img .gdbinit __pycache__ xv6.out* \ + ph barrier # try to generate a unique GDB port GDBPORT = $(shell expr `id -u` % 5000 + 25000) @@ -155,12 +282,22 @@ QEMUGDB = $(shell if $(QEMU) -help | grep -q '^-gdb'; \ ifndef CPUS CPUS := 3 endif +ifeq ($(LAB),fs) +CPUS := 1 +endif + +FWDPORT = $(shell expr `id -u` % 5000 + 25999) QEMUOPTS = -machine virt -bios none -kernel $K/kernel -m 128M -smp $(CPUS) -nographic QEMUOPTS += -global virtio-mmio.force-legacy=false QEMUOPTS += -drive file=fs.img,if=none,format=raw,id=x0 QEMUOPTS += -device virtio-blk-device,drive=x0,bus=virtio-mmio-bus.0 +ifeq ($(LAB),net) +QEMUOPTS += -netdev user,id=net0,hostfwd=udp::$(FWDPORT)-:2000 -object filter-dump,id=net0,netdev=net0,file=packets.pcap +QEMUOPTS += -device e1000,netdev=net0,bus=pcie.0 +endif + qemu: $K/kernel fs.img $(QEMU) $(QEMUOPTS) @@ -171,3 +308,61 @@ qemu-gdb: $K/kernel .gdbinit fs.img @echo "*** Now run 'gdb' in another window." 1>&2 $(QEMU) $(QEMUOPTS) -S $(QEMUGDB) +ifeq ($(LAB),net) +# try to generate a unique port for the echo server +SERVERPORT = $(shell expr `id -u` % 5000 + 25099) + +server: + python3 server.py $(SERVERPORT) + +ping: + python3 ping.py $(FWDPORT) +endif + +## +## FOR testing lab grading script +## + +ifneq ($(V),@) +GRADEFLAGS += -v +endif + +print-gdbport: + @echo $(GDBPORT) + +grade: + @echo $(MAKE) clean + @$(MAKE) clean || \ + (echo "'make clean' failed. HINT: Do you have another running instance of xv6?" && exit 1) + ./grade-lab-$(LAB) $(GRADEFLAGS) + +## +## FOR submissions +## + +submit-check: + @if ! test -d .git; then \ + echo No .git directory, is this a git repository?; \ + false; \ + fi + @if test "$$(git symbolic-ref HEAD)" != refs/heads/$(LAB); then \ + git branch; \ + read -p "You are not on the $(LAB) branch. Hand-in the current branch? [y/N] " r; \ + test "$$r" = y; \ + fi + @if ! git diff-files --quiet || ! git diff-index --quiet --cached HEAD; then \ + git status -s; \ + echo; \ + echo "You have uncomitted changes. Please commit or stash them."; \ + false; \ + fi + @if test -n "`git status -s`"; then \ + git status -s; \ + read -p "Untracked files will not be handed in. Continue? [y/N] " r; \ + test "$$r" = y; \ + fi + +zipball: clean submit-check + git archive --verbose --format zip --output lab.zip HEAD + +.PHONY: zipball clean grade submit-check diff --git a/conf/lab.mk b/conf/lab.mk new file mode 100644 index 0000000..1e7f18d --- /dev/null +++ b/conf/lab.mk @@ -0,0 +1 @@ +LAB=lock diff --git a/grade-lab-lock b/grade-lab-lock new file mode 100755 index 0000000..770d676 --- /dev/null +++ b/grade-lab-lock @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 + +import re +from gradelib import * + +r = Runner(save("xv6.out")) + +@test(0, "running kalloctest") +def test_kalloctest(): + r.run_qemu(shell_script([ + 'kalloctest' + ]), timeout=200) + +@test(10, "kalloctest: test1", parent=test_kalloctest) +def test_kalloctest_test1(): + r.match('^test1 OK$') + +@test(10, "kalloctest: test2", parent=test_kalloctest) +def test_kalloctest_test2(): + r.match('^test2 OK$') + +@test(10, "kalloctest: test3", parent=test_kalloctest) +def test_kalloctest_test3(): + r.match('^test3 OK$') + +@test(10, "kalloctest: sbrkmuch") +def test_sbrkmuch(): + r.run_qemu(shell_script([ + 'usertests sbrkmuch' + ]), timeout=90) + r.match('^ALL TESTS PASSED$') + +@test(0, "running bcachetest") +def test_bcachetest(): + r.run_qemu(shell_script([ + 'bcachetest' + ]), timeout=90) + +@test(10, "bcachetest: test0", parent=test_bcachetest) +def test_bcachetest_test0(): + r.match('^test0: OK$') + +@test(10, "bcachetest: test1", parent=test_bcachetest) +def test_bcachetest_test1(): + r.match('^test1 OK$') + +@test(19, "usertests") +def test_usertests(): + r.run_qemu(shell_script([ + 'usertests -q' + ]), timeout=300) + r.match('^ALL TESTS PASSED$') + +@test(1, "time") +def test_time(): + check_time() + +run_tests() diff --git a/gradelib.py b/gradelib.py new file mode 100644 index 0000000..f0d4934 --- /dev/null +++ b/gradelib.py @@ -0,0 +1,628 @@ +from __future__ import print_function + +import sys, os, re, time, socket, select, subprocess, errno, shutil, random, string, json +from subprocess import check_call, Popen +from optparse import OptionParser + +__all__ = [] + +################################################################## +# Test structure +# + +__all__ += ["test", "end_part", "run_tests", "get_current_test"] + +TESTS = [] +TOTAL = POSSIBLE = 0 +PART_TOTAL = PART_POSSIBLE = 0 +CURRENT_TEST = None +GRADES = {} + +def test(points, title=None, parent=None): + """Decorator for declaring test functions. If title is None, the + title of the test will be derived from the function name by + stripping the leading "test_" and replacing underscores with + spaces.""" + + def register_test(fn, title=title): + if not title: + assert fn.__name__.startswith("test_") + title = fn.__name__[5:].replace("_", " ") + if parent: + title = " " + title + + def run_test(): + global TOTAL, POSSIBLE, CURRENT_TEST, GRADES + + # Handle test dependencies + if run_test.complete: + return run_test.ok + run_test.complete = True + parent_failed = False + if parent: + parent_failed = not parent() + + # Run the test + fail = None + start = time.time() + CURRENT_TEST = run_test + sys.stdout.write("== Test %s == " % title) + if parent: + sys.stdout.write("\n") + sys.stdout.flush() + try: + if parent_failed: + raise AssertionError('Parent failed: %s' % parent.__name__) + fn() + except AssertionError as e: + fail = str(e) + + # Display and handle test result + POSSIBLE += points + if points: + print("%s: %s" % (title, \ + (color("red", "FAIL") if fail else color("green", "OK"))), end=' ') + if time.time() - start > 0.1: + print("(%.1fs)" % (time.time() - start), end=' ') + print() + if fail: + print(" %s" % fail.replace("\n", "\n ")) + else: + TOTAL += points + if points: + GRADES[title] = 0 if fail else points + + for callback in run_test.on_finish: + callback(fail) + CURRENT_TEST = None + + run_test.ok = not fail + return run_test.ok + + # Record test metadata on the test wrapper function + run_test.__name__ = fn.__name__ + run_test.title = title + run_test.complete = False + run_test.ok = False + run_test.on_finish = [] + TESTS.append(run_test) + return run_test + return register_test + +def end_part(name): + def show_part(): + global PART_TOTAL, PART_POSSIBLE + print("Part %s score: %d/%d" % \ + (name, TOTAL - PART_TOTAL, POSSIBLE - PART_POSSIBLE)) + print() + PART_TOTAL, PART_POSSIBLE = TOTAL, POSSIBLE + show_part.title = "" + TESTS.append(show_part) + +def write_results(): + global options + if not options.results: + return + try: + with open(options.results, "w") as f: + f.write(json.dumps(GRADES)) + except OSError as e: + print("Provided a bad results path. Error:", e) + +def run_tests(): + """Set up for testing and run the registered test functions.""" + + # Handle command line + global options + parser = OptionParser(usage="usage: %prog [-v] [filters...]") + parser.add_option("-v", "--verbose", action="store_true", + help="print commands") + parser.add_option("--color", choices=["never", "always", "auto"], + default="auto", help="never, always, or auto") + parser.add_option("--results", help="results file path") + (options, args) = parser.parse_args() + + # Start with a full build to catch build errors + make() + + # Clean the file system if there is one + reset_fs() + + # Run tests + limit = list(map(str.lower, args)) + try: + for test in TESTS: + if not limit or any(l in test.title.lower() for l in limit): + test() + if not limit: + write_results() + print("Score: %d/%d" % (TOTAL, POSSIBLE)) + except KeyboardInterrupt: + pass + if TOTAL < POSSIBLE: + sys.exit(1) + +def get_current_test(): + if not CURRENT_TEST: + raise RuntimeError("No test is running") + return CURRENT_TEST + +################################################################## +# Assertions +# + +__all__ += ["assert_equal", "assert_lines_match"] + +def assert_equal(got, expect, msg=""): + if got == expect: + return + if msg: + msg += "\n" + raise AssertionError("%sgot:\n %s\nexpected:\n %s" % + (msg, str(got).replace("\n", "\n "), + str(expect).replace("\n", "\n "))) + +def assert_lines_match(text, *regexps, **kw): + """Assert that all of regexps match some line in text. If a 'no' + keyword argument is given, it must be a list of regexps that must + *not* match any line in text.""" + + def assert_lines_match_kw(no=[]): + return no + no = assert_lines_match_kw(**kw) + + # Check text against regexps + lines = text.splitlines() + good = set() + bad = set() + for i, line in enumerate(lines): + if any(re.match(r, line) for r in regexps): + good.add(i) + regexps = [r for r in regexps if not re.match(r, line)] + if any(re.match(r, line) for r in no): + bad.add(i) + + if not regexps and not bad: + return + + # We failed; construct an informative failure message + show = set() + for lineno in good.union(bad): + for offset in range(-2, 3): + show.add(lineno + offset) + if regexps: + show.update(n for n in range(len(lines) - 5, len(lines))) + + msg = [] + last = -1 + for lineno in sorted(show): + if 0 <= lineno < len(lines): + if lineno != last + 1: + msg.append("...") + last = lineno + msg.append("%s %s" % (color("red", "BAD ") if lineno in bad else + color("green", "GOOD") if lineno in good + else " ", + lines[lineno])) + if last != len(lines) - 1: + msg.append("...") + if bad: + msg.append("unexpected lines in output") + for r in regexps: + msg.append(color("red", "MISSING") + " '%s'" % r) + raise AssertionError("\n".join(msg)) + +################################################################## +# Utilities +# + +__all__ += ["make", "maybe_unlink", "reset_fs", "color", "random_str", "check_time", "check_answers"] + +MAKE_TIMESTAMP = 0 + +def pre_make(): + """Delay prior to running make to ensure file mtimes change.""" + while int(time.time()) == MAKE_TIMESTAMP: + time.sleep(0.1) + +def post_make(): + """Record the time after make completes so that the next run of + make can be delayed if needed.""" + global MAKE_TIMESTAMP + MAKE_TIMESTAMP = int(time.time()) + +def make(*target): + pre_make() + if Popen(("make",) + target).wait(): + sys.exit(1) + post_make() + +def show_command(cmd): + from pipes import quote + print("\n$", " ".join(map(quote, cmd))) + +def maybe_unlink(*paths): + for path in paths: + try: + os.unlink(path) + except EnvironmentError as e: + if e.errno != errno.ENOENT: + raise + +COLORS = {"default": "\033[0m", "red": "\033[31m", "green": "\033[32m"} + +def color(name, text): + if options.color == "always" or (options.color == "auto" and os.isatty(1)): + return COLORS[name] + text + COLORS["default"] + return text + +def reset_fs(): + if os.path.exists("obj/fs/clean-fs.img"): + shutil.copyfile("obj/fs/clean-fs.img", "obj/fs/fs.img") + +def random_str(n=8): + letters = string.ascii_letters + string.digits + return ''.join(random.choice(letters) for _ in range(n)) + +def check_time(): + try: + print("") + with open('time.txt') as f: + d = f.read().strip() + if not re.match(r'^\d+$', d): + raise AssertionError('time.txt does not contain a single integer (number of hours spent on the lab)') + except IOError: + raise AssertionError('Cannot read time.txt') + +def check_answers(file, n=10): + try: + print("") + with open(file) as f: + d = f.read().strip() + if len(d) < n: + raise AssertionError('%s does not seem to contain enough text' % file) + except IOError: + raise AssertionError('Cannot read %s' % file) + + +################################################################## +# Controllers +# + +__all__ += ["QEMU", "GDBClient"] + +class QEMU(object): + _GDBPORT = None + + def __init__(self, *make_args): + # Check that QEMU is not currently running + try: + GDBClient(self.get_gdb_port(), timeout=0).close() + except socket.error: + pass + else: + print("""\ +GDB stub found on port %d. +QEMU appears to already be running. Please exit it if possible or use +'killall qemu' or 'killall qemu.real'.""" % self.get_gdb_port(), file=sys.stderr) + sys.exit(1) + + if options.verbose: + show_command(("make",) + make_args) + cmd = ("make", "-s", "--no-print-directory") + make_args + self.proc = Popen(cmd, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + stdin=subprocess.PIPE) + # Accumulated output as a string + self.output = "" + # Accumulated output as a bytearray + self.outbytes = bytearray() + self.on_output = [] + + @staticmethod + def get_gdb_port(): + if QEMU._GDBPORT is None: + p = Popen(["make", "-s", "--no-print-directory", "print-gdbport"], + stdout=subprocess.PIPE) + (out, _) = p.communicate() + if p.returncode: + raise RuntimeError( + "Failed to get gdbport: make exited with %d" % + p.returncode) + QEMU._GDBPORT = int(out) + return QEMU._GDBPORT + + def fileno(self): + if self.proc: + return self.proc.stdout.fileno() + + def handle_read(self): + buf = os.read(self.proc.stdout.fileno(), 4096) + self.outbytes.extend(buf) + self.output = self.outbytes.decode("utf-8", "replace") + for callback in self.on_output: + callback(buf) + if buf == b"": + self.wait() + return + + def write(self, buf): + if isinstance(buf, str): + buf = buf.encode('utf-8') + self.proc.stdin.write(buf) + self.proc.stdin.flush() + + def wait(self): + if self.proc: + self.proc.wait() + self.proc = None + + def kill(self): + if self.proc: + self.proc.terminate() + +class GDBClient(object): + def __init__(self, port, timeout=15): + start = time.time() + while True: + self.sock = socket.socket() + try: + self.sock.settimeout(1) + self.sock.connect(("localhost", port)) + break + except socket.error: + if time.time() >= start + timeout: + raise + self.__buf = "" + + def fileno(self): + if self.sock: + return self.sock.fileno() + + def handle_read(self): + try: + data = self.sock.recv(4096).decode("ascii", "replace") + except socket.error: + data = "" + if data == "": + self.sock.close() + self.sock = None + return + self.__buf += data + + while True: + m = re.search(r"\$([^#]*)#[0-9a-zA-Z]{2}", self.__buf) + if not m: + break + pkt = m.group(1) + self.__buf = self.__buf[m.end():] + + if pkt.startswith("T05"): + # Breakpoint + raise TerminateTest + + def __send(self, cmd): + packet = "$%s#%02x" % (cmd, sum(map(ord, cmd)) % 256) + self.sock.sendall(packet.encode("ascii")) + + def __send_break(self): + self.sock.sendall(b"\x03") + + def close(self): + if self.sock: + self.sock.close() + self.sock = None + + def cont(self): + self.__send("c") + + def breakpoint(self, addr): + self.__send("Z1,%x,1" % addr) + + +################################################################## +# QEMU test runner +# + +__all__ += ["TerminateTest", "Runner"] + +class TerminateTest(Exception): + pass + +class Runner(): + def __init__(self, *default_monitors): + self.__default_monitors = default_monitors + + def run_qemu(self, *monitors, **kw): + """Run a QEMU-based test. monitors should functions that will + be called with this Runner instance once QEMU and GDB are + started. Typically, they should register callbacks that throw + TerminateTest when stop events occur. The target_base + argument gives the make target to run. The make_args argument + should be a list of additional arguments to pass to make. The + timeout argument bounds how long to run before returning.""" + + def run_qemu_kw(target_base="qemu", make_args=[], timeout=30): + return target_base, make_args, timeout + target_base, make_args, timeout = run_qemu_kw(**kw) + + # Start QEMU + pre_make() + self.qemu = QEMU(target_base + "-gdb", *make_args) + self.gdb = None + + try: + # Wait for QEMU to start or make to fail. This will set + # self.gdb if QEMU starts. + self.qemu.on_output = [self.__monitor_start] + self.__react([self.qemu], timeout=90) + self.qemu.on_output = [] + if self.gdb is None: + print("Failed to connect to QEMU; output:") + print(self.qemu.output) + sys.exit(1) + post_make() + + # QEMU and GDB are up + self.reactors = [self.qemu, self.gdb] + + # Start monitoring + for m in self.__default_monitors + monitors: + m(self) + + # Run and react + self.gdb.cont() + self.__react(self.reactors, timeout) + finally: + # Shutdown QEMU + try: + if self.gdb is None: + sys.exit(1) + self.qemu.kill() + self.__react(self.reactors, 5) + self.gdb.close() + self.qemu.wait() + except: + print("""\ +Failed to shutdown QEMU. You might need to 'killall qemu' or +'killall qemu.real'. +""") + raise + + def __monitor_start(self, output): + if b"\n" in output: + try: + self.gdb = GDBClient(self.qemu.get_gdb_port(), timeout=2) + raise TerminateTest + except socket.error: + pass + if not len(output): + raise TerminateTest + + def __react(self, reactors, timeout): + deadline = time.time() + timeout + try: + while True: + timeleft = deadline - time.time() + if timeleft < 0: + sys.stdout.write("Timeout! ") + sys.stdout.flush() + return + + rset = [r for r in reactors if r.fileno() is not None] + if not rset: + return + + rset, _, _ = select.select(rset, [], [], timeleft) + for reactor in rset: + reactor.handle_read() + except TerminateTest: + pass + + def user_test(self, binary, *monitors, **kw): + """Run a user test using the specified binary. Monitors and + keyword arguments are as for run_qemu. This runs on a disk + snapshot unless the keyword argument 'snapshot' is False.""" + + maybe_unlink("obj/kern/init.o", "obj/kern/kernel") + if kw.pop("snapshot", True): + kw.setdefault("make_args", []).append("QEMUEXTRA+=-snapshot") + self.run_qemu(target_base="run-%s" % binary, *monitors, **kw) + + def match(self, *args, **kwargs): + """Shortcut to call assert_lines_match on the most recent QEMU + output.""" + + assert_lines_match(self.qemu.output, *args, **kwargs) + +################################################################## +# Monitors +# + +__all__ += ["save", "stop_breakpoint", "call_on_line", "stop_on_line", "shell_script"] + +def save(path): + """Return a monitor that writes QEMU's output to path. If the + test fails, copy the output to path.test-name.""" + + def setup_save(runner): + f.seek(0) + f.truncate() + runner.qemu.on_output.append(f.write) + get_current_test().on_finish.append(save_on_finish) + + def save_on_finish(fail): + f.flush() + save_path = path + "." + get_current_test().__name__[5:] + if fail: + shutil.copyfile(path, save_path) + print(" QEMU output saved to %s" % save_path) + elif os.path.exists(save_path): + os.unlink(save_path) + print(" (Old %s failure log removed)" % save_path) + + f = open(path, "wb") + return setup_save + +def stop_breakpoint(addr): + """Returns a monitor that stops when addr is reached. addr may be + a number or the name of a symbol.""" + + def setup_breakpoint(runner): + if isinstance(addr, str): + addrs = [int(sym[:16], 16) for sym in open("kernel/kernel.sym") + if sym[17:].strip() == addr] + assert len(addrs), "Symbol %s not found" % addr + runner.gdb.breakpoint(addrs[0]) + else: + runner.gdb.breakpoint(addr) + return setup_breakpoint + +def call_on_line(regexp, callback): + """Returns a monitor that calls 'callback' when QEMU prints a line + matching 'regexp'.""" + + def setup_call_on_line(runner): + buf = bytearray() + def handle_output(output): + buf.extend(output) + while b"\n" in buf: + line, buf[:] = buf.split(b"\n", 1) + line = line.decode("utf-8", "replace") + if re.match(regexp, line): + callback(line) + runner.qemu.on_output.append(handle_output) + return setup_call_on_line + +def stop_on_line(regexp): + """Returns a monitor that stops when QEMU prints a line matching + 'regexp'.""" + + def stop(line): + raise TerminateTest + return call_on_line(regexp, stop) + +def shell_script(script, terminate_match=None): + """Returns a monitor that plays the script, and stops when the script is + done executing.""" + + def setup_call_on_line(runner): + class context: + n = 0 + buf = bytearray() + def handle_output(output): + context.buf.extend(output) + if terminate_match is not None: + if re.match(terminate_match, context.buf.decode('utf-8', 'replace')): + raise TerminateTest + if b'$ ' in context.buf: + context.buf = bytearray() + if context.n < len(script): + runner.qemu.write(script[context.n]) + runner.qemu.write('\n') + context.n += 1 + else: + if terminate_match is None: + raise TerminateTest + runner.qemu.on_output.append(handle_output) + return setup_call_on_line diff --git a/kernel/defs.h b/kernel/defs.h index a3c962b..c6fef8c 100644 --- a/kernel/defs.h +++ b/kernel/defs.h @@ -8,6 +8,10 @@ struct spinlock; struct sleeplock; struct stat; struct superblock; +#ifdef LAB_NET +struct mbuf; +struct sock; +#endif // bio.c void binit(void); @@ -117,6 +121,10 @@ void initlock(struct spinlock*, char*); void release(struct spinlock*); void push_off(void); void pop_off(void); +int atomic_read4(int *addr); +#ifdef LAB_LOCK +void freelock(struct spinlock*); +#endif // sleeplock.c void acquiresleep(struct sleeplock*); @@ -187,3 +195,44 @@ void virtio_disk_intr(void); // number of elements in fixed-size array #define NELEM(x) (sizeof(x)/sizeof((x)[0])) + + + +#ifdef LAB_PGTBL +// vmcopyin.c +int copyin_new(pagetable_t, char *, uint64, uint64); +int copyinstr_new(pagetable_t, char *, uint64, uint64); +#endif + +// stats.c +void statsinit(void); +void statsinc(void); + +// sprintf.c +int snprintf(char*, int, char*, ...); + +#ifdef KCSAN +void kcsaninit(); +#endif + +#ifdef LAB_NET +// pci.c +void pci_init(); + +// e1000.c +void e1000_init(uint32 *); +void e1000_intr(void); +int e1000_transmit(struct mbuf*); + +// net.c +void net_rx(struct mbuf*); +void net_tx_udp(struct mbuf*, uint32, uint16, uint16); + +// sysnet.c +void sockinit(void); +int sockalloc(struct file **, uint32, uint16, uint16); +void sockclose(struct sock *); +int sockread(struct sock *, uint64, int); +int sockwrite(struct sock *, uint64, int); +void sockrecvudp(struct mbuf*, uint32, uint16, uint16); +#endif diff --git a/kernel/file.h b/kernel/file.h index b076d1d..1eb5107 100644 --- a/kernel/file.h +++ b/kernel/file.h @@ -1,10 +1,17 @@ struct file { +#ifdef LAB_NET + enum { FD_NONE, FD_PIPE, FD_INODE, FD_DEVICE, FD_SOCK } type; +#else enum { FD_NONE, FD_PIPE, FD_INODE, FD_DEVICE } type; +#endif int ref; // reference count char readable; char writable; struct pipe *pipe; // FD_PIPE struct inode *ip; // FD_INODE and FD_DEVICE +#ifdef LAB_NET + struct sock *sock; // FD_SOCK +#endif uint off; // FD_INODE short major; // FD_DEVICE }; @@ -38,3 +45,4 @@ struct devsw { extern struct devsw devsw[]; #define CONSOLE 1 +#define STATS 2 diff --git a/kernel/fs.c b/kernel/fs.c index c6bab15..6c4079e 100644 --- a/kernel/fs.c +++ b/kernel/fs.c @@ -295,11 +295,11 @@ ilock(struct inode *ip) struct buf *bp; struct dinode *dip; - if(ip == 0 || ip->ref < 1) + if(ip == 0 || atomic_read4(&ip->ref) < 1) panic("ilock"); acquiresleep(&ip->lock); - + if(ip->valid == 0){ bp = bread(ip->dev, IBLOCK(ip->inum, sb)); dip = (struct dinode*)bp->data + ip->inum%IPB; @@ -320,7 +320,7 @@ ilock(struct inode *ip) void iunlock(struct inode *ip) { - if(ip == 0 || !holdingsleep(&ip->lock) || ip->ref < 1) + if(ip == 0 || !holdingsleep(&ip->lock) || atomic_read4(&ip->ref) < 1) panic("iunlock"); releasesleep(&ip->lock); @@ -416,7 +416,6 @@ bmap(struct inode *ip, uint bn) brelse(bp); return addr; } - panic("bmap: out of range"); } @@ -447,7 +446,7 @@ itrunc(struct inode *ip) bfree(ip->dev, ip->addrs[NDIRECT]); ip->addrs[NDIRECT] = 0; } - + ip->size = 0; iupdate(ip); } diff --git a/kernel/kcsan.c b/kernel/kcsan.c new file mode 100644 index 0000000..90861ba --- /dev/null +++ b/kernel/kcsan.c @@ -0,0 +1,323 @@ +#include "types.h" +#include "param.h" +#include "memlayout.h" +#include "spinlock.h" +#include "riscv.h" +#include "proc.h" +#include "defs.h" + +// +// Race detector using gcc's thread sanitizer. It delays all stores +// and loads and monitors if any other CPU is using the same address. +// If so, we have a race and print out the backtrace of the thread +// that raced and the thread that set the watchpoint. +// + +// +// To run with kcsan: +// make clean +// make KCSAN=1 qemu +// + +// The number of watch points. +#define NWATCH (NCPU) + +// The number of cycles to delay stores, whatever that means on qemu. +//#define DELAY_CYCLES 20000 +#define DELAY_CYCLES 200000 + +#define MAXTRACE 20 + +int +trace(uint64 *trace, int maxtrace) +{ + uint64 i = 0; + + push_off(); + + uint64 fp = r_fp(); + uint64 ra, low = PGROUNDDOWN(fp) + 16, high = PGROUNDUP(fp); + + while(!(fp & 7) && fp >= low && fp < high){ + ra = *(uint64*)(fp - 8); + fp = *(uint64*)(fp - 16); + trace[i++] = ra; + if(i >= maxtrace) + break; + } + + pop_off(); + + return i; +} + +struct watch { + uint64 addr; + int write; + int race; + uint64 trace[MAXTRACE]; + int tracesz; +}; + +struct { + struct spinlock lock; + struct watch points[NWATCH]; + int on; +} tsan; + +static struct watch* +wp_lookup(uint64 addr) +{ + for(struct watch *w = &tsan.points[0]; w < &tsan.points[NWATCH]; w++) { + if(w->addr == addr) { + return w; + } + } + return 0; +} + +static int +wp_install(uint64 addr, int write) +{ + for(struct watch *w = &tsan.points[0]; w < &tsan.points[NWATCH]; w++) { + if(w->addr == 0) { + w->addr = addr; + w->write = write; + w->tracesz = trace(w->trace, MAXTRACE); + return 1; + } + } + panic("wp_install"); + return 0; +} + +static void +wp_remove(uint64 addr) +{ + for(struct watch *w = &tsan.points[0]; w < &tsan.points[NWATCH]; w++) { + if(w->addr == addr) { + w->addr = 0; + w->tracesz = 0; + return; + } + } + panic("remove"); +} + +static void +printtrace(uint64 *t, int n) +{ + int i; + + for(i = 0; i < n; i++) { + printf("%p\n", t[i]); + } +} + +static void +race(char *s, struct watch *w) { + uint64 t[MAXTRACE]; + int n; + + n = trace(t, MAXTRACE); + printf("== race detected ==\n"); + printf("backtrace for racing %s\n", s); + printtrace(t, n); + printf("backtrace for watchpoint:\n"); + printtrace(w->trace, w->tracesz); + printf("==========\n"); +} + +// cycle counter +static inline uint64 +r_cycle() +{ + uint64 x; + asm volatile("rdcycle %0" : "=r" (x) ); + return x; +} + +static void delay(void) __attribute__((noinline)); +static void delay() { + uint64 stop = r_cycle() + DELAY_CYCLES; + uint64 c = r_cycle(); + while(c < stop) { + c = r_cycle(); + } +} + +static void +kcsan_read(uint64 addr, int sz) +{ + struct watch *w; + + acquire(&tsan.lock); + if((w = wp_lookup(addr)) != 0) { + if(w->write) { + race("load", w); + } + release(&tsan.lock); + return; + } + release(&tsan.lock); +} + +static void +kcsan_write(uint64 addr, int sz) +{ + struct watch *w; + + acquire(&tsan.lock); + if((w = wp_lookup(addr)) != 0) { + race("store", w); + release(&tsan.lock); + } + + // no watchpoint; try to install one + if(wp_install(addr, 1)) { + + release(&tsan.lock); + + // XXX maybe read value at addr before and after delay to catch + // races of unknown origins (e.g., device). + + delay(); + + acquire(&tsan.lock); + + wp_remove(addr); + } + release(&tsan.lock); +} + +// tsan.on will only have effect with "make KCSAN=1" +void +kcsaninit(void) +{ + initlock(&tsan.lock, "tsan"); + tsan.on = 1; + __sync_synchronize(); +} + +// +// Calls inserted by compiler into kernel binary, except for this file. +// + +void +__tsan_init(void) +{ +} + +void +__tsan_read1(uint64 addr) +{ + if(!tsan.on) + return; + // kcsan_read(addr, 1); +} + +void +__tsan_read2(uint64 addr) +{ + if(!tsan.on) + return; + kcsan_read(addr, 2); +} + +void +__tsan_read4(uint64 addr) +{ + if(!tsan.on) + return; + kcsan_read(addr, 4); +} + +void +__tsan_read8(uint64 addr) +{ + if(!tsan.on) + return; + kcsan_read(addr, 8); +} + +void +__tsan_read_range(uint64 addr, uint64 size) +{ + if(!tsan.on) + return; + kcsan_read(addr, size); +} + +void +__tsan_write1(uint64 addr) +{ + if(!tsan.on) + return; + // kcsan_write(addr, 1); +} + +void +__tsan_write2(uint64 addr) +{ + if(!tsan.on) + return; + kcsan_write(addr, 2); +} + +void +__tsan_write4(uint64 addr) +{ + if(!tsan.on) + return; + kcsan_write(addr, 4); +} + +void +__tsan_write8(uint64 addr) +{ + if(!tsan.on) + return; + kcsan_write(addr, 8); +} + +void +__tsan_write_range(uint64 addr, uint64 size) +{ + if(!tsan.on) + return; + kcsan_write(addr, size); +} + +void +__tsan_atomic_thread_fence(int order) +{ + __sync_synchronize(); +} + +uint32 +__tsan_atomic32_load(uint *ptr, uint *val, int order) +{ + uint t; + __atomic_load(ptr, &t, __ATOMIC_SEQ_CST); + return t; +} + +void +__tsan_atomic32_store(uint *ptr, uint val, int order) +{ + __atomic_store(ptr, &val, __ATOMIC_SEQ_CST); +} + +// We don't use this +void +__tsan_func_entry(uint64 pc) +{ +} + +// We don't use this +void +__tsan_func_exit(void) +{ +} + + diff --git a/kernel/main.c b/kernel/main.c index f0d3171..48c9555 100644 --- a/kernel/main.c +++ b/kernel/main.c @@ -12,6 +12,9 @@ main() { if(cpuid() == 0){ consoleinit(); +#if defined(LAB_LOCK) + statsinit(); +#endif printfinit(); printf("\n"); printf("xv6 kernel is booting\n"); @@ -28,11 +31,18 @@ main() iinit(); // inode table fileinit(); // file table virtio_disk_init(); // emulated hard disk +#ifdef LAB_NET + pci_init(); + sockinit(); +#endif userinit(); // first user process +#ifdef KCSAN + kcsaninit(); +#endif __sync_synchronize(); started = 1; } else { - while(started == 0) + while(atomic_read4((int *) &started) == 0) ; __sync_synchronize(); printf("hart %d starting\n", cpuid()); diff --git a/kernel/pipe.c b/kernel/pipe.c index f6b501a..41a9c5e 100644 --- a/kernel/pipe.c +++ b/kernel/pipe.c @@ -68,6 +68,9 @@ pipeclose(struct pipe *pi, int writable) } if(pi->readopen == 0 && pi->writeopen == 0){ release(&pi->lock); +#ifdef LAB_LOCK + freelock(&pi->lock); +#endif kfree((char*)pi); } else release(&pi->lock); diff --git a/kernel/riscv.h b/kernel/riscv.h index 20a01db..adc3e38 100644 --- a/kernel/riscv.h +++ b/kernel/riscv.h @@ -295,6 +295,14 @@ r_sp() return x; } +static inline uint64 +r_fp() +{ + uint64 x; + asm volatile("mv %0, s0" : "=r" (x) ); + return x; +} + // read and write tp, the thread pointer, which xv6 uses to hold // this core's hartid (core number), the index into cpus[]. static inline uint64 @@ -344,6 +352,9 @@ typedef uint64 *pagetable_t; // 512 PTEs #define PTE_X (1L << 3) #define PTE_U (1L << 4) // user can access + + + // shift a physical address to the right place for a PTE. #define PA2PTE(pa) ((((uint64)pa) >> 12) << 10) diff --git a/kernel/spinlock.c b/kernel/spinlock.c index 9840302..266a698 100644 --- a/kernel/spinlock.c +++ b/kernel/spinlock.c @@ -8,12 +8,52 @@ #include "proc.h" #include "defs.h" +#ifdef LAB_LOCK +#define NLOCK 500 + +static struct spinlock *locks[NLOCK]; +struct spinlock lock_locks; + +void +freelock(struct spinlock *lk) +{ + acquire(&lock_locks); + int i; + for (i = 0; i < NLOCK; i++) { + if(locks[i] == lk) { + locks[i] = 0; + break; + } + } + release(&lock_locks); +} + +static void +findslot(struct spinlock *lk) { + acquire(&lock_locks); + int i; + for (i = 0; i < NLOCK; i++) { + if(locks[i] == 0) { + locks[i] = lk; + release(&lock_locks); + return; + } + } + panic("findslot"); +} +#endif + void initlock(struct spinlock *lk, char *name) { lk->name = name; lk->locked = 0; lk->cpu = 0; +#ifdef LAB_LOCK + lk->nts = 0; + lk->n = 0; + findslot(lk); +#endif } // Acquire the lock. @@ -25,12 +65,21 @@ acquire(struct spinlock *lk) if(holding(lk)) panic("acquire"); +#ifdef LAB_LOCK + __sync_fetch_and_add(&(lk->n), 1); +#endif + // On RISC-V, sync_lock_test_and_set turns into an atomic swap: // a5 = 1 // s1 = &lk->locked // amoswap.w.aq a5, a5, (s1) - while(__sync_lock_test_and_set(&lk->locked, 1) != 0) - ; + while(__sync_lock_test_and_set(&lk->locked, 1) != 0) { +#ifdef LAB_LOCK + __sync_fetch_and_add(&(lk->nts), 1); +#else + ; +#endif + } // Tell the C compiler and the processor to not move loads or stores // past this point, to ensure that the critical section's memory @@ -108,3 +157,61 @@ pop_off(void) if(c->noff == 0 && c->intena) intr_on(); } + +// Read a shared 32-bit value without holding a lock +int +atomic_read4(int *addr) { + uint32 val; + __atomic_load(addr, &val, __ATOMIC_SEQ_CST); + return val; +} + +#ifdef LAB_LOCK +int +snprint_lock(char *buf, int sz, struct spinlock *lk) +{ + int n = 0; + if(lk->n > 0) { + n = snprintf(buf, sz, "lock: %s: #test-and-set %d #acquire() %d\n", + lk->name, lk->nts, lk->n); + } + return n; +} + +int +statslock(char *buf, int sz) { + int n; + int tot = 0; + + acquire(&lock_locks); + n = snprintf(buf, sz, "--- lock kmem/bcache stats\n"); + for(int i = 0; i < NLOCK; i++) { + if(locks[i] == 0) + break; + if(strncmp(locks[i]->name, "bcache", strlen("bcache")) == 0 || + strncmp(locks[i]->name, "kmem", strlen("kmem")) == 0) { + tot += locks[i]->nts; + n += snprint_lock(buf +n, sz-n, locks[i]); + } + } + + n += snprintf(buf+n, sz-n, "--- top 5 contended locks:\n"); + int last = 100000000; + // stupid way to compute top 5 contended locks + for(int t = 0; t < 5; t++) { + int top = 0; + for(int i = 0; i < NLOCK; i++) { + if(locks[i] == 0) + break; + if(locks[i]->nts > locks[top]->nts && locks[i]->nts < last) { + top = i; + } + } + n += snprint_lock(buf+n, sz-n, locks[top]); + last = locks[top]->nts; + } + n += snprintf(buf+n, sz-n, "tot= %d\n", tot); + release(&lock_locks); + return n; +} +#endif diff --git a/kernel/spinlock.h b/kernel/spinlock.h index 4392820..9bac216 100644 --- a/kernel/spinlock.h +++ b/kernel/spinlock.h @@ -5,5 +5,9 @@ struct spinlock { // For debugging: char *name; // Name of lock. struct cpu *cpu; // The cpu holding the lock. +#ifdef LAB_LOCK + int nts; + int n; +#endif }; diff --git a/kernel/sprintf.c b/kernel/sprintf.c new file mode 100644 index 0000000..050eb85 --- /dev/null +++ b/kernel/sprintf.c @@ -0,0 +1,91 @@ +#include + +#include "types.h" +#include "param.h" +#include "spinlock.h" +#include "sleeplock.h" +#include "fs.h" +#include "file.h" +#include "riscv.h" +#include "defs.h" + +static char digits[] = "0123456789abcdef"; + +static int +sputc(char *s, char c) +{ + *s = c; + return 1; +} + +static int +sprintint(char *s, int xx, int base, int sign) +{ + char buf[16]; + int i, n; + uint x; + + if(sign && (sign = xx < 0)) + x = -xx; + else + x = xx; + + i = 0; + do { + buf[i++] = digits[x % base]; + } while((x /= base) != 0); + + if(sign) + buf[i++] = '-'; + + n = 0; + while(--i >= 0) + n += sputc(s+n, buf[i]); + return n; +} + +int +snprintf(char *buf, int sz, char *fmt, ...) +{ + va_list ap; + int i, c; + int off = 0; + char *s; + + if (fmt == 0) + panic("null fmt"); + + va_start(ap, fmt); + for(i = 0; off < sz && (c = fmt[i] & 0xff) != 0; i++){ + if(c != '%'){ + off += sputc(buf+off, c); + continue; + } + c = fmt[++i] & 0xff; + if(c == 0) + break; + switch(c){ + case 'd': + off += sprintint(buf+off, va_arg(ap, int), 10, 1); + break; + case 'x': + off += sprintint(buf+off, va_arg(ap, int), 16, 1); + break; + case 's': + if((s = va_arg(ap, char*)) == 0) + s = "(null)"; + for(; *s && off < sz; s++) + off += sputc(buf+off, *s); + break; + case '%': + off += sputc(buf+off, '%'); + break; + default: + // Print unknown % sequence to draw attention. + off += sputc(buf+off, '%'); + off += sputc(buf+off, c); + break; + } + } + return off; +} diff --git a/kernel/start.c b/kernel/start.c index e16f18a..bf03bc0 100644 --- a/kernel/start.c +++ b/kernel/start.c @@ -38,6 +38,11 @@ start() w_mideleg(0xffff); w_sie(r_sie() | SIE_SEIE | SIE_STIE | SIE_SSIE); +#ifdef KCSAN + // allow supervisor to read cycle counter register + w_mcounteren(r_mcounteren()|0x3); +#endif + // configure Physical Memory Protection to give supervisor mode // access to all of physical memory. w_pmpaddr0(0x3fffffffffffffull); diff --git a/kernel/stats.c b/kernel/stats.c new file mode 100644 index 0000000..9659bb9 --- /dev/null +++ b/kernel/stats.c @@ -0,0 +1,69 @@ +#include + +#include "types.h" +#include "param.h" +#include "spinlock.h" +#include "sleeplock.h" +#include "fs.h" +#include "file.h" +#include "riscv.h" +#include "defs.h" + +#define BUFSZ 4096 +static struct { + struct spinlock lock; + char buf[BUFSZ]; + int sz; + int off; +} stats; + +int statscopyin(char*, int); +int statslock(char*, int); + +int +statswrite(int user_src, uint64 src, int n) +{ + return -1; +} + +int +statsread(int user_dst, uint64 dst, int n) +{ + int m; + + acquire(&stats.lock); + + if(stats.sz == 0) { +#ifdef LAB_PGTBL + stats.sz = statscopyin(stats.buf, BUFSZ); +#endif +#ifdef LAB_LOCK + stats.sz = statslock(stats.buf, BUFSZ); +#endif + } + m = stats.sz - stats.off; + + if (m > 0) { + if(m > n) + m = n; + if(either_copyout(user_dst, dst, stats.buf+stats.off, m) != -1) { + stats.off += m; + } + } else { + m = -1; + stats.sz = 0; + stats.off = 0; + } + release(&stats.lock); + return m; +} + +void +statsinit(void) +{ + initlock(&stats.lock, "stats"); + + devsw[STATS].read = statsread; + devsw[STATS].write = statswrite; +} + diff --git a/user/bcachetest.c b/user/bcachetest.c new file mode 100644 index 0000000..5dc46ef --- /dev/null +++ b/user/bcachetest.c @@ -0,0 +1,189 @@ +#include "kernel/fcntl.h" +#include "kernel/param.h" +#include "kernel/types.h" +#include "kernel/stat.h" +#include "kernel/riscv.h" +#include "kernel/fs.h" +#include "user/user.h" + +void test0(); +void test1(); + +#define SZ 4096 +char buf[SZ]; + +int +main(int argc, char *argv[]) +{ + test0(); + test1(); + exit(0); +} + +void +createfile(char *file, int nblock) +{ + int fd; + char buf[BSIZE]; + int i; + + fd = open(file, O_CREATE | O_RDWR); + if(fd < 0){ + printf("createfile %s failed\n", file); + exit(-1); + } + for(i = 0; i < nblock; i++) { + if(write(fd, buf, sizeof(buf)) != sizeof(buf)) { + printf("write %s failed\n", file); + exit(-1); + } + } + close(fd); +} + +void +readfile(char *file, int nbytes, int inc) +{ + char buf[BSIZE]; + int fd; + int i; + + if(inc > BSIZE) { + printf("readfile: inc too large\n"); + exit(-1); + } + if ((fd = open(file, O_RDONLY)) < 0) { + printf("readfile open %s failed\n", file); + exit(-1); + } + for (i = 0; i < nbytes; i += inc) { + if(read(fd, buf, inc) != inc) { + printf("read %s failed for block %d (%d)\n", file, i, nbytes); + exit(-1); + } + } + close(fd); +} + +int ntas(int print) +{ + int n; + char *c; + + if (statistics(buf, SZ) <= 0) { + fprintf(2, "ntas: no stats\n"); + } + c = strchr(buf, '='); + n = atoi(c+2); + if(print) + printf("%s", buf); + return n; +} + +// Test reading small files concurrently +void +test0() +{ + char file[2]; + char dir[2]; + enum { N = 10, NCHILD = 3 }; + int m, n; + + dir[0] = '0'; + dir[1] = '\0'; + file[0] = 'F'; + file[1] = '\0'; + + printf("start test0\n"); + for(int i = 0; i < NCHILD; i++){ + dir[0] = '0' + i; + mkdir(dir); + if (chdir(dir) < 0) { + printf("chdir failed\n"); + exit(1); + } + unlink(file); + createfile(file, N); + if (chdir("..") < 0) { + printf("chdir failed\n"); + exit(1); + } + } + m = ntas(0); + for(int i = 0; i < NCHILD; i++){ + dir[0] = '0' + i; + int pid = fork(); + if(pid < 0){ + printf("fork failed"); + exit(-1); + } + if(pid == 0){ + if (chdir(dir) < 0) { + printf("chdir failed\n"); + exit(1); + } + + readfile(file, N*BSIZE, 1); + + exit(0); + } + } + + for(int i = 0; i < NCHILD; i++){ + wait(0); + } + printf("test0 results:\n"); + n = ntas(1); + if (n-m < 500) + printf("test0: OK\n"); + else + printf("test0: FAIL\n"); +} + +// Test bcache evictions by reading a large file concurrently +void test1() +{ + char file[3]; + enum { N = 200, BIG=100, NCHILD=2 }; + + printf("start test1\n"); + file[0] = 'B'; + file[2] = '\0'; + for(int i = 0; i < NCHILD; i++){ + file[1] = '0' + i; + unlink(file); + if (i == 0) { + createfile(file, BIG); + } else { + createfile(file, 1); + } + } + for(int i = 0; i < NCHILD; i++){ + file[1] = '0' + i; + int pid = fork(); + if(pid < 0){ + printf("fork failed"); + exit(-1); + } + if(pid == 0){ + if (i==0) { + for (i = 0; i < N; i++) { + readfile(file, BIG*BSIZE, BSIZE); + } + unlink(file); + exit(0); + } else { + for (i = 0; i < N*20; i++) { + readfile(file, 1, BSIZE); + } + unlink(file); + } + exit(0); + } + } + + for(int i = 0; i < NCHILD; i++){ + wait(0); + } + printf("test1 OK\n"); +} diff --git a/user/init.c b/user/init.c index e0a5689..fc1c3db 100644 --- a/user/init.c +++ b/user/init.c @@ -18,6 +18,7 @@ main(void) if(open("console", O_RDWR) < 0){ mknod("console", CONSOLE, 0); + mknod("statistics", STATS, 0); open("console", O_RDWR); } dup(0); // stdout diff --git a/user/kalloctest.c b/user/kalloctest.c new file mode 100644 index 0000000..a82f1d5 --- /dev/null +++ b/user/kalloctest.c @@ -0,0 +1,161 @@ +#include "kernel/param.h" +#include "kernel/types.h" +#include "kernel/stat.h" +#include "kernel/riscv.h" +#include "kernel/memlayout.h" +#include "kernel/fcntl.h" +#include "user/user.h" + +#define NCHILD 2 +#define N 100000 +#define SZ 4096 + +void test1(void); +void test2(void); +void test3(void); +char buf[SZ]; + +int +main(int argc, char *argv[]) +{ + test1(); + test2(); + test3(); + exit(0); +} + +int ntas(int print) +{ + int n; + char *c; + + if (statistics(buf, SZ) <= 0) { + fprintf(2, "ntas: no stats\n"); + } + c = strchr(buf, '='); + n = atoi(c+2); + if(print) + printf("%s", buf); + return n; +} + +// Test concurrent kallocs and kfrees +void test1(void) +{ + void *a, *a1; + int n, m; + printf("start test1\n"); + m = ntas(0); + for(int i = 0; i < NCHILD; i++){ + int pid = fork(); + if(pid < 0){ + printf("fork failed"); + exit(-1); + } + if(pid == 0){ + for(i = 0; i < N; i++) { + a = sbrk(4096); + *(int *)(a+4) = 1; + a1 = sbrk(-4096); + if (a1 != a + 4096) { + printf("wrong sbrk\n"); + exit(-1); + } + } + exit(-1); + } + } + + for(int i = 0; i < NCHILD; i++){ + wait(0); + } + printf("test1 results:\n"); + n = ntas(1); + if(n-m < 10) + printf("test1 OK\n"); + else + printf("test1 FAIL\n"); +} + +// +// countfree() from usertests.c +// +int +countfree() +{ + uint64 sz0 = (uint64)sbrk(0); + int n = 0; + + while(1){ + uint64 a = (uint64) sbrk(4096); + if(a == 0xffffffffffffffff){ + break; + } + // modify the memory to make sure it's really allocated. + *(char *)(a + 4096 - 1) = 1; + n += 1; + } + sbrk(-((uint64)sbrk(0) - sz0)); + return n; +} + +// Test stealing +void test2() { + int free0 = countfree(); + int free1; + int n = (PHYSTOP-KERNBASE)/PGSIZE; + printf("start test2\n"); + printf("total free number of pages: %d (out of %d)\n", free0, n); + if(n - free0 > 1000) { + printf("test2 FAILED: cannot allocate enough memory"); + exit(-1); + } + for (int i = 0; i < 50; i++) { + free1 = countfree(); + if(i % 10 == 9) + printf("."); + if(free1 != free0) { + printf("test2 FAIL: losing pages\n"); + exit(-1); + } + } + printf("\ntest2 OK\n"); +} + +// Test concurrent kalloc/kfree and stealing +void test3(void) +{ + void *a, *a1; + printf("start test3\n"); + for(int i = 0; i < NCHILD; i++){ + int pid = fork(); + if(pid < 0){ + printf("fork failed"); + exit(-1); + } + if(pid == 0){ + if (i == 0) { + for(i = 0; i < N; i++) { + a = sbrk(4096); + *(int *)(a+4) = 1; + a1 = sbrk(-4096); + if (a1 != a + 4096) { + printf("wrong sbrk\n"); + exit(-1); + } + } + printf("child done %d\n", i); + exit(0); + } else { + countfree(); + printf("child done %d\n", i); + exit(0); + } + } + } + + for(int i = 0; i < NCHILD; i++){ + wait(0); + } + printf("test3 OK\n"); +} diff --git a/user/statistics.c b/user/statistics.c new file mode 100644 index 0000000..e22681a --- /dev/null +++ b/user/statistics.c @@ -0,0 +1,24 @@ +#include "kernel/types.h" +#include "kernel/stat.h" +#include "kernel/fcntl.h" +#include "user/user.h" + +int +statistics(void *buf, int sz) +{ + int fd, i, n; + + fd = open("statistics", O_RDONLY); + if(fd < 0) { + fprintf(2, "stats: open failed\n"); + exit(1); + } + for (i = 0; i < sz; ) { + if ((n = read(fd, buf+i, sz-i)) < 0) { + break; + } + i += n; + } + close(fd); + return i; +} diff --git a/user/stats.c b/user/stats.c new file mode 100644 index 0000000..f8c9138 --- /dev/null +++ b/user/stats.c @@ -0,0 +1,24 @@ +#include "kernel/types.h" +#include "kernel/stat.h" +#include "kernel/fcntl.h" +#include "user/user.h" + +#define SZ 4096 +char buf[SZ]; + +int +main(void) +{ + int i, n; + + while (1) { + n = statistics(buf, SZ); + for (i = 0; i < n; i++) { + write(1, buf+i, 1); + } + if (n != SZ) + break; + } + + exit(0); +} diff --git a/user/user.h b/user/user.h index 4d398d5..16cf173 100644 --- a/user/user.h +++ b/user/user.h @@ -22,6 +22,14 @@ int getpid(void); char* sbrk(int); int sleep(int); int uptime(void); +#ifdef LAB_NET +int connect(uint32, uint16, uint16); +#endif +#ifdef LAB_PGTBL +int pgaccess(void *base, int len, void *mask); +// usyscall region +int ugetpid(void); +#endif // ulib.c int stat(const char*, struct stat*); @@ -39,3 +47,4 @@ void free(void*); int atoi(const char*); int memcmp(const void *, const void *, uint); void *memcpy(void *, const void *, uint); +int statistics(void*, int); From 3c0a25fc4383140b3f8bf83f5eef4cbb14062e94 Mon Sep 17 00:00:00 2001 From: Robert Morris Date: Tue, 2 Jan 2024 10:04:23 -0500 Subject: [PATCH 2/7] x --- .gitignore | 2 +- grade-lab-lock | 4 ++ kernel/defs.h | 8 +++ user/bcachetest.c | 129 ++++++++++++++++++++++++++++++++++++++++++++++ user/user.h | 6 +++ 5 files changed, 148 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index d036a8b..11d0677 100644 --- a/.gitignore +++ b/.gitignore @@ -11,7 +11,7 @@ entryother initcode initcode.out kernelmemfs -mkfs +mkfs/mkfs kernel/kernel user/usys.S .gdbinit diff --git a/grade-lab-lock b/grade-lab-lock index 770d676..fa90fef 100755 --- a/grade-lab-lock +++ b/grade-lab-lock @@ -44,6 +44,10 @@ def test_bcachetest_test0(): def test_bcachetest_test1(): r.match('^test1 OK$') +@test(10, "bcachetest: test2", parent=test_bcachetest) +def test_bcachetest_test2(): + r.match('^test2 OK$') + @test(19, "usertests") def test_usertests(): r.run_qemu(shell_script([ diff --git a/kernel/defs.h b/kernel/defs.h index c6fef8c..859fc41 100644 --- a/kernel/defs.h +++ b/kernel/defs.h @@ -1,3 +1,7 @@ +#ifdef LAB_MMAP +typedef unsigned long size_t; +typedef long int off_t; +#endif struct buf; struct context; struct file; @@ -121,7 +125,9 @@ void initlock(struct spinlock*, char*); void release(struct spinlock*); void push_off(void); void pop_off(void); +#if defined(LAB_LOCK) || defined(LAB_NET) int atomic_read4(int *addr); +#endif #ifdef LAB_LOCK void freelock(struct spinlock*); #endif @@ -204,12 +210,14 @@ int copyin_new(pagetable_t, char *, uint64, uint64); int copyinstr_new(pagetable_t, char *, uint64, uint64); #endif +#ifdef LAB_LOCK // stats.c void statsinit(void); void statsinc(void); // sprintf.c int snprintf(char*, int, char*, ...); +#endif #ifdef KCSAN void kcsaninit(); diff --git a/user/bcachetest.c b/user/bcachetest.c index 5dc46ef..ccf7516 100644 --- a/user/bcachetest.c +++ b/user/bcachetest.c @@ -8,6 +8,7 @@ void test0(); void test1(); +void test2(); #define SZ 4096 char buf[SZ]; @@ -17,6 +18,7 @@ main(int argc, char *argv[]) { test0(); test1(); + test2(); exit(0); } @@ -187,3 +189,130 @@ void test1() } printf("test1 OK\n"); } + +// +// test concurrent creates. +// +void +test2() +{ + int nc = 4; + char file[16]; + + printf("start test2\n"); + + mkdir("d2"); + + file[0] = 'd'; + file[1] = '2'; + file[2] = '/'; + + // remove any stale existing files. + for(int i = 0; i < 50; i++){ + for(int ci = 0; ci < nc; ci++){ + file[3] = 'a' + ci; + file[4] = '0' + i; + file[5] = '\0'; + unlink(file); + } + } + + int pids[nc]; + for(int ci = 0; ci < nc; ci++){ + pids[ci] = fork(); + if(pids[ci] < 0){ + printf("test2: fork failed\n"); + exit(1); + } + if(pids[ci] == 0){ + char me = "abcdefghijklmnop"[ci]; + int pid = getpid(); + int nf = (ci == 0 ? 10 : 15); + + // create nf files. + for(int i = 0; i < nf; i++){ + file[3] = me; + file[4] = '0' + i; + file[5] = '\0'; + // printf("w %s\n", file); + int fd = open(file, O_CREATE | O_RDWR); + if(fd < 0){ + printf("test2: create %s failed\n", file); + exit(1); + } + int xx = (pid << 16) | i; + for(int nw = 0; nw < 2; nw++){ + // the sleep() increases the chance of simultaneous + // calls to bget(). + sleep(1); + if(write(fd, &xx, sizeof(xx)) <= 0){ + printf("test2: write %s failed\n", file); + exit(1); + } + } + close(fd); + } + + // read back the nf files. + for(int i = 0; i < nf; i++){ + file[3] = me; + file[4] = '0' + i; + file[5] = '\0'; + // printf("r %s\n", file); + int fd = open(file, O_RDWR); + if(fd < 0){ + printf("test2: open %s failed\n", file); + exit(1); + } + int xx = (pid << 16) | i; + for(int nr = 0; nr < 2; nr++){ + int z = 0; + sleep(1); + int n = read(fd, &z, sizeof(z)); + if(n != sizeof(z)){ + printf("test2: read %s returned %d, expected %d\n", file, n, sizeof(z)); + exit(1); + } + if(z != xx){ + printf("test2: file %s contained %d, not %d\n", file, z, xx); + exit(1); + } + } + close(fd); + } + + // delete the nf files. + for(int i = 0; i < nf; i++){ + file[3] = me; + file[4] = '0' + i; + file[5] = '\0'; + //printf("u %s\n", file); + if(unlink(file) != 0){ + printf("test2: unlink %s failed\n", file); + exit(1); + } + } + + exit(0); + } + } + + int ok = 1; + + for(int ci = 0; ci < nc; ci++){ + int st = 0; + int ret = wait(&st); + if(ret <= 0){ + printf("test2: wait() failed\n"); + ok = 0; + } + if(st != 0) + ok = 0; + } + + if(ok){ + printf("test2 OK\n"); + } else { + printf("test2 failed\n"); + } +} diff --git a/user/user.h b/user/user.h index 16cf173..2d6ace6 100644 --- a/user/user.h +++ b/user/user.h @@ -1,3 +1,7 @@ +#ifdef LAB_MMAP +typedef unsigned long size_t; +typedef long int off_t; +#endif struct stat; // system calls @@ -47,4 +51,6 @@ void free(void*); int atoi(const char*); int memcmp(const void *, const void *, uint); void *memcpy(void *, const void *, uint); +#ifdef LAB_LOCK int statistics(void*, int); +#endif From 0de5ac779602f562a038e5ad27163d85bc71638b Mon Sep 17 00:00:00 2001 From: Robert Morris Date: Tue, 2 Jan 2024 12:55:17 -0500 Subject: [PATCH 3/7] x --- kernel/virtio_disk.c | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/kernel/virtio_disk.c b/kernel/virtio_disk.c index ae6c164..dfca2bc 100644 --- a/kernel/virtio_disk.c +++ b/kernel/virtio_disk.c @@ -212,6 +212,28 @@ alloc3_desc(int *idx) return 0; } +#ifdef LAB_LOCK +// +// check that there are at most NBUF distinct +// struct buf's, which the lock lab requires. +// +static struct buf *xbufs[NBUF]; +static void +checkbuf(struct buf *b) +{ + for(int i = 0; i < NBUF; i++){ + if(xbufs[i] == b){ + return; + } + if(xbufs[i] == 0){ + xbufs[i] = b; + return; + } + } + panic("more than NBUF bufs"); +} +#endif + void virtio_disk_rw(struct buf *b, int write) { @@ -219,6 +241,10 @@ virtio_disk_rw(struct buf *b, int write) acquire(&disk.vdisk_lock); +#ifdef LAB_LOCK + checkbuf(b); +#endif + // the spec's Section 5.2 says that legacy block operations use // three descriptors: one for type/reserved/sector, one for the // data, one for a 1-byte status result. From c4d86174285df86bd4c3290aebf9307427cb275f Mon Sep 17 00:00:00 2001 From: novice <619671969@qq.com> Date: Sun, 8 Sep 2024 15:59:51 +0800 Subject: [PATCH 4/7] lab 8 locks lab part1 Memory allocator part has passed, it is very easy for me :), just take me about half an hour to finish! --- .../clangd/index/bio.c.34489AC9E3FB27B2.idx | Bin 0 -> 3462 bytes .../clangd/index/buf.h.7DA89D0539A50AFB.idx | Bin 0 -> 870 bytes .../index/console.c.A959DCA84FDA00CD.idx | Bin 0 -> 3090 bytes .../clangd/index/defs.h.72A9C4FFB86E6400.idx | Bin 0 -> 12652 bytes .../clangd/index/elf.h.B51ED6807EFE6571.idx | Bin 0 -> 2096 bytes .../clangd/index/entry.S.7790893A73F2EC77.idx | Bin 0 -> 266 bytes .../clangd/index/exec.c.C583EF6E813AE52A.idx | Bin 0 -> 2614 bytes .../clangd/index/fcntl.h.204FC1983BB1DFC2.idx | Bin 0 -> 260 bytes .../clangd/index/file.c.E75BF18666EA6C16.idx | Bin 0 -> 3924 bytes .../clangd/index/file.h.2A63A83574D7D652.idx | Bin 0 -> 2214 bytes .cache/clangd/index/fs.c.DE158A81433875BE.idx | Bin 0 -> 10498 bytes .cache/clangd/index/fs.h.F83902F1C88C3791.idx | Bin 0 -> 1830 bytes .../index/initcode.S.373AF54AA740F373.idx | Bin 0 -> 482 bytes .../index/kalloc.c.2F15DD93067E2B26.idx | Bin 0 -> 1926 bytes .../index/kernelvec.S.06F25524429F6CAE.idx | Bin 0 -> 266 bytes .../clangd/index/log.c.D81C51C68A1AD96E.idx | Bin 0 -> 5408 bytes .../clangd/index/main.c.2DC262271CAFD048.idx | Bin 0 -> 1184 bytes .../index/memlayout.h.0B2C565D58B84A48.idx | Bin 0 -> 562 bytes .../clangd/index/param.h.37451DCC2B36E012.idx | Bin 0 -> 444 bytes .../clangd/index/pipe.c.2473E067140E4F18.idx | Bin 0 -> 2860 bytes .../clangd/index/plic.c.2EA8519EDD3A2B20.idx | Bin 0 -> 1100 bytes .../index/printf.c.0918689B2930FAE2.idx | Bin 0 -> 2010 bytes .../clangd/index/proc.c.5346DCDE506E9F58.idx | Bin 0 -> 11546 bytes .../clangd/index/proc.h.27341B4843D3B8B6.idx | Bin 0 -> 6066 bytes .../clangd/index/riscv.h.6737E35D6CB953E7.idx | Bin 0 -> 4968 bytes .../index/sleeplock.c.BC30DEE970D57711.idx | Bin 0 -> 1446 bytes .../index/sleeplock.h.56E9B1C95DBCB92F.idx | Bin 0 -> 510 bytes .../index/spinlock.c.1B29CD753041D103.idx | Bin 0 -> 3054 bytes .../index/spinlock.h.7E8FC04641EE310E.idx | Bin 0 -> 558 bytes .../index/sprintf.c.A2EB5C91A2B1B2CC.idx | Bin 0 -> 1128 bytes .../clangd/index/start.c.92F9EB51DC5F96B3.idx | Bin 0 -> 1678 bytes .../clangd/index/stat.h.AEE4CE7ADDE89C85.idx | Bin 0 -> 608 bytes .../clangd/index/stats.c.50950397C46FA543.idx | Bin 0 -> 1844 bytes .../index/string.c.87F56374FD494C3A.idx | Bin 0 -> 1016 bytes .../clangd/index/swtch.S.11DB57B07ECB88BC.idx | Bin 0 -> 266 bytes .../index/syscall.c.05D088F49A8C83CC.idx | Bin 0 -> 4568 bytes .../index/syscall.h.66E962A052CADC6A.idx | Bin 0 -> 630 bytes .../index/sysfile.c.C337A604B3627C12.idx | Bin 0 -> 6944 bytes .../index/sysproc.c.E5BC46BBC06178C3.idx | Bin 0 -> 1772 bytes .../index/trampoline.S.ABB830BE366004AD.idx | Bin 0 -> 406 bytes .../clangd/index/trap.c.E331BC8CB04ABF35.idx | Bin 0 -> 3568 bytes .../clangd/index/types.h.9C15A82D28EB699F.idx | Bin 0 -> 620 bytes .../clangd/index/uart.c.382E637B5067D2B7.idx | Bin 0 -> 2170 bytes .../index/virtio.h.7AE2FDAEE3C87964.idx | Bin 0 -> 2640 bytes .../index/virtio_disk.c.8DF9309BB95BE078.idx | Bin 0 -> 7434 bytes .cache/clangd/index/vm.c.70D05D5C0213F437.idx | Bin 0 -> 7366 bytes compile_commands.json | 756 ++++++++++++++++++ kernel/kalloc.c | 51 +- 48 files changed, 796 insertions(+), 11 deletions(-) create mode 100644 .cache/clangd/index/bio.c.34489AC9E3FB27B2.idx create mode 100644 .cache/clangd/index/buf.h.7DA89D0539A50AFB.idx create mode 100644 .cache/clangd/index/console.c.A959DCA84FDA00CD.idx create mode 100644 .cache/clangd/index/defs.h.72A9C4FFB86E6400.idx create mode 100644 .cache/clangd/index/elf.h.B51ED6807EFE6571.idx create mode 100644 .cache/clangd/index/entry.S.7790893A73F2EC77.idx create mode 100644 .cache/clangd/index/exec.c.C583EF6E813AE52A.idx create mode 100644 .cache/clangd/index/fcntl.h.204FC1983BB1DFC2.idx create mode 100644 .cache/clangd/index/file.c.E75BF18666EA6C16.idx create mode 100644 .cache/clangd/index/file.h.2A63A83574D7D652.idx create mode 100644 .cache/clangd/index/fs.c.DE158A81433875BE.idx create mode 100644 .cache/clangd/index/fs.h.F83902F1C88C3791.idx create mode 100644 .cache/clangd/index/initcode.S.373AF54AA740F373.idx create mode 100644 .cache/clangd/index/kalloc.c.2F15DD93067E2B26.idx create mode 100644 .cache/clangd/index/kernelvec.S.06F25524429F6CAE.idx create mode 100644 .cache/clangd/index/log.c.D81C51C68A1AD96E.idx create mode 100644 .cache/clangd/index/main.c.2DC262271CAFD048.idx create mode 100644 .cache/clangd/index/memlayout.h.0B2C565D58B84A48.idx create mode 100644 .cache/clangd/index/param.h.37451DCC2B36E012.idx create mode 100644 .cache/clangd/index/pipe.c.2473E067140E4F18.idx create mode 100644 .cache/clangd/index/plic.c.2EA8519EDD3A2B20.idx create mode 100644 .cache/clangd/index/printf.c.0918689B2930FAE2.idx create mode 100644 .cache/clangd/index/proc.c.5346DCDE506E9F58.idx create mode 100644 .cache/clangd/index/proc.h.27341B4843D3B8B6.idx create mode 100644 .cache/clangd/index/riscv.h.6737E35D6CB953E7.idx create mode 100644 .cache/clangd/index/sleeplock.c.BC30DEE970D57711.idx create mode 100644 .cache/clangd/index/sleeplock.h.56E9B1C95DBCB92F.idx create mode 100644 .cache/clangd/index/spinlock.c.1B29CD753041D103.idx create mode 100644 .cache/clangd/index/spinlock.h.7E8FC04641EE310E.idx create mode 100644 .cache/clangd/index/sprintf.c.A2EB5C91A2B1B2CC.idx create mode 100644 .cache/clangd/index/start.c.92F9EB51DC5F96B3.idx create mode 100644 .cache/clangd/index/stat.h.AEE4CE7ADDE89C85.idx create mode 100644 .cache/clangd/index/stats.c.50950397C46FA543.idx create mode 100644 .cache/clangd/index/string.c.87F56374FD494C3A.idx create mode 100644 .cache/clangd/index/swtch.S.11DB57B07ECB88BC.idx create mode 100644 .cache/clangd/index/syscall.c.05D088F49A8C83CC.idx create mode 100644 .cache/clangd/index/syscall.h.66E962A052CADC6A.idx create mode 100644 .cache/clangd/index/sysfile.c.C337A604B3627C12.idx create mode 100644 .cache/clangd/index/sysproc.c.E5BC46BBC06178C3.idx create mode 100644 .cache/clangd/index/trampoline.S.ABB830BE366004AD.idx create mode 100644 .cache/clangd/index/trap.c.E331BC8CB04ABF35.idx create mode 100644 .cache/clangd/index/types.h.9C15A82D28EB699F.idx create mode 100644 .cache/clangd/index/uart.c.382E637B5067D2B7.idx create mode 100644 .cache/clangd/index/virtio.h.7AE2FDAEE3C87964.idx create mode 100644 .cache/clangd/index/virtio_disk.c.8DF9309BB95BE078.idx create mode 100644 .cache/clangd/index/vm.c.70D05D5C0213F437.idx create mode 100644 compile_commands.json diff --git a/.cache/clangd/index/bio.c.34489AC9E3FB27B2.idx b/.cache/clangd/index/bio.c.34489AC9E3FB27B2.idx new file mode 100644 index 0000000000000000000000000000000000000000..33c0aeff1a0dea7bd9dc3626c60847717280faa8 GIT binary patch literal 3462 zcmY*b3sjTW9ltk(gfF>yl6-*#C?Fzy`4UK6r68sa54YCv3Wr)1MIJikwG|i?QQnGc z5G#Ssv)Q_JfKGIWTDpnSPG!iZo^{pZcB&pN>eSUaSX(AOPP-4fn|t}r$<6(J|Ns5p z|NH;BUtYPgQ2{_|$;)q4Y^o^~0{{YrUv*8@*55+_ek8nj=Dvl`Ze?I~I%*Jdg79 zxqq_je^UA8wY`fE>{xT^>(^KFH~#L8N>EIWE?;x7*k-$Mr1cl84iuf6K2b}IVevCN~)*~kYg-svj*@{w_g^KkNzW47JCCvn|ObjsM@`qt+8 zeQ;^p&dtR+Ox=6WJK>%eL|?tcJqd}j_mAzWyAfH}_*ZTH)=}NAiA?dAimO%T_v%Iu zeU;|fw`x)TpyRoxSBgitsgX}-?o1ATf3|zCqogS$?1hZYX`!Dzx%T9n7gJ_oTk2TZ z!&OZ3#7md{(`0@3LwAa0=fBjYoFcm??BVV!AJt|{b*016?jKZcIr+i2miz7DgV)9{ zKe&7%Vh|cDhHgE(Y8VZ>kn!32y|LxDLMp?q$V<;8em>%=KD|ZVP6s-~BmzQwyFQG$Tqy$UFfD2cIYvvar z!t>9t-@(BX1LIl*A_3q$5O|=N4^ju|0OJoqLM-T;n3!rXS0psTvAqaoJ#j&A( zw5k$;MFKe=EzpqG+tB27xGnTmxz(Jga7X!h>%8`BC2&hdUG? zOdv;yA_C?YtXe*!@puMqc$8qVpt(t5QqM1#d}Q{I2d~=;`Ve?dIGqHN#PbU#uU?V* z>xu*8GYCWr-zO zBf)J@-Ud|!w?lb5!5a7YBhjYo3K8PcCFxpnWv(RGhj5xf+5dA4yBVjKT(%&s5El~| zV<3h)v<{X?PGi%I1i4u^g&MRCEK#)sYC9l>JE67{vRE6$bwO&Xu`e-K`4rT|H>3g969w;a2(gXc_pd6>iWA)9zsl34)!Gd~Gy%O7hJ4<<|@qW&F zG2)W^lNfSuk}4^XpnOTbj98bi&evgt{{`#jS|YX%%NJhHwL<)Qf52G5wv>}Ka>SV! z6T)2&ap6oj!rdQn(M&YLZbMw6GEqZRNoJA}LF=UJD8)7~8xU3qaiz*q4Gse0YLqop z)_5TDKoxOTH&k{*4R%)Y_V=p-F8;Jx@QOp^puEx`YGANwi0g!+PRI};UMTWH1`EL* zKUB7$(+e4dVyKESi_8JURx@i3A&3|86pd$jie`~n)P&Pww1g96Ra&Xqic`hu3C$+9 z`SKTWcCnp84!MK!v{UA!644pyj3ItcQ>D=@TIQlSU6C$|)2(t-oDK2@Dhe%7*+Oa$ z3C]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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/defs.h.72A9C4FFB86E6400.idx b/.cache/clangd/index/defs.h.72A9C4FFB86E6400.idx new file mode 100644 index 0000000000000000000000000000000000000000..920096172a5945000b43172cc776efe155959576 GIT binary patch literal 12652 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 F;Qz$)_RIhP literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/elf.h.B51ED6807EFE6571.idx b/.cache/clangd/index/elf.h.B51ED6807EFE6571.idx new file mode 100644 index 0000000000000000000000000000000000000000..5099316424cb6b08d1bf1425fd300d52bd7d4894 GIT binary patch literal 2096 zcmX|B3v5(H6uq6c`(}1$r`>JAcDuVR1hQ=d3WUnHQA&l<$e(}+L;)*E*r457%O`vz zKZQgifs~?rDiYCH2}C}clqzkYK($eVSj7NRs34!j*fbKo^UU$>?s=PY=FaENxp&%x zapUqO(b$(J)Wj>Q=BE%*2LBROm9L!Ox06IvQ&&8Bj%gaCTc=hh<%fc~qv&b}?RY$1 z*t4s4NPJZB?4s_n0sXh%ZT#7}Bmdl-8ts2-|H78VAGh5ecIot~l(IX+Qgrnbq1L3Y zY1fk3r?W8COZYb>OnR|2hyCYK{U7Nn<_Gew&`p=(Ix#nPXbI#?xk+I)z zTvalr(_i}bk+YYY>cz4Ld`LaCDgTDI}$n`8B_tvfkMCZ^YY z-muF1f-IUFqr~#~0wV#xdFj;zQdfZ~6G*2eIyup;VR~>G)iL zyfQZJ&0wpHaC9$HAr&$%Kz?{`;*&p&zFTN0#B#RE_PYSN_rNQ)eV=YCGNgHOe$ril zJa2KscRiEza6@SvouhKJ3y@1@RCYh}$%7GwQaCzIrSX>m@}VDVZq(k`I@(Y=M@Lk| zxBz)*-$iQXpTmIT<$ne^^D%ZFG`Ip9;_~t`<_8aQW(LojDF9YPa-nnzG;-~eW8p>ul zQ)LERfSkPI>^~>&1&$aBvK&wW;{xPwd$q2;RdwPE4`mXmEGNsjK#EB4g&x0hp`_d- zpE2a+twmKd%>_h%)I4-q`_Yljh92X|GgO9g0dm>pqQ8gizRq%pWvQg!1<2!@77cw= zU(s$ThbIrKuyFzM#N%@gKll5X4ntv%_BvkU0_5LX%2!_KbLN_%ESCMsZ(M+Uv2A_F zfbfz(Jmlenr8=p87wo~f3Tb2gm-z!n?0aA+nb*!!dBz1q>kU=Kp{4J48;jtWJt4*kZzd zu1_{MR^OUBFPW=Pcs$s(R$k%tz)jq+gz@0sPOpfz&ulsQBF~gB^K<@7JW*+==lqU> z!K*k6KH-ya1Ls6&i6m*|7k&vFa<>sV61SjLScD}Eu2n=tByz4*R752zORHRwE71b9 z$`g4K=Iq+%c-F>muM=8ji);x)XcZD62{R#-k6>E|t`d1<+I9=%=w9cF`>!7hA57B9 z5sm|+BC|Z&b`Xrl)i7;42WYIpwCxzk+J-H2`?YO)wvp+6vR^OII4RS%fgrfEHc>rj zb>s}w1+w6O*U#G7b@TeZ21^Sm0+<9wVA{4B>;#@;+O`+aNIcWFtzb!bfN9%KFdA3L zv~44x@n+h#59|b&!?bN1m>V8p+O`V>bEjB3--aeC7bbl6k4k;&{DMYZyqM@;{~t)Q literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/entry.S.7790893A73F2EC77.idx b/.cache/clangd/index/entry.S.7790893A73F2EC77.idx new file mode 100644 index 0000000000000000000000000000000000000000..e8940671fac11570a3b66ea7e3f69ab66dd0c028 GIT binary patch literal 266 zcmWIYbaP{3WMFVk@vO*AElFfyU|+>5uhU-bW2EU)-PkV!EuNv_#lwmdKN+1IYgPhTE0^grSh(-E6J zGiFNvGwV607o12n3p82j;j!ZR1AnvI4T@JL74jBw25PIc%Jk=3Z<)O;*GlDeJj>fQ zyKijL{M##gms_;%`&6{?P2GwIi{_a+etz*i&40$K#oK$<`^&h#Nb%f$;Qwy{(Hpcoqm2NN?3 I7b_z>04ug;@Bjb+ literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/exec.c.C583EF6E813AE52A.idx b/.cache/clangd/index/exec.c.C583EF6E813AE52A.idx new file mode 100644 index 0000000000000000000000000000000000000000..b17af59ac5d4a26f46509513639ffb934549a166 GIT binary patch literal 2614 zcmY*a3sh5O9KYY)^NuTwJpec6h4CI>5CcRQ>@b3O%Ls{(Xo*S+hy#^`G136BPGA#> z1L(>g7UZMHQOHwl$OXTe&fn z6U9G?GF^h2cq!w*@ux0!Unwiz>Z8#%H?!mPHT*q$ceDjo41aad)SJIVbHGymw~=+; z>rj5$7jkV+ck!B+&RzaGN>ej%=}dWI8~5;?j^_&3cicKaNuP|C`A(n3%7FR0a57mL zRL9+S<86P}uAa<2Tbf47-|b91G2(hNA*p|dN#(uk`-kd{Dd9;s>mAysCeQqO@s))o zfyQ-CZs|p-2F2iH<>y8pf@9(q?e@Rt(J;IrubY*mZ_2#TvJ#goUfPqF`^R9CbnUf| zXJnbtLqqJY&aORwOzqE$c&M8GXLr`|r0HXY=|$^fHM{#lCrkr>Wmi81;9T{^k>%D*f+>o`PtonWa1J;ih>sRo5N_}}|tfe^jwTd@O zUoV7=47F6=c2PdbATc?HQ7)JZTj446lwbr7-2G(O-ln;y)4H!NCNW>Ac3?X=&i+Bi z+2>`Kv9Lz-N&|@nK(z&67Qmwj2SS7lFypf2744inYnw3?yzFAUq!%Klg{?c0jZPXOw7aC_Unrm|H5Sh!jLRBKv~keIqj&sODC=f*>EFcC~=x(A-$RN%Wf4T{Y|vj_!2Zy=bR zI7+$XuImqNIem+uwIA-sLskcGf73AJ_gN0?qDojLL1Kt}t5gUfqHw`81i`UJYhOS{ zW0{UuYA3P^I3z`=i3Mn=5G^EP8Ds%57NE7q$rg~#;8uXQ0xrVn%_5#*9x}nx(Ss2D zzd2B=Jts>}d12|Lu%}c>stYQRq)Z$W-MHw8>xZ?evenSY+0of{f6P84r4Q3DKxq6@ z=%YssAC*HRN=(gVBBgLsXnNY7TV>d^ztspQTPv&;BctjDP*m4jUde(J2qZ#KCnV)g zxYMPRu=G$1h(OwmUCs$xujai86Uvk_e^duamg*f^6nQYd~lX2@7y1lt>IC<1#+uq!O#_8Vi?(%Nbo9J5Io$R6NzrFALAIL&dUU z`rN@I5K|J*_*np~%!kRp9pKvmpTSljwE{W9nCjliLeo?o9H*Cqmk@U|zPzL45b37T8E6$zE zpbvoT1K`2nP9W?AE)3oY1UmtJ1z{7Hl{?1=zJqmi0B#3xK=a?!w8Z;#W7=V;h!jOq z$bTf|=8fhAQ9tavKu|!}4KF{HAp|vd@VArkDUPh8&?rh8Ww()ZVLFI_rq(h*w(`f^= z^O@3g3Y`+6yNlA!99%W>C(J^K2{)8HV$0eLZC2|fY)k8?rFRD;mekXG=hW$qqe1Q~ zZ$n=>A*a(F-H_m0%33iE#ZGga=rGi;{FiRz~ oq)!5dEiEl7u^k0h*STy$z;_fmb2(yij)W(4a*+DFu-veJ0b@*L0ssI2 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/fcntl.h.204FC1983BB1DFC2.idx b/.cache/clangd/index/fcntl.h.204FC1983BB1DFC2.idx new file mode 100644 index 0000000000000000000000000000000000000000..49fdadc755f547ce0cea3c6542429973c5eced39 GIT binary patch literal 260 zcmWIYbaVT|z`)>~;#rZKT9U{DWD5gvaY<383y`(~;)*%R9;eTEZoPE<`uP**eXpKB zt$*6b@9O!pI-Tn^j4!h%-JNq}Nm8sbvvTs^H&+(zxgzs-%ac8mWcKo~G1z7bCly!b zCIO9MC`wH$E(X#o#EcpR1MZYFaxt=Su<(PVK%i#dg7rJQ_O1j9GjlKtKm-{W{9iM* zxW!4V0SYs5F!8~JgFeskkBj_z0VvGC!2nn7UTFA5W9Q^sKw(A>Mz}E0?wmxB*5ab% TVr~$FvB#fx(}$;%>lqjTuxm=C literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/file.c.E75BF18666EA6C16.idx b/.cache/clangd/index/file.c.E75BF18666EA6C16.idx new file mode 100644 index 0000000000000000000000000000000000000000..16ade710f56afc445d247c6842d4b837855fae73 GIT binary patch literal 3924 zcmY*b2~?9u9-j#Ta!mMgNkTw@L_i=PkYJ<=h=8IgAd0mthyp6sMo~#pPRpujs#uT( ztF8~Mir~@e7Ry?zcvtI%TC~=>E@EvJAKuzS+v-l-PUbW3<$Lp+|NQS`CexgflEwg# zJkwlORA?{Y0{|5GZ?jw9oyG&8%>#h4rslVfSgu7$n{9`ZKJeRJSXdYn$WIO^;sp(r z&h{F19uQr`UY4d*_keJs;lgYK)I|9IIYC#%EIBThl*kKRNP6 z(-HqBTgk)S`q-P@cZ7{OAN>7;!kc>spS>ncUu*A)k2$z5=BV(G7gYu*-&ZNEMMuB<+wUIBo*bAsMAZLL zhjv$CK;C@KHz)g=XPYxFtC#KW{*|me(->8mx);DI*hUb$KS5En| zW?^|pT#s&a-1G&rk5Bk8X>s3lY52{r_D7zd)7snpeEEzUJC?K`3x5mxZaM1y>AJ_w zskS!jg;}+AotZlgyIZDv5%?jP;%IG7)7JhgB6;-7=JjK6vhfS_G9JeMgC#wVZB!m#KKP&UTJmAA7c7s$^2iG;k_f*Ev@c8$e&ylw|DRU3s=7G zI;Y;d^k47(95wRPu6yqc+LO8b&oeFUHOHU7ET8nVaehtDmPvaWQWnS!Wu|3o_g9Jx zIbW?w`L$U7rD>kAwC@*T=hJIH>yFG)3$``n zPIS8%aI}BWqo_{V+;@zn&wurQc#B~U#AvGEw=d$}wv`u6&w>DW&(UdAbvJYf!~?)O zAaFpTK1>?s1B3#%!3iNCp>SP>;py@a2^fhFD0m9Ns}C;JSHA*#|D$aWiuDM@VR9D8 z66iyvp=u!X91CKF`XFf#7VZH9Mh^jxzk6}P%Q|!f0DNAKl2(kdx0=_z{id~3amJY_c`TTG!JmnvOU$vf1f9VAhv2dAO=KbnJ zgad2gEZY|%0Ny@6#jtf#iUcB-@njJ3$kw5}o5y@8aYJmHENy@*OsrLDRlB0X)3C=QglLd0rCS}6zlY6B?>VuA)x6e&pk#38n$*#-25`aRQugk)0vT7-{VO9AvVOpr}Mv;!ROK6xBn9s7Gu))YLt#a#dLH= z^4Y*?k8*i9G;#J(l)FS-;zv-!@LQ(lx;OK&!aRPSm@2H~SBl9Y#I{0@Rwy9~Z}%FW zJ#%bcfE8vdvV92CiGi&byF!}Y!`thjbUpMXnVbYGSb3qbRD@W$P%a^J3bB5keq!1x z{z88VMG>A6V%jQ^Or(OMSXnG*gv1NuB{bMs(kvyh2(cEaMM>RoK$(N)3u(%(-yfe* ziS5ncX9$RhoEGi;#G1*KIF02&S z;Mc>rdYDKEh;4wH2Ac8Fn&)Rf3NbfBr!zH7)8>q7-f)WWu z^-y0A4P1{z4YZ$#e%#K^D~gC5wm5TF(R%wvY=BHClac#`6oZ@SwaW^zTA7wJMzvaP zFmbbK+B>^WylmWx@U`GR&gCIuQw6Dr_=|gxN#{(^^x*U`O3M}GA{y#k|6CnK#e!l^ znr)0tK|L>JN;#+&3Th#uaaaYJRdkXfwh=Oo6#I2nEz}%t+kpd+EzFh>g`n>T?Z>xI z?8oI6&5!0}FOi?f@$G&7`4&J2{{MY*R+rZVIZ9xak-9F)i8$tbN%QpOp? z~d z>&q9gzvKDiIVs-+JvPxE9DD52VWi)B(G#&ck&ZK31`7uxQcQ?73XGgVGt_;kfK)JI zM+ruWX+V-hNv_60>{$1)u9@+)?zgR8s}%pihUN%!T)C|(uxwppxo{0{TLo6vRek^P zCiZIP&i`Wj|gmk`0^x6v&zfTlu74aGmHhG{oaTeR>9i*WsR36Hq z8RU2tk*6_hlAAavL7w1E4M|oet0^+e%`O^#zs@ai2GeGpVXJm7qMV=q|BPe-fQc?$ zPapt>(cPhRsi(_mx^yKN0E256vd0FFuE^Q5AyqWYsE>*q8XaLWfEh(I=lb9?16BSa ZM(U+htB}}7uFy!l2grO!`3VPs{{a|#G(i9W literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/file.h.2A63A83574D7D652.idx b/.cache/clangd/index/file.h.2A63A83574D7D652.idx new file mode 100644 index 0000000000000000000000000000000000000000..11586e1d85aceee05275c670615f78b047954372 GIT binary patch literal 2214 zcmYk63s6*57{|}9>wWLJu)6`v5-z(XyW@(prBV4v#n4Uh)x@9$grHJ_BFiW$CKZEC znQt*BMqomB7?bfq7Npc*4<##`)JaDh4Kz&&6*9#KedoaEbZ7RzGyng0&OP^h=XYiY zl9P8xge2tziu30eWtj*eR`>;r3g5U1|5FWw6j!BeNLloaGpzj2Q1O-eji2S!uC0n_ z_I7Me_w>wen^%;xuzm8(Eh8WNGpeE@wxlHa_g}&@)^E@5K0PjR<9TUA}0u`PV{r?>Tc zlgGVYkbCF!-Y*~aoEqP-KX-LnWlwwCp#`n}!i>24+4A&=TvPicl6tP>Xv`dcMSNS= z{+O%&y&Y@xo{k(>*B>;m#Z&rphj3%=ktyzp<7<^kOAfx2R5zmRqt+*^!}?14N*ga< z@oC;P7Dl^N-R229acvq7Xq8bp44w&^@nPc z%>pyjcrjk%LS#a05C@%96$X_Q33tsh~(86j~A~MrvGGOU%%cmkle2TjoEt zTp$X>L?kK~7PDvWC$1$E-hX8kC6TalDpG|DPQEj@^TL}~gAm8T(!7$_%mw3F!P26> z`nlz1G>Gc6`Rsi1#|2WAv9RI0zAYhWDBBjlX%rVM-nH!JtxacF?xrLRKFluKRW2C! z)Z7Y`?e1=+#0jG%QPR0!y#CC|uInj7+b9W#SP4@sTri$|Wzvl2yhJPs$VQEofl)?q$jg{i)%%MJrtq>29hM2iv zJnY&RQs8Rk9ZDX9*eN;9TrjRU8`^bhjr5R`!4SJex5foyQaFD>u>F558WheTHX0c; zD*f#BHcEECFSvKRDJ6D$&o?RCcf@+&&dsL0L0od#+z^}lq2Af?0xP3@J z*bIHF#_a@~A&)lF4mLv_?dpd38J-P?{sMc1G~&@p5Pq;3`B;rd0BlA)t^{ERn~{z- zLJl?~9PMrz-MT_O&h=Yq2>B0G C96*Br literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/fs.c.DE158A81433875BE.idx b/.cache/clangd/index/fs.c.DE158A81433875BE.idx new file mode 100644 index 0000000000000000000000000000000000000000..ac65803fbf7c3be593370c27e27c94c97ec53bd8 GIT binary patch literal 10498 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 Ee@q5~ga7~l literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/fs.h.F83902F1C88C3791.idx b/.cache/clangd/index/fs.h.F83902F1C88C3791.idx new file mode 100644 index 0000000000000000000000000000000000000000..3ff50b11780f338a1a7b24c9a27989fe82592f45 GIT binary patch literal 1830 zcmYLJdr(wm6#uyF-UoZ{UG`N7j67VX#dtUp0fO2XZZbOoF^C{hAW{(`xyvM!)r5>F z1_(YtB1m+2BoQhkuW`mANJn9Xv6Yj32zhm9OhIl|eujb&qJy6;-C<6d8;WG9m{l$>VI8%_I8IprD)pY%tibiLeNKYr)O`!|M@wRGfiM$y*XoL5@S_S3sf zy&=NZzxFm*Y=yZyUZ)5d zE(xEj>^x6IqNWMw%lZm35Ei-z-=Mf*dGzEd1x=v4To@B3$UwNK^7i*DYJIe`+9rern5;R5h1w`>m$g3@ zDSlswM1Z?RM&xBc`Qy@yf0Dh58j%xrMzpd8ke#DtKBr7cR(va#zlH z%!AKL8z35zs~NRQ29&q{wXMbN*oG#NC_pwa23HwS{%Yf%WV7~2KTVV{P%p+ykU<(K zxPeRuC;D1U4L51>9LNGAXk?INSRs<=lvh)EvFl%vXdt;O<0{I4$%!@V9ot9F|GUb` zMRpTjif#g0veHuz5ptAiCsT`~TAEkV<_Mp8~ zG|<6punNoRNP19Ee!3~ziRZ$pa2BV0>4`qUmOc;zr`NLJ^=DtT)vcxU+CB@=o~);% zO0+G|l4r4@XMRyO-%2&b0qwzhXfO%77--4D`0hJ#;`FDpZ=|_^Eh&*kxAL5tQqyQJ zo^z#KX&gAuX($bi1@oMi($Y8|p3_k}8vD<4dP+}YBYDn18EEt*&lxErjrNCqrTl2@ zEv^*2RoW+fYve@nr8NKKLdu16XWborfLOs#k9A@N5GyU4V-Ob>r!RMHDg)Y|^>+*c z?+04iJ-i7A0<^Sq*jnrd(9*79ZY&9CX~&SpWI#*1g%3m-XlbXA?)ti1ad^f)2Xp`n z|B}zXDevL#9#lMxi`CWN GBji6)nBidn literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/initcode.S.373AF54AA740F373.idx b/.cache/clangd/index/initcode.S.373AF54AA740F373.idx new file mode 100644 index 0000000000000000000000000000000000000000..527c9ab1fcb6c8178bd11763dac8fb458d933acc GIT binary patch literal 482 zcmWIYbaT7K$iU#7;#rZKT9U}Zz`!63#Kk2=nWjK-7bXUViaApQcjp~8;JLzoF=vtz z2Up6AWKAgr=eC|koy*$u8Asik8f&#wHrrLqYFxL=nCDPy%+GIcX8CLD>WG&5<|;%L{tYu(d&^yX z=fVxWS8kMquH$n$7{{Y>&eb?W#cWlo+)+W3xNSFzReWqJ-6L4b%o5(MU19dK<6@eh zMF!99KsWK6SF>&xN9C+?-FoQ3>&SygkKOs1x&Lx%)M7rC==2CXo$&e}P04DG^J@xk zt+0|1WyzlZ;d<_Z;&WTuMyOh_=8xWomZYSZ@s2G(rLUZTnnlhweU>3p)R#t#OomaEoUi^%=r~Bg9_q`Xlov&?= zGc~6->$=&3d0C$Jr#m+tII~FOHwim$r9Wu#OQy|FziZ~q;qI1Bih1(fDE_6*a=8A* zglmVsTV1gCBhA^QS;D5>b3~7KUQ0S|tGZnO{MWLxa~qlt{?XHZ+sAiptj)VDol#hw z)Ra*}*LLqu`Ms&ItdX;R9RI@UbwA4IY2IJIUGWbm&gUBCpIcI3##72D&d4&1=~9S6 z5&%d|sRh9W&oTHEyvXIQ?HCs?0V%@)l1XHd!G(lnsQUD`S#k#iMw}fDqWL-}>r?`o zqJT*Ymfmk&s(`YI5G3MoCdd@%9IQhX2oFw;1)edxoAQrN`a}Yfxd166m8#%E$e*<4 zWOj`?>=%Q$|F@7Bilrnx|Hk-;?1IM?5DdcPdZ4F~h%b_m@R1dxlLuLaJ0u_hldB{u zRd6BUgu<^*e6ZuwGY|~L*~uW8uN%vb#mae{fbx{j;>z+qf7UAi!*G}tvP^Ix*}kG; z|7+}T(mjUh*ENV@VJsVJ4zh?W($Im(3axAy*(jSJjO-$NpFf=?<l5+L%ho)98N;?n&L1d$eMrD1YYipfOCf8L(6?$)b2f zN~RA8;TXMR zvJ+&hZt+E&Tec8Ou~3#i19VbOniOnaG@-d5Idn|8|xa!L>OtTOuA_z)SOA(9k@(GUZ^CvP9DUT)Hak(o7zoCA?J z%1drD0C#Q-sK0&k5Eh-vOAS>cV?5e;OCb{=HEG!vKB!Kplt=#X!hc0O-TJ1Hzv(OA2QPTB%XT2t<%! V74it7QX*B+kutG*NEAOB{0A|l9Yz2E literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/kernelvec.S.06F25524429F6CAE.idx b/.cache/clangd/index/kernelvec.S.06F25524429F6CAE.idx new file mode 100644 index 0000000000000000000000000000000000000000..6d4347b33752bff772412bc7e6d7deb364999c4c GIT binary patch literal 266 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/main.c.2DC262271CAFD048.idx b/.cache/clangd/index/main.c.2DC262271CAFD048.idx new file mode 100644 index 0000000000000000000000000000000000000000..771dbed85023866694efe65d9b195c1e1b066e87 GIT binary patch literal 1184 zcmWIYbaR`*!oc91;#rZKT9OE4G6(~4aY<38JtG5y05bza#hkf8w)sqkJZI%U?R01j zP;INz37sfmRpPSqh`7?EA5WgF`|w`6if8SvfVLy&{VVG>rm`+z=n`{J)wP>lSjm5I z`9lspUamN^e*fKPzx`Z$==v3ZV|l&gTd+6#=dL-qqAtQWgCg8FSInJ-p*goUiuDnCKhu$aNRnl2L@7(8~H%(U;2b6wZG9fgc zVH3wzhT_WHBs*Yu{tbUs{ctIN8xMm#1A`R$Rfvz@Svt{^7ESqdX&zq!^1BH_T9%Uf)3X)2Y@>Jd!djG6FDR9!Vn> zBRKD2WbdQj8`^AudUd#T#9)d96>3gQ_7Zjj3X8Ica>9hqXR#DsT=UfrC@jk&3m485 z6LOtmR~H8q7Gx3RgQ<4^YTVKt(wzx(fH;ddKTMcM(tyPP&g1QiVR(Hdq!y@%hn0s5 zp-5j*Uk%2y*Kk>W{Xn{0~G!IPpV&%I~6WjgGKw&u+Ik(ctt;K{?|%g0y<*%fWq=D@^HtkY29_nkv;4wP*{~k6)tT4dmop;#4X=} z!V)YJaA7NfLvy#zEdR&CBPqlpgcS0^EW$`U5f%|7o<55{oL7{ZlL$(S#YM@*?jVK? zhyVjd$&0E>MItWP*s;n=OUXzu$iie87$gu(DFjm*!A#Cg$&mzdMa9LL*g4pE1o&B) S1-ZC|SowH4h2=yT#TWo&{H65( literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/memlayout.h.0B2C565D58B84A48.idx b/.cache/clangd/index/memlayout.h.0B2C565D58B84A48.idx new file mode 100644 index 0000000000000000000000000000000000000000..9f27e6d4471b38b719688db7ba13f27d5bb0ab17 GIT binary patch literal 562 zcmWIYbaT^UVqkDi@vO*AElFfyU|vkKfhvXLUN)YZzZP4rLLD zAOpj>5Rn_^V|_+i2^w~||?N$FJrg_SszL}9`{p-$}WaUW`c z!V(-3aMiEZt-Hs}b$uRC*q*~49wu{mobJc_UR?|nmgJBGMGhDUS*K^s&0<>)6qe(V zg9~rkB70Cv?AB?ZuqubD7)&+iq*ZH}wVJ;Gg=INp;lj@j_QthW+I|NLt8u8o4Jk^^ aNd)OEE=n%u1~C{foT_+tdEw7I1_l5Yc!i1p literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/param.h.37451DCC2B36E012.idx b/.cache/clangd/index/param.h.37451DCC2B36E012.idx new file mode 100644 index 0000000000000000000000000000000000000000..963f60d465ff92ff38a11e382ba4b4ce2253dccf GIT binary patch literal 444 zcmWIYbaUIn$iU#7;#rZKT9U}Zz`!63#Kk2=nJz%u3WzJ_Bzv4bT&+2rp*D$`!o^*H4ktIp7%FN2if8ShLwC9S<-=-srj>PQcVPmk(5RNIX z%uNCs!%&o(R;&%Qt2>I_bxO`@WkxPWRt{DkkQ4}<5X*L)^x?fOP?(W}5iXp$yfQew z;H?o*n2m#tAEK6lA%|mm;>SIjkw9S{4j#C$43BNs5?+z@~y%n_fE>M`6gP9j5+&-aq!kh&M?gNDx zI2ho<@t1j9>=^1E0)<&PSm1_yc3B_aE6MZ-D9p{l4HwpEpCa0H`rj*{FcSw8T=-Cl q@p~5`=`TQGE)FiZ=Ye6ClL)fExG1@p8^mBNT)JzUr&^3Z0|Nl4)oDQh literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/pipe.c.2473E067140E4F18.idx b/.cache/clangd/index/pipe.c.2473E067140E4F18.idx new file mode 100644 index 0000000000000000000000000000000000000000..431d9c3252d814ef9a2ce680084a290f496b8e8d GIT binary patch literal 2860 zcmYjT3s6&68a|2PhMSz++&oAiJWPN~2ofO(2$V-*qm;#MN}#X>Dx{LAJdB$_4TuyN zR<+#Gv~YK ze|-Pz+}MlOu8oxf@SD0KUz4-hAp!uX(9hfK*?ds|Kuiz-zJY_KzjMze!<)AM4(>YH zdxA4{Pd&~&7*|X8USJ-hUbH?|P*=3KZuOe6N4X#TaLN_5^Ycz;PVQnqYnt5k+BeRS z(uKN&`leIkZ$JEd{FXx%kN&*;y7S1DL$fCP+`YVQh5x&Bwf4lLch?(h)K`AE)@k{8 zNdHBHXI*w?*c(Z^FV}uaMLH+m+^}};yD8nA;KA7kzuY`E_rk*`zkk1D_2e$)Y}BmH z0UugK+RmcdmPmGkvV8O0-p!HwMw<>sjy1GA*TR}p{&OU2XaA47!pH5cuH5mSl$!&6 zZR$bSih{l@VT1Fw`asj4emiSCU8KI;D@_*n4BhUw4mZy(?rZ3;y3(-wT|;=1AMn zv&`_zp2?x>t?I*~`RVg7f4Nw3aAV&q`s3otocMmx*I^X{6L0UF%Gy8jcpm`O);8)|pjg9Z6 z&z;Vrhg**ybG#w`Zf${1`+jf!{>dXV!*@3gZmXO;FT3SFuxGr=+uHQp)2N=uJ}Um> zxl5;)L9hw{P6ITwp@c071GGqBSrG-k7})jKgv;;H3|N^0IJsC3{R?Uc|Fdr9ZyBl2 zG$|OMN5_nqk@^>WY(8_a-ecaq5`uJO+y-p4p^Pm<#;Iih8UM5){+`o1k;H%`q|J(1 znSa6B&12W<$4|sAnx@vnMNJYl8Ko)JVvvy=WNC+~PgHin- zjN%i@RVk~q1UVU}iXboaD)<06pWLS=XuEVfOVAF@j&O{; zXViCUs~GD0JfPUI0T_%eyV(1f`|;$R4a9kLxfgO-$q>B0Jc#{@wxPn0Ji z0TqY}0#FrI1&INt&>2inmq6Gh2*yO8DWPT^XP!tzMC0f<1tFS1C-CUj`4b(TnxD)9 z$i)g{C0GdCLmD7Fr9 z2ZO~VFSzqY+cxE(*M*`&h&iaJ!ef1c)O-|MHB~Jo4t*jYjdgqPob6RZMJdva3X58f zqq$*YzV28kc^2u)g>nk_E#z1sOW}Mxb<*n7w=B4kZVg={#}4rL21)#5OVXvM^bB?Y zx%}XK7E^_sm9{DfDwme?ZT-zxmiza24sAtL>}tCXdx4x=?bhKiN(F6Zr88w464EF% zA;gO&Mq|Xts{487FD6Sn60(Kc48&5Su2GLIWw(!cf@gMjE`waQFqaC^Q2=^8aoRau&A^aM0p>!zUTPW?SC@p3PxhzFi!06i)wh-d8k!|E#A-&5! z+H|1#b(DJDRY^06+Z2`Fz^a>t1 zB=0SxWu;$4LN)4|NW!5*)e(XH#MQkxU4CTC2S~^wvd|1i9Sc+<=L(Mp=!d4ql@-8B++K zIC|-otzF+DpB&2tw3>-E@o0Ejee|P9?e`R_p=gbiSSl732cQb7BA{JdLRY{GMo!G@-~#xMlKwUNOx1}Zfn T5?aeDLZxbzJSV$R%22mO={dD{LOR5vsq z-?Bzv)fML5F#=Po9&9+Sxb?k1M;=_>a9oeK;rr^{@w2b~`o8$l<*L#{?Q8|SKaRI7 z(0;BXd4XwLZkpazmFL0B^MtktEnd>8`l~C~Y~n`owdX3kzRyz+SXq0_&O0@_-_rW~ z^(SJ_z2@F#a+5w<7~xi?CVM43@L9sQ1|~1pwj9a1=e=)vrg#}uoxZ}dQ7z!+%rzS? zx_2$}SQPhqW*_&>grMhsX~w&A)6SZ*?w_k=(!STmK9M-%*jClI!~EB# zbk5~zHPPR1Z7Jru=6wG6zZc>y-_r#wWS?f3{rY4#FCa;N$EVfLC$G<6AiwI6#=V2} z>c^B!iz{=JT7cmn{r_;eM8ghg9tJfA1_eb1MK0Nci~86$8C-gO1Km%j zTJtby0u=}|2=mAuU=%pOC<9iYCBqOqgImYo@lrP)26dnUEe0)K*+Yy1hZtoUIGGt4 zfC}um>)6vzJg?(n&;TmnX5i+K-OnhnpHTv2f+|o!QEFQ8I$#>e_{J`~PK1|(iARA? zgijXeIxyf-kW`m6fbn1sX5<397ADNRbn%J(vHSEGfvR~VC1AoZ*8^39oDLI)xfv)7 zaxhG|du`G;W?#u{kOO%61YyEF3jDnMa2{`848!XyA+^jr3ZlHCLNFV66qI?DgeYKFCts(biBOA~<7CtVRDxh^N{75`W7D+CIEix=JNIVrj z6%mA;x-7a}Fgxe)INgu;y}B6a7k&|bd6=ER;IWc)h4D6Rkv*s-cIz}S)MR*Mq+r6& z4)(^iSK59D>Qxa_QG^NeDCqL&ioi%z>u7qk|PO}kr0<+<>Kb#7Zze?6XE3(a@;^R literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/printf.c.0918689B2930FAE2.idx b/.cache/clangd/index/printf.c.0918689B2930FAE2.idx new file mode 100644 index 0000000000000000000000000000000000000000..50a269003187a17b81bb45b3f7c11d7a6c03a27e GIT binary patch literal 2010 zcmY*Y2~bl<7~c019!c1okU+v2JRXM}QOXe+5D*ZgP_z+A2}mQ1Tv8vXTt-ErGU$j^ zE45ZTwon~W3l`g{*0EZ&RZ)sgwH|oj1ZwT5D6O`r-DJ9XAv5{k|LwQ`vHyNMFD)fy zz!`v~#c4GaMb(8|0Dvp{S5-45y#xR$P5{*GKD7Pq7EcXaKQ^BkDV+as*|v}i(<98L zymU^?^M2z8<$be%EV#a>B=PsvN2U&j81(5%f$DPby>p4(;kRP{JytrF-QN4my``h% zWZ1o({SUeVeaCyv>M$m4UFd~l=1;yez6?10T-LNGIB0BPWOKLA<9z;HQ*_Iq*e|a9 z&dHmVD<8*qji0y~_tO^PM(>Sb=k@uT_SRWTB!-=ms_enm$G?pwjNHw8qH|77u1(USK%=j^$ML(-)UW z-^vC``F!`LYt6ej#VsDSdoqvSons1pFI4(v@Twc#;7aYaqB`Ba(J%g}OXO%0Zac@% z%yX&@(sk>ka~n0SYkl|4Jo_Q2s;zimi*C~=BUHU3+rwE1Gyu?2p;T@&=)P^g<$LtL zk=|Q)5JVw50z~j^2Gi|B58HdHzgIyJiD)n2#j_bqmndY(+v8065WI!xMglYv0{>h| zt_tuu91!gblAmU(8(c@f7J*PMpye{T!e(%MW?u(4<>aLvA@D=-N~o0C45rDlv^$n} z_Z}C4Fchtz6hfQ9G#I(>zjyfTaR|au^a`-T$$z0_p&am?NNa75OJDB&;kK(nFdfnE zq&wGUaI{u(`qQ3|SH6Z|2BPCZJmsGw$x#44MMOmV5Ug0!B}+tJc>J}YA_geL*%3^GH2^IA@I zn${>@grManf@~rL_$G$3L=Q|O*#<=Tk$x1eh-pIb|1IG}gJ1cqopXgQK>HKO1U~L` zw(6gYI|4NgTu4XoBgFW0kd9Hs__0W<*3v98s0@BML2N@8!@JnL2IWoVrn=ze$hGqh zSL~|(3@yv~aw(Pv{&EEqc(#bH{z6p(7m?~zIGeX7z)sQt@d}OQgU=tz2qp*&KG!tBm#g=G~G}qO) zkc4u?IdVJvrI>xBC;c%y1dI zvT)1jGOceJCxLV=S<7R4t|RLlP(4|1M}R3RFSLeLF~+Jb=u6OjXZBB5=l|vEqMkN2 zIB4>uDS`e0AP}bpU^45fS$7)i2D7d|>rP?aAl9A4x&f>^m3563i_4V=db)e_gd!+Y V$OU|NiPXcz%~h-nQ8{~o{{VFsRp9^t literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/proc.c.5346DCDE506E9F58.idx b/.cache/clangd/index/proc.c.5346DCDE506E9F58.idx new file mode 100644 index 0000000000000000000000000000000000000000..1aa3d2d69538a61d9ea2e7e64bdd1aead9c0be10 GIT binary patch literal 11546 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/sleeplock.c.BC30DEE970D57711.idx b/.cache/clangd/index/sleeplock.c.BC30DEE970D57711.idx new file mode 100644 index 0000000000000000000000000000000000000000..ed86f4a87412c698c9fd720fd8c5b8361e736479 GIT binary patch literal 1446 zcmWIYbaR`>%D~{9;#rZKT9U}Zz`!63#Kk2=nTr@17&?Fg6?2wOKA3mgfT!)JhUJ$H zd`q`3aSmiTk@#BAmHEkr!+niP7yAS}OH^k2Hz4YLHE2)+RY3;d>oR-Nv&v`T1&-9#&X&JMGPl9)y;E7ii z0?`Xx;@&e#x}?6Fq_{;-_sTTpl_&NZFVWJBuAaIy9%{T-n?G zD(Ck`L$)oIZ{~!QsT?@-KJ`n0wSV!_d-E;?&0YO=e{o~eb@q3sBz9cA^g1vh$++$J z&gSF;*Z=z&8bEw<|@whZ+}(#(bk&V zp5bXSZ)>1ez<5Qw;PSC=_A7n^Jy5^UzA|R1Tmk1o(sy)`|0r3nHwO6qXc4 z@MQUAk>r&5l?7p@^Qfrvt0VFB`Sk^14&zZVd{YBm;eoat;}=1~!65{LVRM@5-Q8Oi(lO!}NKEifMd{Rv78Fn@*yvbkT4dA$^5 zotTUyl66`Jx-h+*l`gBJ+^qKkgN~n#A08#v|D{@{R$V*G%A+E{Ccp!;fk#DxS3($J zk~Et%4}zz{row{=6$35<0hlc?8t6h$YJ|CP*-?>|=Viq|0R1Y^#nvyDmJY1GR0l`#7 uFqIHYH3U-;!A#Cg$&mzdCB>!LxOun)M1(omMfv!}IE4gx#kD0^r5FJEMec6^ literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/sleeplock.h.56E9B1C95DBCB92F.idx b/.cache/clangd/index/sleeplock.h.56E9B1C95DBCB92F.idx new file mode 100644 index 0000000000000000000000000000000000000000..c3f658ca525ecf8006498161b433200bee09c804 GIT binary patch literal 510 zcmWIYbaVU0$iU#7;#rZKT9U}Zz`!63#Kk2=nI%BF6^JY5xb_5cH5&-9e%ILPu*-F! zyruK|fSj6Z6MW55Ty5%J`~Q^yf~u^)KX~_AT%2)M_g3s{sYJHLs+>&5>!S{Yeiu2Y zn!7%^{sX`M<=cM>P;GcYhQvNH;R2?kCE2B3=>&UP+RaXunqz{kMG!NA1M#?A>Q7&w4( zKrp5JhUTG_+NpdD%s^>oA!ZRU0h8vebXgtcX1$k>ffXpt#=*t|CScOm|D{@{R$V*G z$G`%VW@2aJ1rso7hN9H8;)Ot4U~XjOg18NAHNtH`VUWXMsvi6EJ*j&U7|Y1R1O#j_ zOJGg~ss_0errNAAXkG5Ck_AB3%$&@EFjX*@166~Z4O0y>3@8k8E=(Bc(wsz)tBQ+~ Ti@8AzCMG?ngDlf-0)rR;++~X1 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/spinlock.c.1B29CD753041D103.idx b/.cache/clangd/index/spinlock.c.1B29CD753041D103.idx new file mode 100644 index 0000000000000000000000000000000000000000..0eadc2a16c0d7277a516732de53758ef6c9ff915 GIT binary patch literal 3054 zcmZ8i3s6+o89x8I?A^V4cK5;p%X?Rrg$n`#6@(FdBuGTZ#L*TbHZr_oj4~#Gpu7T_ zq*B5|YC(A<1&UE7LXDuoAP-w=5VjT~sdmPiP*oB|MNe; z|D5g7QBh+`gkDaHKAe)A9xp`*X~{n=J$2t-0HIIGhr>0sJGSn34isuX8F^V9eLSX3 z`%=KOvP+fQj%gyEe(}}NquAGn&X#BF*UsKs^N(QDzSvE=r;nemIvCXu|Lx4kkietj_zD)cvYI^neZ-zWs2fc*)b(ZaM$dyqZ(4n;Qvgq*)$5`JU-)nRePtGmNahwU57nrz&8`shb4ueF_O z%ll9WtGD;u-Msg*(KxP|zM=QpuAj~B+Y#DkPIw&u?wnfNe%-cApV}PRxFI8~ z@4RZpJXI94f7@*KUhPqzAG5E#dUn8dVpMz6&1v!-@6ow`Ivq%Dn|rVJm8n}Nt^{p# zv8&7}4><90y>njbuctTeI6y z5uS4)RX$LdkCC1zM4$-Hctkj&vxrv{adNc$^8eazA6211B327(r}@W1e5f_vY4we6 zc@aiGBjS^QP6B7l6Y|J@snlZr-fH)<`cETHs8A45P&uev=O1+cOTnRU+r<8>2_ruu z&PBPLF-ypr_il;)^`Gl@?uv@+z-Sc_7Xm5-xiMGBCDA`O|L(|*YUh*pzQ!noC^P|T z0=)2|E(T%{BxU(Nz-R?g(IdTl{z1iOdTr0$bk$8`6imc%D2_Ac2szIqAn~Kr;$fJ>BcVLx)}ca*|z3QqiapXW3VikTV#(IsgE=) zHd;Iniu1s;Xj(vQ0dI|&U5nOJ{LWNM!>mBUu?0M56XP7rlg}<#DrF&RZvG*G)N2zN*jKDCa6~|wu7V{6f}#6 zb(}0eHKu*)3bHnj3%nR|P)Y>sm&PwMc$e=XXQNLI;X-tj`wS%%9?5JNX z4uf)-VM<0qkxWUZf@aJwj3f=8PNTrTFojsO=j<_yN+;7P88UK4%;NBnc_ebeonXsw7ihYc;%-oNgAJ4SfM*Y^V7MO?{fy68G=swYB6c)`8`C#~uNeXv9t7hc zhzt*batH*9D>h>xN` zr@*30t+J;D#iE*1YiQH4Xf0SfunOu0y#uS6zu@n{Tt{dkbj)>}CQe72hs9h?u8umk z9BW=pu#(Ob{k{x~>#f#fW+Gk|uc9XS`6HEfzj2~9EwlXni&j`H0d)!3(8g~e*Hss;taH6X8Hax^jG{>k{Cza)meCEgrMb%S)nlDZ~H6PDEV6i81k zHCYAHDu!t&gwX3G>v);WCMh{Zur z46@l&POs_sPt3>P$g#LewrUCMw(7UK)5I*trM?B+sTVAEgRUE#m{Bum&0xP2o6Jk8 zZiWyugfaOL=!V$-t2Qh2t~S0SGAzd8SZn4s9}M|mqHMA-!>WXx`Ie$cOF_YkQU;PT z;25p|n+nj;B28B68ecPIj*@B?0WJbtrdSD9m7t=Elp_-Uh1(d5A(D{AJA~4h%&W7+ zdC387l9^Q00zZFgQ$kn{M#(TcpvnDxAl@QOOHE9Rvn))O$Mc^TT_EJcmfmb>WJ?dW z^jutm==Y76@5T1iCeFv?;qB#VM2RU$2ONoli_T4<)~K{PdnNB+ZR3dTYz3zPXSpl- EKL94UeEw!OTwfm>G9Ny?dfKb44{bBfPFizOWE%USD8tT8%8M*r)x2l3 zEYnE6v%T@$)>rp;zMU8A&t2a;^^;cF-Sj^PoyQ7&w4(KyWGjkTw4|8$&(@HlQ>s2P+SlfJqmhv8a2e zSrNm>zyg$JVrSw76ENv%UOeh-VK?URF)#t8+4$H5!30d&tTAX^?yQmpY#;$pfJeU zFkzUBfx;l?!h|3D^F6715g5zJ!_36Q#0FCZ^8ipa$n`MQFd8Tfay2NRK;Zo8L)#Mj vOb-GLVdG@ufoX>M1E?D037F=h)SN_+uHvHPVr~$FS>&H=x$EXIW(EcTuz#Oy literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/sprintf.c.A2EB5C91A2B1B2CC.idx b/.cache/clangd/index/sprintf.c.A2EB5C91A2B1B2CC.idx new file mode 100644 index 0000000000000000000000000000000000000000..70a8679657610cff58e1a453488350692347d233 GIT binary patch literal 1128 zcmWIYbaP8!VPJ4h@vO*AElC728H9njxTGj^2_pl;e4s$ZoVAmDv!x9M+MX}}F~K>= zCMajRfKP13W$zUS+vTcEHks@eyCy#AS}DiR_p<4-w@j9*cqiK5lRRs@cp}@m^Y7G) z_l8z}d6#HowR`@#+!g&;EZ?VI9MM?dLzdEsyi8V4STcJatvm#)YZIE>|x8mZ*~5 zyY@!PQ_kQgYXjc>JsG4gan;(#GVIdV8JkV*L-GnvtumE%SYK=ML~LFUS9y-{l#?r& z6IjAj%OZuPW{Vd|+nyBo9yVD-FY9T_!*e&cZ;z`AO`6d8dgZjPD}Jrl=G47DxphXz z%#yOp)lZ&C&3pRT?OOZasZYe`-V&J;=a;^oW1{t`#tLQ4;{UxD6n0N~dW`MoqYoRe zO4&`x$`QHUzu@`ygq-Z`#$#5qynoKOo?@19U2;;)r00$~|D&GI&y~zNCGd`e=Mh_| zcb9ts$BznE=L3&AgyJvc3CzinIA?eE=Io1A(_d8VIdfS4rqYxP-akSYgdcw~Y1gWU z>VBtsdx|S_lNx|=ws*ZQ>+{YRLOcwb3=FFJ4Eh{$w-^O(F-kCSGBIkYOEXHb9yjph zzdyfIkB31AsDzJ!j}=S+HG_e*=A`>emNnS&FlYm%MHxgn!30eDq~&|t8Mh2q^D@W) zrMY>yg}?+%x+pcRI1`v=VD4b#0y_dGo!2Z^Zu5*$nvqAnm;!$=4;LI6WPQmtEQ-;tRSx>#~=%nWnh3C$-tn15LH1iF=hz{0J}k64*&oF literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/start.c.92F9EB51DC5F96B3.idx b/.cache/clangd/index/start.c.92F9EB51DC5F96B3.idx new file mode 100644 index 0000000000000000000000000000000000000000..2dcf96bfa10588204582e1d97c2635d0ae3c9760 GIT binary patch literal 1678 zcmY*Y3rrMO6n#4jJNuc11$NyJ!*5|XAb&v+^@l6_llwH53%VR3HTe z?2OWU4s_M{($$d_|DYIu+0&{|8dgoLP(o?@) zA4-@{GUWKwwwLwIjPuU;b_0B}&GOO2E;n;5TAJvgzQ5b6xn@-2L$;b)yf+6y8rjH(i^v%L3Qf&_^wl`GM^Va3$pD^06mu9Z(e!Jtu^G>7fl(W z!uUfI-#%!VD2YvWReI$2HhNzRv=6Ma|Lb;--9pB(k%GF``byFEsQ!wmCK=OpQ=g?qd)>usAcGtm`w$P5XAExftc18U%5wSDZ!b|$f z#%Iy8PxH8#`F^hJ=#?U`Ygp$BYj!woM^=xx$|Gp-R(S|VHod=M`9)uG({tg+KZ+7H z>FVfC*x}V6YuCi!aEgR3JyCs2NSK@L4SU@u$@O3v9WG>>RtgkZ4 z0tsLV&HlijMdG@+9x|^VetGtJoqjF>%>IK&hAxAJ%$BwfTs}{DSi}Y9(3@?=-ny|M zv+Q1ew@hd^NdPP4%_DexWKM~T*Nnrtpy&OZUR?VXP9w;0ES!ZTwI)cHC&dsg#kiOXhT4F!H#ju4s8XgGvLOpyq&qskdMIqaoK zD9(-J#z&PAWB@0CkFvk7e_J#4+ksT*Yl@jN5ox#N?~w`{=L{T{0=Nv+QAlE&@(_t2 z6*>wwiUfC-3Y!nRU@VyVVHc(sM&*QO%Lz9?HZ)flYtuZzR0gI3lxkmr1Oybv6+)SE zrksmlG<5K^v=fIa&%A2(>C4_XrI4*MR7ntQxa+eM)h8I=L0Dm{piV1gHY@SYw){J= zPeQ)X1jU9YO+*NgN^9kp%kw+-cSDi{lTfXPBrJl1NGmaRVdYEYJ*`R;IW;9Mc|9?1 zY2*Bs>ShD=qtlyR6lNdpV#+nIIsp`3(SHVCy)}CbX@DINr}+} zYJZHi%fAm56VOPV+_d@**Qq_aCK9o+2vD;O0Ck-Jpd_ Rz~&h0>Ty{{rhM8K@DCop=Su(p literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/stat.h.AEE4CE7ADDE89C85.idx b/.cache/clangd/index/stat.h.AEE4CE7ADDE89C85.idx new file mode 100644 index 0000000000000000000000000000000000000000..4bace528f3f50dc52bf42a6b94075c1e87e22a7b GIT binary patch literal 608 zcmWIYbaRVfVqkDi@vO*AElFfyU|X9E;$?u4&eiLB z4B2d=*Em}9o8JGkVE=lHQ*O&+dBNh!+@xJV^Cu+>Hm~44t;@&2%Fe*V$;rtJCKxz? zazJqH?~01LqIg?A1`eP!I|n-tn1D&od?{%6OYeva9|I#$nw5=}6HLIQ=QW>m70tUd zg^z(5D9y&s#swx|(lZ6ccC=|c*vH4f0+i<9;NS%lFzGLSKbG_L3*TmAU}IolVqs_D z1``aN5T_NTrWOAMGGRVo*`C!7bQ-AKzcAWVID9pscBmfh>KE2%f?n~d_Kw)6`@WO-{ic)hDL7d{E UV=J$M4BH)Nx^l+NjO`@KA+$xj=L8XaU~{ZfSFolx?wF`Tuf|Wk0ma&y5m7* zicVIVHhJa;Q+dY@H*Ejq^w`qDwwA%*DGPqduA_WahHBm9o}1D+q$_U=jyE||!$b|xE^yM=jIAMNLdw7uwY_}DDB zQx_f&r{>@-(e#Y1rm4v6ua}-ELV9~R)mge$-A?;*cCBGFrSWn6ebt?^!-BAxaeI8% z^nq%}Q-1f7u_5MUZb!`n?Wm!6(rbF@e$Fz(`Wj3})ZlZ&D=og|;@*4tvwgRMj#|oF z>PC*+O8kp1B-ED3=

?4M^J)x+tu6z}*lvZ9m220m0ku<2~fY2f^vA3xu5_JsFe zTpWb0MF;^+z*_TxaCpISXRtP!4b-rk&?C)9H`bp1fRy|pmYRgtJq6(e};q2usaGw zF{Psv?kGh9m=sE=#uwPqGwhXaq<(H2b;AjzOc~(fK&VyfEeIh^smu*p!WNFw8x_6m zy7h%a^e&8o69%dQLwrilRSftaY>9wjHC-)4)o2dx*arP^BG5CCg^J(?m=Y(E3Rkg7 zq{XzZ9GV+-wqa^GA?L|m#Bf5-)2~AYFM|jz@N;T(zdUK)3eRHX z82KoC{j)!R&ziQMfngKJBtYShe3tqzhiJ}HaY8H+%MeAJka|lup<|#c19e!vFKC)L zp%SZnP!W_)tJaf9gKIb>(qTH6Vv%Q?ZH)eM2c#mW%9*Gr!S2ZYxA9OZq++BR>4+iZ zOEtNW?wqA5`$}#->}4@oJfs%7weX#-URjc%+*8g)8^F1_2Vx{r(v+^v;S?oG*MZ^5 zJXD@!rHZE#kw~pjhpt26>TM*_cxcx3X=&PZJLqV-bx7~2U&qXV8+ho%Xf=3GRv#F7 z7^BE2Lq+JNQJDYx!YG*Yd7<8Knu7N!FLunVYRfRX{%D}K43i7p=oU0Sk&5S_wtA}G zMb(ymB4u?QyDimz3jR`veZ>zQ{F7fvn0^ZXzyR4MxfICJP5{VA*N=1+q#H=OQqm0| o-A$zHPr9kuX(uEQip3Hd6JxNwcpmP2oF$-hIiA8Gk()R8569I=bxGa=*hzURb#K z89#r)y)8*O@w}brq{#QSXI;GSa#lZdTIVw__H*Xaqf0lfTgkY%`%b_Ox2&998Eagf z4$fngoRTVcM9?g5+p`lBeI8x3HVREhZ$9a+y{gx4R)(?qqx_H-kQ&s+hxu@zV+fz!t0*XyPv)i*L>zO$wNQLMLopQz*#K#cS_wEIqT;O zzBbDB{A~X?U;FgZ&@$a7okHu3<^N$B!(n5 zFaeX!EuPaEUDo@Ohd~-B&BwsU1}0$AMX71U9>7!t^FJdOR(~^bq4<|a!h+L60Ol>2 z?}2(jUWXYClLiWdybKe5?9cb4?nPiMD~|-TB(p5s^AddOeA;l=O310mX~08W!c5sr z9cCVngpHbw7R8{V-#@SVP`XuS88eTB0EYlC!a64|Cw`cb zJQ7Y~PSP+QEPR0`fdUt15=<*l7!;^5;iA->L=d~UD7jc1#E=9LV8AG`>2|*A|Jk)m n7$q5!b5n9aQljGGOza$NJOcbI%z|9pLacneoWfEfjA9G`U&T5r literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/swtch.S.11DB57B07ECB88BC.idx b/.cache/clangd/index/swtch.S.11DB57B07ECB88BC.idx new file mode 100644 index 0000000000000000000000000000000000000000..7ccddfba12d8a5465e9d207db459e9b731368917 GIT binary patch literal 266 zcmWIYbaP{3WMFVk@vO*AElFfyU|_?6?T6cUZPGloNNM@s+Y2`} zI^SQj^Y*n_WebdJ4}E?a^H*S@=c4JgCyYNw+-aC5vNGI1e*Oic!?AN?I{&@5J;9(~ zus)};xH2~h=wybX)U;vgc{C;Gf literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/syscall.c.05D088F49A8C83CC.idx b/.cache/clangd/index/syscall.c.05D088F49A8C83CC.idx new file mode 100644 index 0000000000000000000000000000000000000000..7b46f32d3cde9d5899d8e27db0752ba836bce3cb GIT binary patch literal 4568 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 KxJZUEFaQA7MUpW9 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/sysfile.c.C337A604B3627C12.idx b/.cache/clangd/index/sysfile.c.C337A604B3627C12.idx new file mode 100644 index 0000000000000000000000000000000000000000..7d2044c90da686c63f35bf0eaced7ab9134172b5 GIT binary patch literal 6944 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/sysproc.c.E5BC46BBC06178C3.idx b/.cache/clangd/index/sysproc.c.E5BC46BBC06178C3.idx new file mode 100644 index 0000000000000000000000000000000000000000..0a06c0df3fef617b20309aabb01defe0576bbd81 GIT binary patch literal 1772 zcmZuwdr*{B6ungOb;LrkU{nePK_-KgG(d=vc%v~WNE1;^celCw@kigxo;~OM&N=s--??{p zXi(4;3Ba!O&_mf71t~@V03rJ27ihC`H~{o>0XS6OP!nD~>S$5Ex-0E7O>1K8-LnpL zO`mG#&h}Ebhiz;mzT=vuMOj{BShiQYLJ|nS^Lm9#-U7aEE^Q4_E3>oJ79RJ+l4Z^K z==yTq#IOsX7dq)u>h_DhUf{OY*V(e0-@^TX;F`;JTDgrzd& zE`OTwDlLq<`1u#q_7@8?JIdqSxSCUU?%Rea@@`#wU6RysAo;c8fqn2wbd&r`LulG<*S7QgEhjc29HNmFJq`$x z?7U_(FFB}&;)aWc72l^+G(>qn32KgwoR{VNp49Wl$%XfSI5u#^C#pMguw!h;cvSm? zwRh>5g19rI(!9LHhp}CIE!A_i>0b*5l?jVo--fMSczdz7?VZlO3F~>OUlw%pT8+ut zEY5qCWnIO>dE54#3l1f(I@gxX{OtZ)@#TnsB5r1H_yv%EI6L)E#6Ry`?v)DSjuix( z0bqQ953Lsn(SP@iGcWaupIbxVhTuJ5kEvc@_R42vGo z!Pf(FMMAG4Jca20gf)~bUu?}GUQJ}M#htg@KKNnG!K-pmQtv+V=Wa= zwIMQ|7cVmGfJx*f8myBmliu2oeFIP{&a^Whb15W)o2odzJCR#yq@;0OpVj2Xr?X`- z$Q?mP@NvV1S;c}|f(|uuZ#CY^$NQR$G@B}#i{3{-#*gqLaS_O<2{nn^`Kn*@lM4vX zM!B9sPb-`|JHBmowY)Kx3mFkDGB+%d@uWS?aS&t_W(vcYD(PQ+r#!YDHH8cXDAKSw zMgRmPTR;rNBxW2k_Q0ORLqo=qaHLqv6}Xb@QSO90#aiCLd&58>AcVwZKqdyn7{-$y zZP8MF$3H+E$OxH%NXWz!@igWDmqm-$-EO>iwdh9R<^I8sj35IENU;NLA+~I2#h>t} zSZ>3Ka0<8b>sn}i$wYG{Dj?^{E!dy{DuB;gN}h59mcUD}z>UR5lfl0vJw1n(BNB?N zF^Mi^X*LxdeHW11iEyGZWB4D9p?igRjM1{`p^i!8t02vDwK&fNa!E+$7F*UbwXI_#2c>JR>3*XM^G7c<9j;VTBi>$4?mwVCVt9IKJM%x57 zouFdy_@O7krE;+#8jD&tl=`DJpJj3-&y5b+}_5u)fvJ_lr{7!RjA@ll2#U zKfT!H@%=lqXaAGm_xFS62hW#NQ-3hqwa@l1uFOpWdW4}UHLW-nNWWgU?jAGO^?7VO z+;YltIv^0h}-f12Z@C?}bH6IxBscxHuV-b5n9a%GfwKn3!33SQ*&?x@CV( literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/trap.c.E331BC8CB04ABF35.idx b/.cache/clangd/index/trap.c.E331BC8CB04ABF35.idx new file mode 100644 index 0000000000000000000000000000000000000000..fbc6f3abceb155949416cf4dc42a0f5758663807 GIT binary patch literal 3568 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 Oq)lMs69ru3N#K9P^69w% literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/virtio.h.7AE2FDAEE3C87964.idx b/.cache/clangd/index/virtio.h.7AE2FDAEE3C87964.idx new file mode 100644 index 0000000000000000000000000000000000000000..324596fc6c1a9511113de34a04ba4c07f19921fa GIT binary patch literal 2640 zcmYL~c~BHr5XK)fvioKkhF#8u1#~%74iBOWs}L>~79*k{c!9WHkzq6hYQ@4 zt@@VM-QK3hf4@E46}4jaZ?C)ByFTi@WOKHEk_N`aFifXHzg8jULy$l(TygXea)!mVny3e!X6tmm?uGX8o2Rdf#56|fv6+WhZ@XG7E?p3_VJR4V0ms369Q2YlR}GM>BxPnzY&N7 z^gNwQx0eFGU1})dpB}A0B@iCcGq@QJQo!`=Z7(z1HeUE%Aqs|#R7N^VK`d?$#S5Zs zTXQn&&nk!;q{k`8X`~>g#b;q_mFAP2K|d;p2GY}&(_N$>rUgiwU%pzdePX?V-SifE}r$9#?PJ-%z>b+cr1AX*5lX7{?#5IQ!TgyPS1v6mfNWzycM#aJ7>| zzr`j`qYq#|>L>r@oKBtkjc%rh?Ww)I8npvh6b`ml)9J!&p1MB(u#W2FA|d^=buAse zfq*qsBNsUsklrulPVNxE!8BN2y-88$@Rf7v2Y|h)w;yg0^$1uLBQ_Rw2v`&$j%WF= z(axQz1rdM;(LsH&2+9($s7Wk>as(`D5%CRm<=8o8`f-56X}AX#xm0j|>zHxnDS+Ln zyAR@EL&nB>rdh-;)TJNdkjc99ql>F2u_`u%hS(wI*%%=P=Jfr;vq|1b@`Y|PTy5#s z@o5@V8b}Aq!?Ipg8+7Q3V>aMG8VC}2|FmA+xg^qRwg4VL2gn#b1h8lz*qGF3YePD> zUtb8=m-@}z|Oc+JU z@T`$BQrr*EMln$ots88SiKcih&=e+y;%)G3EE7xd-g!2WNu;P!FePR@MXws|@#g1k z0U;|Ho;5HAireGa8O#idp7VH*Qc-AmRAdWI&4f}M9G*2XCW-?MUdSX+v`C&!XVNKp z8qa1h85CuOYoG_BhoS_oZRmMDIQvi;U}x$q4_^O2C*D@3KimLVPxW#m@c@8Dr^U9% z3Y+pS*v4-G>`6Uk3HX;BeeK#5^abDm8X(tZ_Qd2pu=#QaUb&?g0!T~IrHx|KT0TxXg zF%|wQ)#L^&xdr)I|5bhmjG+2Ru*I4;J3%xI^H${4x&LiEE3XK z70tg{cLOj_c^M0(LzAcezWgR&SL!M^wqah?v$CcWcL2LlH(3;Tr;O_Tm*T(TAXY9( zi;BUCgm=Y{2A*}_q_M>dvj2Dv*pAxCcZHe&EPg}qj;wQY&0_U@>+F2VBG`$-lImOf I>=r`)1@N}Q@Bjb+ literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/virtio_disk.c.8DF9309BB95BE078.idx b/.cache/clangd/index/virtio_disk.c.8DF9309BB95BE078.idx new file mode 100644 index 0000000000000000000000000000000000000000..ef93d3f09f826c20e81d3c075c97875a0acc21df GIT binary patch literal 7434 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 K-pfPjCHx<@xE%!m literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/vm.c.70D05D5C0213F437.idx b/.cache/clangd/index/vm.c.70D05D5C0213F437.idx new file mode 100644 index 0000000000000000000000000000000000000000..87fe54b8e9714dc67431949bc1bf8a7f6c78458d GIT binary patch literal 7366 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 literal 0 HcmV?d00001 diff --git a/compile_commands.json b/compile_commands.json new file mode 100644 index 0000000..10a391a --- /dev/null +++ b/compile_commands.json @@ -0,0 +1,756 @@ +[ + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-c", + "-o", + "kernel/entry.o", + "kernel/entry.S" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/entry.S", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/entry.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/kalloc.o", + "kernel/kalloc.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/kalloc.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/kalloc.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/string.o", + "kernel/string.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/string.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/string.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/main.o", + "kernel/main.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/main.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/main.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/vm.o", + "kernel/vm.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/vm.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/vm.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/proc.o", + "kernel/proc.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/proc.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/proc.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-c", + "-o", + "kernel/swtch.o", + "kernel/swtch.S" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/swtch.S", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/swtch.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-c", + "-o", + "kernel/trampoline.o", + "kernel/trampoline.S" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/trampoline.S", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/trampoline.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/trap.o", + "kernel/trap.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/trap.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/trap.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/syscall.o", + "kernel/syscall.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/syscall.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/syscall.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/sysproc.o", + "kernel/sysproc.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/sysproc.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/sysproc.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/bio.o", + "kernel/bio.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/bio.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/bio.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/fs.o", + "kernel/fs.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/fs.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/fs.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/log.o", + "kernel/log.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/log.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/log.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/sleeplock.o", + "kernel/sleeplock.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/sleeplock.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/sleeplock.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/file.o", + "kernel/file.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/file.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/file.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/pipe.o", + "kernel/pipe.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/pipe.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/pipe.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/exec.o", + "kernel/exec.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/exec.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/exec.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/sysfile.o", + "kernel/sysfile.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/sysfile.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/sysfile.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-c", + "-o", + "kernel/kernelvec.o", + "kernel/kernelvec.S" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/kernelvec.S", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/kernelvec.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/plic.o", + "kernel/plic.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/plic.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/plic.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/virtio_disk.o", + "kernel/virtio_disk.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/virtio_disk.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/virtio_disk.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/stats.o", + "kernel/stats.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/stats.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/stats.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/sprintf.o", + "kernel/sprintf.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/sprintf.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/sprintf.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/start.o", + "kernel/start.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/start.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/start.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/console.o", + "kernel/console.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/console.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/console.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/printf.o", + "kernel/printf.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/printf.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/printf.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/uart.o", + "kernel/uart.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/uart.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/uart.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-c", + "-o", + "kernel/spinlock.o", + "kernel/spinlock.c" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/kernel/spinlock.c", + "output": "/home/novice/mit_xv6/xv6-labs-2023/kernel/spinlock.o" + }, + { + "arguments": [ + "/usr/bin/riscv64-linux-gnu-gcc", + "-Wall", + "-Werror", + "-O", + "-fno-omit-frame-pointer", + "-ggdb", + "-gdwarf-2", + "-DSOL_LOCK", + "-DLAB_LOCK", + "-mcmodel=medany", + "-ffreestanding", + "-fno-common", + "-mno-relax", + "-I.", + "-fno-stack-protector", + "-fno-pie", + "-march=rv64g", + "-nostdinc", + "-I.", + "-Ikernel", + "-c", + "-o", + "user/initcode.o", + "user/initcode.S" + ], + "directory": "/home/novice/mit_xv6/xv6-labs-2023", + "file": "/home/novice/mit_xv6/xv6-labs-2023/user/initcode.S", + "output": "/home/novice/mit_xv6/xv6-labs-2023/user/initcode.o" + } +] diff --git a/kernel/kalloc.c b/kernel/kalloc.c index 0699e7e..f9d6f59 100644 --- a/kernel/kalloc.c +++ b/kernel/kalloc.c @@ -18,15 +18,20 @@ struct run { struct run *next; }; -struct { +struct kmem{ struct spinlock lock; struct run *freelist; -} kmem; +} ; + +struct kmem kmem[NCPU]; + void kinit() { - initlock(&kmem.lock, "kmem"); + for (int i = 0; i < NCPU ; i++) { + initlock(&kmem[i].lock, "kmem"); + } freerange(end, (void*)PHYSTOP); } @@ -47,6 +52,7 @@ void kfree(void *pa) { struct run *r; + int i =cpuid(); if(((uint64)pa % PGSIZE) != 0 || (char*)pa < end || (uint64)pa >= PHYSTOP) panic("kfree"); @@ -56,10 +62,25 @@ kfree(void *pa) r = (struct run*)pa; - acquire(&kmem.lock); - r->next = kmem.freelist; - kmem.freelist = r; - release(&kmem.lock); + acquire(&kmem[i].lock); + r->next = kmem[i].freelist; + kmem[i].freelist = r; + release(&kmem[i].lock); +} + +int kmem_borrow(struct run **r,int cpuid){ + for(int i = 0;i < NCPU;i++){ + if(kmem[i].freelist){ + acquire(&kmem[i].lock); + struct run * n; + n = kmem[i].freelist; + kmem[i].freelist = kmem[i].freelist->next; + n->next = *r; + *r = n; + release(&kmem[i].lock); + } + } + return -1; } // Allocate one 4096-byte page of physical memory. @@ -69,14 +90,22 @@ void * kalloc(void) { struct run *r; + int i = cpuid(); - acquire(&kmem.lock); - r = kmem.freelist; + acquire(&kmem[i].lock); + r = kmem[i].freelist; + if(!r){ + kmem_borrow(&r,i); + } if(r) - kmem.freelist = r->next; - release(&kmem.lock); + kmem[i].freelist = r->next; + release(&kmem[i].lock); if(r) memset((char*)r, 5, PGSIZE); // fill with junk return (void*)r; + + if(!r){ + // try to borrow free memory from other cpu. + } } From e5c453189c1e7f08c958f15529810f96d8524bb2 Mon Sep 17 00:00:00 2001 From: novice <619671969@qq.com> Date: Sun, 8 Sep 2024 20:20:42 +0800 Subject: [PATCH 5/7] just add a lock array and remove LRU --- .../index/kalloc.c.2F15DD93067E2B26.idx | Bin 1926 -> 2516 bytes kernel/bio.c | 47 ++++++++++-------- 2 files changed, 27 insertions(+), 20 deletions(-) diff --git a/.cache/clangd/index/kalloc.c.2F15DD93067E2B26.idx b/.cache/clangd/index/kalloc.c.2F15DD93067E2B26.idx index 87c6fd37b1a6f472a1c01191bdf3a63fb0203dcd..1bb31de79f6c262256d3f241629f0d2bd78ccca2 100644 GIT binary patch literal 2516 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 V74it7QX*B+kutG*NEAOB{0A|l9Yz2E diff --git a/kernel/bio.c b/kernel/bio.c index 60d91a6..da9c731 100644 --- a/kernel/bio.c +++ b/kernel/bio.c @@ -23,14 +23,17 @@ #include "fs.h" #include "buf.h" +#define NHASH 17 + struct { struct spinlock lock; + struct spinlock hashlocks[NHASH]; struct buf buf[NBUF]; // Linked list of all buffers, through prev/next. // Sorted by how recently the buffer was used. // head.next is most recent, head.prev is least. - struct buf head; + //struct buf head; } bcache; void @@ -39,16 +42,20 @@ binit(void) struct buf *b; initlock(&bcache.lock, "bcache"); + + for (int i = 0; i < NHASH; i++) { + initlock(&bcache.hashlocks[i], "bcache"); + } // Create linked list of buffers - bcache.head.prev = &bcache.head; - bcache.head.next = &bcache.head; + //bcache.head.prev = &bcache.head; + //bcache.head.next = &bcache.head; for(b = bcache.buf; b < bcache.buf+NBUF; b++){ - b->next = bcache.head.next; - b->prev = &bcache.head; + //b->next = bcache.head.next; + //b->prev = &bcache.head; initsleeplock(&b->lock, "buffer"); - bcache.head.next->prev = b; - bcache.head.next = b; + //bcache.head.next->prev = b; + //bcache.head.next = b; } } @@ -63,18 +70,18 @@ bget(uint dev, uint blockno) acquire(&bcache.lock); // Is the block already cached? - for(b = bcache.head.next; b != &bcache.head; b = b->next){ + for (int i = 0; i < NBUF; i++) { + b = &bcache.buf[i]; if(b->dev == dev && b->blockno == blockno){ b->refcnt++; release(&bcache.lock); acquiresleep(&b->lock); return b; - } + } } - // Not cached. - // Recycle the least recently used (LRU) unused buffer. - for(b = bcache.head.prev; b != &bcache.head; b = b->prev){ + for (int i = 0 ;i < NBUF;i++) { + b = &bcache.buf[i]; if(b->refcnt == 0) { b->dev = dev; b->blockno = blockno; @@ -123,15 +130,15 @@ brelse(struct buf *b) acquire(&bcache.lock); b->refcnt--; - if (b->refcnt == 0) { + //if (b->refcnt == 0) { // no one is waiting for it. - b->next->prev = b->prev; - b->prev->next = b->next; - b->next = bcache.head.next; - b->prev = &bcache.head; - bcache.head.next->prev = b; - bcache.head.next = b; - } + //b->next->prev = b->prev; + //b->prev->next = b->next; + //b->next = bcache.head.next; + //b->prev = &bcache.head; + //bcache.head.next->prev = b; + //bcache.head.next = b; + //} release(&bcache.lock); } From ff6709fe7972d36310175062916a58a9acbb7233 Mon Sep 17 00:00:00 2001 From: novice <619671969@qq.com> Date: Sun, 8 Sep 2024 20:26:59 +0800 Subject: [PATCH 6/7] have past test0 and test1 in the second part of locks lab: Buffer cache --- kernel/bio.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/kernel/bio.c b/kernel/bio.c index da9c731..20825de 100644 --- a/kernel/bio.c +++ b/kernel/bio.c @@ -67,19 +67,22 @@ bget(uint dev, uint blockno) { struct buf *b; - acquire(&bcache.lock); + int hash = blockno % NHASH; + acquire(&bcache.hashlocks[hash]); // Is the block already cached? for (int i = 0; i < NBUF; i++) { b = &bcache.buf[i]; if(b->dev == dev && b->blockno == blockno){ b->refcnt++; - release(&bcache.lock); + release(&bcache.hashlocks[hash]); acquiresleep(&b->lock); return b; } } + release(&bcache.hashlocks[hash]); // Not cached. + acquire(&bcache.lock); for (int i = 0 ;i < NBUF;i++) { b = &bcache.buf[i]; if(b->refcnt == 0) { From 3cb5cc991328e21c394b39c6a86a1d65e12ca235 Mon Sep 17 00:00:00 2001 From: novice <619671969@qq.com> Date: Sun, 8 Sep 2024 21:27:19 +0800 Subject: [PATCH 7/7] I think there exist dead lock sometimes and I don't know how to fix it, I will return to this lab later after reading something about parallel programming :) --- .../clangd/index/bio.c.34489AC9E3FB27B2.idx | Bin 3462 -> 2942 bytes kernel/bio.c | 37 ++++++++++-------- kernel/kalloc.c | 8 ++-- 3 files changed, 25 insertions(+), 20 deletions(-) diff --git a/.cache/clangd/index/bio.c.34489AC9E3FB27B2.idx b/.cache/clangd/index/bio.c.34489AC9E3FB27B2.idx index 33c0aeff1a0dea7bd9dc3626c60847717280faa8..b514dbb3818d1b2abb0b671d7d8d29dcd6d527fe 100644 GIT binary patch literal 2942 zcmY*a3s6&68b0Te1a5K@k_$x)8HcLuF?z;SW*1oz}z?@Uh4cmH$# z$M-+3B{?a{E&*U=aq<>xiLFoo0PsP-YFkx#5CuTE5P&T$t(mEt?nKGk9zGRosqc@B zeAk&8UYj`cc5ZCwr^ZKq#ak=)UpYKFWL`2i{c=@b<;eP2SpMJggc}DY3y1zb@y-RW z(J*E1(F*%qtTUsj|KMAO%Aez3Nwka|{&sxll;sW2tF~T8&zku0;)j~XAARFKQl5G% zN;fF0xcKDjgBQxb)Esl{D%kn>Qtp|{b0M?+>$SJur)C3YKhy6C**2Zpv9nk9V#HeR|I}alT3W^A8!eN1i*+Jpk`@Ul^Ftb^LC8V z&E3_?4@>qo^ly*%`RZi-%Qt0S!lr>0>&q|up1Jp0j-kxi5tWv_ctwQq-=cr*OA~E; zHT^+xooUHp>l$tFvGJYJ5pOz2e>5#Fow5K2KwhkWA%oryF&d2nR zuX23wH2%ucxVe*mzG)L)hHumjF09^aEy{%e^n0}TT;Rr3ofwE5?d`Ci^cu_cTFOVNEBu!$noa<$5JdjYzA ztwQkj=;>e57_bL3mQm#Z|5f%JW z1PEC;W-J;ivN0eGiEBWOC{iU?%_|Q=xBYH^HPd8te9o%NOOl z5l#aX|33%VPI{+^w)frg7crbcWe9Nd$)%~&G(27Ed>*o^?HYGtI0sZapvKK5R|kFS zpc-SGU$OYPyfR#bPlTG7%VaZE#9W>#FMuE?WSvlj6*62sWb6635weX?g+pYxX2>@4 zaVun7p~}rD*ACfsf^i^-8drH?VkZA|y2hcJ9UEMpEB|V3}+IWXkyLeZSo1WVl3G zqJkJ-Nv~uGD)B7gxl%@#G1vu$v&n1%}TvEP&S>-yO-yk$Ghi*5+~%b zRu3iheB1~njZi@XZibR(K5m7QR>CTSI!w||u<*&6qO?ls?>!jqb^3J~ad#8FNk-CW z^|ZQ^>hpNgo;4QLj4Ib4Feoq=v9*@7)(>sRQNIP!feJiZ7*0!T6?ouc{gn8*dCYJX zq6&8n;lo1lb5j|mMX3wI=1^6zNxZpdR+)pbc80UC7Pk!ibbC?z)L;LILM)^TJ;|ZX zg3UCk%~~j^C57Y=ba^y1-XBKMq-s(ZkxRLBu6qLDWI31$|Vd50{Nh1WfKqCB3g9#Zv$0@tvnn)$ud4ykt1OJCTQP5+wJJVJvi zND-vuMIWk1AI4`7!zHVd0|?4eWw{YW{G SS}j-jNql|0{S5)0f#82?1Mlqs literal 3462 zcmY*b3sjTW9ltk(gfF>yl6-*#C?Fzy`4UK6r68sa54YCv3Wr)1MIJikwG|i?QQnGc z5G#Ssv)Q_JfKGIWTDpnSPG!iZo^{pZcB&pN>eSUaSX(AOPP-4fn|t}r$<6(J|Ns5p z|NH;BUtYPgQ2{_|$;)q4Y^o^~0{{YrUv*8@*55+_ek8nj=Dvl`Ze?I~I%*Jdg79 zxqq_je^UA8wY`fE>{xT^>(^KFH~#L8N>EIWE?;x7*k-$Mr1cl84iuf6K2b}IVevCN~)*~kYg-svj*@{w_g^KkNzW47JCCvn|ObjsM@`qt+8 zeQ;^p&dtR+Ox=6WJK>%eL|?tcJqd}j_mAzWyAfH}_*ZTH)=}NAiA?dAimO%T_v%Iu zeU;|fw`x)TpyRoxSBgitsgX}-?o1ATf3|zCqogS$?1hZYX`!Dzx%T9n7gJ_oTk2TZ z!&OZ3#7md{(`0@3LwAa0=fBjYoFcm??BVV!AJt|{b*016?jKZcIr+i2miz7DgV)9{ zKe&7%Vh|cDhHgE(Y8VZ>kn!32y|LxDLMp?q$V<;8em>%=KD|ZVP6s-~BmzQwyFQG$Tqy$UFfD2cIYvvar z!t>9t-@(BX1LIl*A_3q$5O|=N4^ju|0OJoqLM-T;n3!rXS0psTvAqaoJ#j&A( zw5k$;MFKe=EzpqG+tB27xGnTmxz(Jga7X!h>%8`BC2&hdUG? zOdv;yA_C?YtXe*!@puMqc$8qVpt(t5QqM1#d}Q{I2d~=;`Ve?dIGqHN#PbU#uU?V* z>xu*8GYCWr-zO zBf)J@-Ud|!w?lb5!5a7YBhjYo3K8PcCFxpnWv(RGhj5xf+5dA4yBVjKT(%&s5El~| zV<3h)v<{X?PGi%I1i4u^g&MRCEK#)sYC9l>JE67{vRE6$bwO&Xu`e-K`4rT|H>3g969w;a2(gXc_pd6>iWA)9zsl34)!Gd~Gy%O7hJ4<<|@qW&F zG2)W^lNfSuk}4^XpnOTbj98bi&evgt{{`#jS|YX%%NJhHwL<)Qf52G5wv>}Ka>SV! z6T)2&ap6oj!rdQn(M&YLZbMw6GEqZRNoJA}LF=UJD8)7~8xU3qaiz*q4Gse0YLqop z)_5TDKoxOTH&k{*4R%)Y_V=p-F8;Jx@QOp^puEx`YGANwi0g!+PRI};UMTWH1`EL* zKUB7$(+e4dVyKESi_8JURx@i3A&3|86pd$jie`~n)P&Pww1g96Ra&Xqic`hu3C$+9 z`SKTWcCnp84!MK!v{UA!644pyj3ItcQ>D=@TIQlSU6C$|)2(t-oDK2@Dhe%7*+Oa$ z3C]iZUnZBX0>WdyfFaXXDWpuB_b1)Wgd2{j}jT~OXdV=t6@NtBV$G3C7k<81Vk zEttKCvuG@oJ1r5GDC|!Er@2L$<%+lb5SPtlD~W#!nL;JW#A0c&FE0Zh->uEN9KT;E z#CUPM21{Dj;{I*L&ue}uyf!jM4IVXEqDZ!2;3ICMWTP+f!Tnp22k)IbC1|l)v|5VK zAg)4O!H^256W95Yw^=;k*ZcPLxX`&$OevA%NEVaj3+0jKoqezLx84+($|dDmBB@qV ztHn{N+V;aGp)2m*o|7a?Q4mR)Os20;2gY^3`6SdZ?T@%LNgBoEmbfX@0Yx3qr{mnj z6LrxA)(b_wq`=PBES*Zzn!XlpHfcnext = bcache.head.next; - //b->prev = &bcache.head; initsleeplock(&b->lock, "buffer"); - //bcache.head.next->prev = b; - //bcache.head.next = b; } } @@ -82,18 +80,22 @@ bget(uint dev, uint blockno) } release(&bcache.hashlocks[hash]); // Not cached. - acquire(&bcache.lock); for (int i = 0 ;i < NBUF;i++) { + acquire(&bcache.hashlocks[hash]); + acquire(&bcache.buflocks[i]); b = &bcache.buf[i]; if(b->refcnt == 0) { b->dev = dev; b->blockno = blockno; b->valid = 0; b->refcnt = 1; - release(&bcache.lock); + release(&bcache.buflocks[i]); + release(&bcache.hashlocks[hash]); acquiresleep(&b->lock); return b; } + release(&bcache.buflocks[i]); + release(&bcache.hashlocks[hash]); } panic("bget: no buffers"); } @@ -126,12 +128,13 @@ bwrite(struct buf *b) void brelse(struct buf *b) { + int hash = b->blockno % NHASH; if(!holdingsleep(&b->lock)) panic("brelse"); releasesleep(&b->lock); - acquire(&bcache.lock); + acquire(&bcache.hashlocks[hash]); b->refcnt--; //if (b->refcnt == 0) { // no one is waiting for it. @@ -143,21 +146,23 @@ brelse(struct buf *b) //bcache.head.next = b; //} - release(&bcache.lock); + release(&bcache.hashlocks[hash]); } void bpin(struct buf *b) { - acquire(&bcache.lock); + int hash = b->blockno % NHASH; + acquire(&bcache.hashlocks[hash]); b->refcnt++; - release(&bcache.lock); + release(&bcache.hashlocks[hash]); } void bunpin(struct buf *b) { - acquire(&bcache.lock); + int hash = b->blockno % NHASH; + acquire(&bcache.hashlocks[hash]); b->refcnt--; - release(&bcache.lock); + release(&bcache.hashlocks[hash]); } diff --git a/kernel/kalloc.c b/kernel/kalloc.c index f9d6f59..73a464b 100644 --- a/kernel/kalloc.c +++ b/kernel/kalloc.c @@ -52,6 +52,7 @@ void kfree(void *pa) { struct run *r; + push_off(); int i =cpuid(); if(((uint64)pa % PGSIZE) != 0 || (char*)pa < end || (uint64)pa >= PHYSTOP) @@ -66,6 +67,7 @@ kfree(void *pa) r->next = kmem[i].freelist; kmem[i].freelist = r; release(&kmem[i].lock); + pop_off(); } int kmem_borrow(struct run **r,int cpuid){ @@ -90,6 +92,7 @@ void * kalloc(void) { struct run *r; + push_off(); int i = cpuid(); acquire(&kmem[i].lock); @@ -103,9 +106,6 @@ kalloc(void) if(r) memset((char*)r, 5, PGSIZE); // fill with junk + pop_off(); return (void*)r; - - if(!r){ - // try to borrow free memory from other cpu. - } }