garentyler/xv6-riscv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove unnecessary "extern "C"" annotations

Browse Source
This commit is contained in:
Garen Tyler 2023-10-31 15:28:28 -06:00
parent ac33c19b5f
commit fa9daf279b
Signed by: garentyler
GPG Key ID: D7A048C454CB7054
15 changed files with 229 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
externs.txt Normal file
View File

@ -0,0 +1,89 @@
kernel/rustkernel/src/console/printf.rs:32:pub extern "C" fn printint(n: i32) {
kernel/rustkernel/src/console/printf.rs:37:pub extern "C" fn printhex(n: i32) {
kernel/rustkernel/src/console/printf.rs:42:pub extern "C" fn printptr(p: u64) {
kernel/rustkernel/src/console/printf.rs:47:pub unsafe extern "C" fn printstr(s: *const c_char) {
kernel/rustkernel/src/lib.rs:60:pub unsafe extern "C" fn main() -> ! {
kernel/rustkernel/src/lib.rs:126:pub unsafe extern "C" fn panic(_: *const c_char) -> ! {
kernel/rustkernel/src/string.rs:13:pub unsafe extern "C" fn strlen(s: *const c_char) -> i32 {
kernel/rustkernel/src/string.rs:18:pub unsafe extern "C" fn strncmp(mut a: *const u8, mut b: *const u8, mut max_chars: u32) -> i32 {
kernel/rustkernel/src/string.rs:32:pub unsafe extern "C" fn strncpy(
kernel/rustkernel/src/string.rs:56:pub unsafe extern "C" fn safestrcpy(
kernel/rustkernel/src/start.rs:17:pub unsafe extern "C" fn start() {
kernel/rustkernel/src/start.rs:57:pub unsafe extern "C" fn timerinit() {
kernel/rustkernel/src/fs/file.rs:142:pub unsafe extern "C" fn filealloc() -> *mut File {
kernel/rustkernel/src/fs/file.rs:157:pub unsafe extern "C" fn filedup(file: *mut File) -> *mut File {
kernel/rustkernel/src/fs/file.rs:173:pub unsafe extern "C" fn fileclose(file: *mut File) {
kernel/rustkernel/src/fs/file.rs:203:pub unsafe extern "C" fn filestat(file: *mut File, addr: u64) -> i32 {
kernel/rustkernel/src/fs/file.rs:233:pub unsafe extern "C" fn fileread(file: *mut File, addr: u64, n: i32) -> i32 {
kernel/rustkernel/src/fs/file.rs:266:pub unsafe extern "C" fn filewrite(file: *mut File, addr: u64, n: i32) -> i32 {
kernel/rustkernel/src/trap.rs:26:pub unsafe extern "C" fn trapinithart() {
kernel/rustkernel/src/trap.rs:31:pub unsafe extern "C" fn clockintr() {
kernel/rustkernel/src/trap.rs:44:pub unsafe extern "C" fn devintr() -> i32 {
kernel/rustkernel/src/trap.rs:129:pub unsafe extern "C" fn usertrapret() {
kernel/rustkernel/src/trap.rs:183:pub unsafe extern "C" fn kerneltrap() {
kernel/rustkernel/src/trap.rs:213:pub unsafe extern "C" fn usertrap() {
kernel/rustkernel/src/trap.rs:274:pub unsafe extern "C" fn push_intr_off() {
kernel/rustkernel/src/trap.rs:285:pub unsafe extern "C" fn pop_intr_off() {
kernel/rustkernel/src/io/pipe.rs:46:pub unsafe extern "C" fn pipealloc(a: *mut *mut File, b: *mut *mut File) -> i32 {
kernel/rustkernel/src/io/pipe.rs:78:pub unsafe extern "C" fn pipeclose(pipe: *mut Pipe, writable: i32) {
kernel/rustkernel/src/io/pipe.rs:95:pub unsafe extern "C" fn pipewrite(pipe: *mut Pipe, addr: u64, n: i32) -> i32 {
kernel/rustkernel/src/io/pipe.rs:124:pub unsafe extern "C" fn piperead(pipe: *mut Pipe, addr: u64, n: i32) -> i32 {
kernel/rustkernel/src/io/bio.rs:56:// pub unsafe extern "C" fn bget(dev: u32, blockno: u32) -> *mut Buffer {
kernel/rustkernel/src/io/bio.rs:93:// pub unsafe extern "C" fn bread(dev: u32, blockno: u32) -> *mut Buffer {
kernel/rustkernel/src/io/bio.rs:105:// pub unsafe extern "C" fn bwrite(b: *mut Buffer) {
kernel/rustkernel/src/io/bio.rs:115:// pub unsafe extern "C" fn bpin(b: *mut Buffer) {
kernel/rustkernel/src/io/bio.rs:122:// pub unsafe extern "C" fn bunpin(b: *mut Buffer) {
kernel/rustkernel/src/proc.rs:228:pub unsafe extern "C" fn cpuid() -> i32 {
kernel/rustkernel/src/proc.rs:235:pub unsafe extern "C" fn mycpu() -> *mut Cpu {
kernel/rustkernel/src/proc.rs:242:pub unsafe extern "C" fn myproc() -> *mut Proc {
kernel/rustkernel/src/proc.rs:249:pub unsafe extern "C" fn allocpid() -> i32 {
kernel/rustkernel/src/proc.rs:259:pub unsafe extern "C" fn freeproc(p: *mut Proc) {
kernel/rustkernel/src/proc.rs:281:pub unsafe extern "C" fn reparent(p: *mut Proc) {
kernel/rustkernel/src/proc.rs:293:pub unsafe extern "C" fn growproc(n: i32) -> i32 {
kernel/rustkernel/src/proc.rs:311:pub unsafe extern "C" fn r#yield() {
kernel/rustkernel/src/proc.rs:326:pub unsafe extern "C" fn sched() {
kernel/rustkernel/src/proc.rs:346:pub unsafe extern "C" fn sleep_lock(chan: *mut c_void, lock: *mut Spinlock) {
kernel/rustkernel/src/proc.rs:372:pub unsafe extern "C" fn kill(pid: i32) -> i32 {
kernel/rustkernel/src/proc.rs:391:pub unsafe extern "C" fn setkilled(p: *mut Proc) {
kernel/rustkernel/src/proc.rs:397:pub unsafe extern "C" fn killed(p: *mut Proc) -> i32 {
kernel/rustkernel/src/syscall.rs:185:pub unsafe extern "C" fn fetchaddr(addr: u64, ip: *mut u64) -> i32 {
kernel/rustkernel/src/syscall.rs:208:pub unsafe extern "C" fn fetchstr(addr: u64, buf: *mut u8, max: i32) -> i32 {
kernel/rustkernel/src/syscall.rs:218:pub unsafe extern "C" fn argraw(n: i32) -> u64 {
kernel/rustkernel/src/syscall.rs:233:pub unsafe extern "C" fn argint(n: i32, ip: *mut i32) {
kernel/rustkernel/src/syscall.rs:242:pub unsafe extern "C" fn argaddr(n: i32, ip: *mut u64) {
kernel/rustkernel/src/syscall.rs:251:pub unsafe extern "C" fn argstr(n: i32, buf: *mut u8, max: i32) -> i32 {
kernel/rustkernel/src/syscall.rs:258:pub unsafe extern "C" fn syscall() {
kernel/rustkernel/src/mem/kalloc.rs:36:pub unsafe extern "C" fn kinit() {
kernel/rustkernel/src/mem/kalloc.rs:42:pub unsafe extern "C" fn freerange(pa_start: *mut u8, pa_end: *mut u8) {
kernel/rustkernel/src/mem/kalloc.rs:56:pub unsafe extern "C" fn kfree(pa: *mut u8) {
kernel/rustkernel/src/mem/kalloc.rs:78:pub unsafe extern "C" fn kalloc() -> *mut u8 {
kernel/rustkernel/src/mem/virtual_memory.rs:108:pub unsafe extern "C" fn walk(
kernel/rustkernel/src/mem/virtual_memory.rs:150:pub unsafe extern "C" fn walkaddr(pagetable: Pagetable, virtual_addr: u64) -> u64 {
kernel/rustkernel/src/mem/virtual_memory.rs:168:pub unsafe extern "C" fn kvmmap(
kernel/rustkernel/src/mem/virtual_memory.rs:186:pub unsafe extern "C" fn mappages(
kernel/rustkernel/src/mem/virtual_memory.rs:228:pub unsafe extern "C" fn uvmunmap(
kernel/rustkernel/src/mem/virtual_memory.rs:260:pub unsafe extern "C" fn uvmcreate() -> Pagetable {
kernel/rustkernel/src/mem/virtual_memory.rs:273:pub unsafe extern "C" fn uvmfirst(pagetable: Pagetable, src: *mut u8, size: u32) {
kernel/rustkernel/src/mem/virtual_memory.rs:295:pub unsafe extern "C" fn uvmalloc(
kernel/rustkernel/src/mem/virtual_memory.rs:342:pub unsafe extern "C" fn uvmdealloc(pagetable: Pagetable, old_size: u64, new_size: u64) -> u64 {
kernel/rustkernel/src/mem/virtual_memory.rs:359:pub unsafe extern "C" fn freewalk(pagetable: Pagetable) {
kernel/rustkernel/src/mem/virtual_memory.rs:377:pub unsafe extern "C" fn uvmfree(pagetable: Pagetable, size: u64) {
kernel/rustkernel/src/mem/virtual_memory.rs:391:pub unsafe extern "C" fn uvmcopy(old: Pagetable, new: Pagetable, size: u64) -> i32 {
kernel/rustkernel/src/mem/virtual_memory.rs:429:pub unsafe extern "C" fn uvmclear(pagetable: Pagetable, virtual_addr: u64) {
kernel/rustkernel/src/mem/virtual_memory.rs:442:pub unsafe extern "C" fn copyout(
kernel/rustkernel/src/mem/virtual_memory.rs:477:pub unsafe extern "C" fn copyin(
kernel/rustkernel/src/mem/virtual_memory.rs:513:pub unsafe extern "C" fn copyinstr(
kernel/rustkernel/src/mem/mod.rs:5:pub unsafe extern "C" fn memset(dst: *mut u8, data: i32, max_bytes: u32) -> *mut u8 {
kernel/rustkernel/src/mem/mod.rs:13:pub unsafe extern "C" fn memcmp(mut a: *const u8, mut b: *const u8, max_bytes: u32) -> i32 {
kernel/rustkernel/src/mem/mod.rs:26:pub unsafe extern "C" fn memmove(mut dst: *mut u8, mut src: *const u8, max_bytes: u32) -> *mut u8 {
kernel/rustkernel/src/mem/mod.rs:54:pub unsafe extern "C" fn memcpy(dst: *mut u8, src: *const u8, max_bytes: u32) -> *mut u8 {
kernel/rustkernel/src/arch/riscv/plic.rs:9:pub unsafe extern "C" fn plicinit() {
kernel/rustkernel/src/arch/riscv/plic.rs:16:pub unsafe extern "C" fn plicinithart() {
kernel/rustkernel/src/arch/riscv/plic.rs:29:pub unsafe extern "C" fn plic_claim() -> i32 {
kernel/rustkernel/src/arch/riscv/plic.rs:36:pub unsafe extern "C" fn plic_complete(irq: i32) {
kernel/rustkernel/src/sync/sleeplock.rs:48:pub unsafe extern "C" fn initsleeplock(lock: *mut Sleeplock, _name: *mut c_char) {
kernel/rustkernel/src/sync/sleeplock.rs:53:pub unsafe extern "C" fn acquiresleep(lock: *mut Sleeplock) {
kernel/rustkernel/src/sync/sleeplock.rs:58:pub unsafe extern "C" fn releasesleep(lock: *mut Sleeplock) {
kernel/rustkernel/src/sync/spinlock.rs:70:pub unsafe extern "C" fn initlock(lock: *mut Spinlock, _name: *mut c_char) {
kernel/rustkernel/src/sync/spinlock.rs:75:pub unsafe extern "C" fn acquire(lock: *mut Spinlock) {
kernel/rustkernel/src/sync/spinlock.rs:80:pub unsafe extern "C" fn release(lock: *mut Spinlock) {

136
kernel/defs.h
View File

@ -17,139 +17,119 @@ struct superblock;
// bio.c // bio.c
void binit(void); void binit(void);
struct buf* bread(uint, uint); struct buf *bread(uint, uint);
void brelse(struct buf*); void brelse(struct buf *);
void bwrite(struct buf*); void bwrite(struct buf *);
void bpin(struct buf*); void bpin(struct buf *);
void bunpin(struct buf*); void bunpin(struct buf *);
// console.c
void consoleintr(int);
void consputc(int);
// exec.c // exec.c
int exec(char*, char**); int exec(char *, char **);
// file.c // file.c
struct file* filealloc(void); struct file *filealloc(void);
void fileclose(struct file*); void fileclose(struct file *);
struct file* filedup(struct file*); struct file *filedup(struct file *);
void fileinit(void); void fileinit(void);
int fileread(struct file*, uint64, int n); int fileread(struct file *, uint64, int n);
int filestat(struct file*, uint64 addr); int filestat(struct file *, uint64 addr);
int filewrite(struct file*, uint64, int n); int filewrite(struct file *, uint64, int n);
// fs.c // fs.c
void fsinit(int); void fsinit(int);
int dirlink(struct inode*, char*, uint); int dirlink(struct inode *, char *, uint);
struct inode* dirlookup(struct inode*, char*, uint*); struct inode *dirlookup(struct inode *, char *, uint *);
struct inode* ialloc(uint, short); struct inode *ialloc(uint, short);
struct inode* idup(struct inode*); struct inode *idup(struct inode *);
void iinit(); void iinit();
void ilock(struct inode*); void ilock(struct inode *);
void iput(struct inode*); void iput(struct inode *);
void iunlock(struct inode*); void iunlock(struct inode *);
void iunlockput(struct inode*); void iunlockput(struct inode *);
void iupdate(struct inode*); void iupdate(struct inode *);
int namecmp(const char*, const char*); int namecmp(const char *, const char *);
struct inode* namei(char*); struct inode *namei(char *);
struct inode* nameiparent(char*, char*); struct inode *nameiparent(char *, char *);
int readi(struct inode*, int, uint64, uint, uint); int readi(struct inode *, int, uint64, uint, uint);
void stati(struct inode*, struct stat*); void stati(struct inode *, struct stat *);
int writei(struct inode*, int, uint64, uint, uint); int writei(struct inode *, int, uint64, uint, uint);
void itrunc(struct inode*); void itrunc(struct inode *);
// ramdisk.c // ramdisk.c
void ramdiskinit(void); void ramdiskinit(void);
void ramdiskintr(void); void ramdiskintr(void);
void ramdiskrw(struct buf*); void ramdiskrw(struct buf *);
// kalloc.c // kalloc.c
void* kalloc(void); void *kalloc(void);
void kfree(void *); void kfree(void *);
void kinit(void);
// log.c // log.c
void initlog(int, struct superblock*); void initlog(int, struct superblock *);
void log_write(struct buf*); void log_write(struct buf *);
void begin_op(void); void begin_op(void);
void end_op(void); void end_op(void);
// pipe.c // pipe.c
int pipealloc(struct file**, struct file**); int pipealloc(struct file **, struct file **);
void pipeclose(struct pipe*, int);
int piperead(struct pipe*, uint64, int);
int pipewrite(struct pipe*, uint64, int);
// printf.c // printf.c
__attribute__((noreturn)) void panic(char *s); __attribute__((noreturn)) void panic(char *s);
void printstr(char *s); void printstr(char *s);
void printint(int n); void printint(int n);
void printhex(int n);
void printptr(uint64 p);
// proc.c // proc.c
int cpuid(void);
void exit(int); void exit(int);
int fork(void); int fork(void);
int growproc(int);
void proc_mapstacks(pagetable_t); void proc_mapstacks(pagetable_t);
pagetable_t proc_pagetable(struct proc *); pagetable_t proc_pagetable(struct proc *);
void proc_freepagetable(pagetable_t, uint64); void proc_freepagetable(pagetable_t, uint64);
int kill(int); int kill(int);
int killed(struct proc*); int killed(struct proc *);
void setkilled(struct proc*); void setkilled(struct proc *);
struct cpu* mycpu(void); struct cpu *mycpu(void);
struct cpu* getmycpu(void); struct proc *myproc();
struct proc* myproc();
void procinit(void); void procinit(void);
void scheduler(void) __attribute__((noreturn)); void scheduler(void) __attribute__((noreturn));
void sched(void); void sched(void);
void sleep_lock(void *, struct spinlock *); void sleep_lock(void *, struct spinlock *);
void userinit(void); void userinit(void);
int wait(uint64); int wait(uint64);
void wakeup(void*); void wakeup(void *);
void yield(void);
int either_copyout(int user_dst, uint64 dst, void *src, uint64 len); int either_copyout(int user_dst, uint64 dst, void *src, uint64 len);
int either_copyin(void *dst, int user_src, uint64 src, uint64 len); int either_copyin(void *dst, int user_src, uint64 src, uint64 len);
void procdump(void); void procdump(void);
// swtch.S // swtch.S
void swtch(struct context*, struct context*); void swtch(struct context *, struct context *);
// spinlock.rs // spinlock.rs
void acquire(struct spinlock *); void acquire(struct spinlock *);
void initlock(struct spinlock*, char*); void initlock(struct spinlock *, char *);
void release(struct spinlock*); void release(struct spinlock *);
void push_off(void);
void pop_off(void);
// sleeplock.c // sleeplock.c
void acquiresleep(struct sleeplock*); void acquiresleep(struct sleeplock *);
void releasesleep(struct sleeplock *); void releasesleep(struct sleeplock *);
void initsleeplock(struct sleeplock*, char*); void initsleeplock(struct sleeplock *, char *);
// string.c // string.c
int memcmp(const void*, const void*, uint); void *memmove(void *, const void *, uint);
void* memmove(void*, const void*, uint); void *memset(void *, int, uint);
void* memset(void*, int, uint); char *safestrcpy(char *, const char *, int);
char* safestrcpy(char*, const char*, int); int strlen(const char *);
int strlen(const char*); int strncmp(const char *, const char *, uint);
int strncmp(const char*, const char*, uint); char *strncpy(char *, const char *, int);
char* strncpy(char*, const char*, int);
// syscall.c // syscall.c
void argint(int, int*); void argint(int, int *);
int argstr(int, char*, int); int argstr(int, char *, int);
void argaddr(int, uint64 *); void argaddr(int, uint64 *);
int fetchstr(uint64, char*, int); int fetchstr(uint64, char *, int);
int fetchaddr(uint64, uint64*); int fetchaddr(uint64, uint64 *);
void syscall();
// trap.c // trap.c
void trapinithart(void);
void usertrapret(void); void usertrapret(void);
void uartintr(void);
// vm.c // vm.c
void kvmmap(pagetable_t, uint64, uint64, uint64, int); void kvmmap(pagetable_t, uint64, uint64, uint64, int);
@ -162,17 +142,9 @@ int uvmcopy(pagetable_t, pagetable_t, uint64);
void uvmfree(pagetable_t, uint64); void uvmfree(pagetable_t, uint64);
void uvmunmap(pagetable_t, uint64, uint64, int); void uvmunmap(pagetable_t, uint64, uint64, int);
void uvmclear(pagetable_t, uint64); void uvmclear(pagetable_t, uint64);
pte_t * walk(pagetable_t, uint64, int);
uint64 walkaddr(pagetable_t, uint64); uint64 walkaddr(pagetable_t, uint64);
int copyout(pagetable_t, uint64, char *, uint64); int copyout(pagetable_t, uint64, char *, uint64);
int copyin(pagetable_t, char *, uint64, uint64); int copyin(pagetable_t, char *, uint64, uint64);
int copyinstr(pagetable_t, char *, uint64, uint64);
// plic.c
void plicinit(void);
void plicinithart(void);
int plic_claim(void);
void plic_complete(int);
// virtio_disk.c // virtio_disk.c
void virtio_disk_init(void); void virtio_disk_init(void);
@ -180,4 +152,4 @@ void virtio_disk_rw(struct buf *, int);
void virtio_disk_intr(void); void virtio_disk_intr(void);
// number of elements in fixed-size array // number of elements in fixed-size array
#define NELEM(x) (sizeof(x)/sizeof((x)[0])) #define NELEM(x) (sizeof(x) / sizeof((x)[0]))

7
kernel/proc.c
View File

@ -187,10 +187,6 @@ userinit(void)
release(&p->lock); release(&p->lock);
} }
// Grow or shrink user memory by n bytes.
// Return 0 on success, -1 on failure.
int growproc(int n);
// Create a new process, copying the parent. // Create a new process, copying the parent.
// Sets up child kernel stack to return as if from fork() system call. // Sets up child kernel stack to return as if from fork() system call.
int int
@ -386,9 +382,6 @@ scheduler(void)
// there's no process. // there's no process.
void sched(void); void sched(void);
// Give up the CPU for one scheduling round.
void yield(void);
// A fork child's very first scheduling by scheduler() // A fork child's very first scheduling by scheduler()
// will swtch to forkret. // will swtch to forkret.
void void

1
kernel/proc.h
View File

@ -111,5 +111,4 @@ struct proc {
char name[16]; // Process name (debugging) char name[16]; // Process name (debugging)
}; };
int cpuid();
int allocpid(); int allocpid();

14
kernel/rustkernel/src/arch/riscv/plic.rs
View File

@ -1,19 +1,17 @@
//! The RISC-V Platform Level Interrupt Controller (PLIC) //! The RISC-V Platform Level Interrupt Controller (PLIC)
use crate::{ use crate::{
proc::cpuid,
arch::riscv::{plic_sclaim, plic_senable, plic_spriority, PLIC, UART0_IRQ, VIRTIO0_IRQ}, arch::riscv::{plic_sclaim, plic_senable, plic_spriority, PLIC, UART0_IRQ, VIRTIO0_IRQ},
proc::cpuid,
}; };
#[no_mangle] pub unsafe fn plicinit() {
pub unsafe extern "C" fn plicinit() {
// Set desired IRQ priorities non-zero (otherwise disabled). // Set desired IRQ priorities non-zero (otherwise disabled).
*((PLIC + UART0_IRQ as u64 * 4) as *mut u32) = 1; *((PLIC + UART0_IRQ as u64 * 4) as *mut u32) = 1;
*((PLIC + VIRTIO0_IRQ as u64 * 4) as *mut u32) = 1; *((PLIC + VIRTIO0_IRQ as u64 * 4) as *mut u32) = 1;
} }
#[no_mangle] pub unsafe fn plicinithart() {
pub unsafe extern "C" fn plicinithart() {
let hart = cpuid() as u64; let hart = cpuid() as u64;
// Set enable bits for this hart's S-mode // Set enable bits for this hart's S-mode
@ -25,15 +23,13 @@ pub unsafe extern "C" fn plicinithart() {
} }
/// Ask the PLIC what interrupt we should serve. /// Ask the PLIC what interrupt we should serve.
#[no_mangle] pub unsafe fn plic_claim() -> i32 {
pub unsafe extern "C" fn plic_claim() -> i32 {
let hart = cpuid() as u64; let hart = cpuid() as u64;
*(plic_sclaim(hart) as *const i32) *(plic_sclaim(hart) as *const i32)
} }
/// Tell the PLIC we've served this IRQ. /// Tell the PLIC we've served this IRQ.
#[no_mangle] pub unsafe fn plic_complete(irq: i32) {
pub unsafe extern "C" fn plic_complete(irq: i32) {
let hart = cpuid() as u64; let hart = cpuid() as u64;
*(plic_sclaim(hart) as *mut i32) = irq; *(plic_sclaim(hart) as *mut i32) = irq;
} }

10
kernel/rustkernel/src/console/printf.rs
View File

@ -33,16 +33,6 @@ pub extern "C" fn printint(n: i32) {
print!("{}", n); print!("{}", n);
} }
#[no_mangle]
pub extern "C" fn printhex(n: i32) {
print!("{:0x}", n);
}
#[no_mangle]
pub extern "C" fn printptr(p: u64) {
print!("{:#018x}", p);
}
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn printstr(s: *const c_char) { pub unsafe extern "C" fn printstr(s: *const c_char) {
let s = CStr::from_ptr(s).to_str().unwrap_or_default(); let s = CStr::from_ptr(s).to_str().unwrap_or_default();

16
kernel/rustkernel/src/io/pipe.rs
View File

@ -42,13 +42,6 @@ impl Default for Pipe {
} }
} }
extern "C" {
// pub fn pipealloc(a: *mut *mut File, b: *mut *mut File) -> i32;
// pub fn pipeclose(pipe: *mut Pipe, writable: i32);
// pub fn pipewrite(pipe: *mut Pipe, addr: u64, n: i32) -> i32;
// pub fn piperead(pipe: *mut Pipe, addr: u64, n: i32) -> i32;
}
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn pipealloc(a: *mut *mut File, b: *mut *mut File) -> i32 { pub unsafe extern "C" fn pipealloc(a: *mut *mut File, b: *mut *mut File) -> i32 {
*a = filealloc(); *a = filealloc();
@ -81,8 +74,7 @@ pub unsafe extern "C" fn pipealloc(a: *mut *mut File, b: *mut *mut File) -> i32
} }
} }
#[no_mangle] pub unsafe fn pipeclose(pipe: *mut Pipe, writable: i32) {
pub unsafe extern "C" fn pipeclose(pipe: *mut Pipe, writable: i32) {
let _guard = (*pipe).lock.lock(); let _guard = (*pipe).lock.lock();
if writable > 0 { if writable > 0 {
@ -98,8 +90,7 @@ pub unsafe extern "C" fn pipeclose(pipe: *mut Pipe, writable: i32) {
} }
} }
#[no_mangle] pub unsafe fn pipewrite(pipe: *mut Pipe, addr: u64, n: i32) -> i32 {
pub unsafe extern "C" fn pipewrite(pipe: *mut Pipe, addr: u64, n: i32) -> i32 {
let mut i = 0; let mut i = 0;
let p = myproc(); let p = myproc();
let lock = (*pipe).lock.lock(); let lock = (*pipe).lock.lock();
@ -126,9 +117,8 @@ pub unsafe extern "C" fn pipewrite(pipe: *mut Pipe, addr: u64, n: i32) -> i32 {
i i
} }
#[no_mangle]
#[allow(clippy::while_immutable_condition)] #[allow(clippy::while_immutable_condition)]
pub unsafe extern "C" fn piperead(pipe: *mut Pipe, addr: u64, n: i32) -> i32 { pub unsafe fn piperead(pipe: *mut Pipe, addr: u64, n: i32) -> i32 {
let mut i = 0; let mut i = 0;
let p = myproc(); let p = myproc();
let lock = (*pipe).lock.lock(); let lock = (*pipe).lock.lock();

27
kernel/rustkernel/src/lib.rs
View File

@ -8,18 +8,18 @@
extern crate alloc; extern crate alloc;
extern crate core; extern crate core;
pub mod console; mod arch;
pub mod fs; mod console;
pub mod io; mod fs;
pub mod mem; mod io;
pub mod proc; mod mem;
pub mod queue; mod proc;
pub(crate) mod arch; mod queue;
pub mod start; mod start;
pub mod string; mod string;
pub mod sync; mod sync;
pub mod syscall; mod syscall;
pub mod trap; mod trap;
use crate::{proc::cpuid, sync::mutex::Mutex}; use crate::{proc::cpuid, sync::mutex::Mutex};
use core::ffi::{c_char, CStr}; use core::ffi::{c_char, CStr};
@ -56,8 +56,7 @@ pub const FSSIZE: usize = 2000;
/// Maximum file path size /// Maximum file path size
pub const MAXPATH: usize = 128; pub const MAXPATH: usize = 128;
#[no_mangle] pub unsafe fn main() -> ! {
pub unsafe extern "C" fn main() -> ! {
if cpuid() == 0 { if cpuid() == 0 {
console::consoleinit(); console::consoleinit();
mem::kalloc::kinit(); mem::kalloc::kinit();

8
kernel/rustkernel/src/mem/kalloc.rs
View File

@ -3,8 +3,8 @@
//! and pipe buffers. Allocates whole 4096-byte pages. //! and pipe buffers. Allocates whole 4096-byte pages.
use crate::{ use crate::{
mem::memset,
arch::riscv::{memlayout::PHYSTOP, pg_round_up, PGSIZE}, arch::riscv::{memlayout::PHYSTOP, pg_round_up, PGSIZE},
mem::memset,
sync::spinlock::Spinlock, sync::spinlock::Spinlock,
}; };
use core::ptr::{addr_of_mut, null_mut}; use core::ptr::{addr_of_mut, null_mut};
@ -32,14 +32,12 @@ pub struct KernelMemory {
pub freelist: *mut Run, pub freelist: *mut Run,
} }
#[no_mangle] pub unsafe fn kinit() {
pub unsafe extern "C" fn kinit() {
kmem.lock = Spinlock::new(); kmem.lock = Spinlock::new();
freerange(addr_of_mut!(end).cast(), PHYSTOP as *mut u8) freerange(addr_of_mut!(end).cast(), PHYSTOP as *mut u8)
} }
#[no_mangle] unsafe fn freerange(pa_start: *mut u8, pa_end: *mut u8) {
pub unsafe extern "C" fn freerange(pa_start: *mut u8, pa_end: *mut u8) {
let mut p = pg_round_up(pa_start as usize as u64) as *mut u8; let mut p = pg_round_up(pa_start as usize as u64) as *mut u8;
while p.add(PGSIZE as usize) <= pa_end { while p.add(PGSIZE as usize) <= pa_end {

18
kernel/rustkernel/src/mem/virtual_memory.rs
View File

@ -1,13 +1,13 @@
use crate::{ use crate::{
arch::riscv::{
memlayout::{KERNBASE, PHYSTOP, TRAMPOLINE},
*,
},
mem::{ mem::{
kalloc::{kalloc, kfree}, kalloc::{kalloc, kfree},
memmove, memset, memmove, memset,
}, },
proc::proc_mapstacks, proc::proc_mapstacks,
arch::riscv::{
memlayout::{KERNBASE, PHYSTOP, TRAMPOLINE},
*,
},
}; };
use core::ptr::{addr_of, addr_of_mut, null_mut}; use core::ptr::{addr_of, addr_of_mut, null_mut};
@ -104,12 +104,7 @@ pub unsafe fn kvminithart() {
/// - 21..30: 9 bits of level 0 index. /// - 21..30: 9 bits of level 0 index.
/// - 30..39: 9 bits of level 0 index. /// - 30..39: 9 bits of level 0 index.
/// - 39..64: Must be zero. /// - 39..64: Must be zero.
#[no_mangle] pub unsafe fn walk(mut pagetable: Pagetable, virtual_addr: u64, alloc: i32) -> *mut PagetableEntry {
pub unsafe extern "C" fn walk(
mut pagetable: Pagetable,
virtual_addr: u64,
alloc: i32,
) -> *mut PagetableEntry {
if virtual_addr > MAXVA { if virtual_addr > MAXVA {
panic!("walk"); panic!("walk");
} }
@ -509,8 +504,7 @@ pub unsafe extern "C" fn copyin(
/// Copy bytes to `dst` from virtual address `src_virtual_addr` /// Copy bytes to `dst` from virtual address `src_virtual_addr`
/// in a given pagetable, until b'\0' or `max` is reached. /// in a given pagetable, until b'\0' or `max` is reached.
/// Returns 0 on success, -1 on error. /// Returns 0 on success, -1 on error.
#[no_mangle] pub unsafe fn copyinstr(
pub unsafe extern "C" fn copyinstr(
pagetable: Pagetable, pagetable: Pagetable,
mut dst: *mut u8, mut dst: *mut u8,
mut src_virtual_addr: u64, mut src_virtual_addr: u64,

11
kernel/rustkernel/src/proc.rs
View File

@ -1,8 +1,8 @@
#![allow(clippy::comparison_chain)] #![allow(clippy::comparison_chain)]
use crate::{ use crate::{
arch::riscv::{intr_get, r_tp, Pagetable, PTE_W},
mem::kalloc::kfree, mem::kalloc::kfree,
arch::riscv::{Pagetable, PTE_W, intr_get, r_tp},
sync::spinlock::{Spinlock, SpinlockGuard}, sync::spinlock::{Spinlock, SpinlockGuard},
}; };
use core::{ use core::{
@ -224,8 +224,7 @@ pub struct Proc {
/// Must be called with interrupts disabled /// Must be called with interrupts disabled
/// to prevent race with process being moved /// to prevent race with process being moved
/// to a different CPU. /// to a different CPU.
#[no_mangle] pub unsafe fn cpuid() -> i32 {
pub unsafe extern "C" fn cpuid() -> i32 {
r_tp() as i32 r_tp() as i32
} }
@ -289,8 +288,7 @@ pub unsafe extern "C" fn reparent(p: *mut Proc) {
/// Grow or shrink user memory by n bytes. /// Grow or shrink user memory by n bytes.
/// Return 0 on success, -1 on failure. /// Return 0 on success, -1 on failure.
#[no_mangle] pub unsafe fn growproc(n: i32) -> i32 {
pub unsafe extern "C" fn growproc(n: i32) -> i32 {
let p = myproc(); let p = myproc();
let mut sz = (*p).sz; let mut sz = (*p).sz;
@ -307,8 +305,7 @@ pub unsafe extern "C" fn growproc(n: i32) -> i32 {
} }
/// Give up the CPU for one scheduling round. /// Give up the CPU for one scheduling round.
#[no_mangle] pub unsafe fn r#yield() {
pub unsafe extern "C" fn r#yield() {
let p = myproc(); let p = myproc();
let _guard = (*p).lock.lock(); let _guard = (*p).lock.lock();
(*p).state = ProcState::Runnable; (*p).state = ProcState::Runnable;

5
kernel/rustkernel/src/start.rs
View File

@ -1,4 +1,4 @@
use crate::{main, arch::riscv::*, NCPU}; use crate::{arch::riscv::*, main, NCPU};
use core::{arch::asm, ptr::addr_of}; use core::{arch::asm, ptr::addr_of};
extern "C" { extern "C" {
@ -53,8 +53,7 @@ pub unsafe extern "C" fn start() {
/// at timervec in kernelvec.S, /// at timervec in kernelvec.S,
/// which turns them into software interrupts for /// which turns them into software interrupts for
/// devintr() in trap.c. /// devintr() in trap.c.
#[no_mangle] pub unsafe fn timerinit() {
pub unsafe extern "C" fn timerinit() {
// Each CPU has a separate source of timer interrupts. // Each CPU has a separate source of timer interrupts.
let id = r_mhartid(); let id = r_mhartid();

5
kernel/rustkernel/src/syscall.rs
View File

@ -1,8 +1,8 @@
use crate::{ use crate::{
arch::riscv::memlayout::QEMU_POWER,
mem::virtual_memory::{copyin, copyinstr}, mem::virtual_memory::{copyin, copyinstr},
println, println,
proc::{self, myproc}, proc::{self, myproc},
arch::riscv::memlayout::QEMU_POWER,
string::strlen, string::strlen,
trap::CLOCK_TICKS, trap::CLOCK_TICKS,
}; };
@ -254,8 +254,7 @@ pub unsafe extern "C" fn argstr(n: i32, buf: *mut u8, max: i32) -> i32 {
fetchstr(addr, buf, max) fetchstr(addr, buf, max)
} }
#[no_mangle] pub unsafe fn syscall() {
pub unsafe extern "C" fn syscall() {
let p = myproc(); let p = myproc();
let num = (*(*p).trapframe).a7; let num = (*(*p).trapframe).a7;

17
kernel/rustkernel/src/trap.rs
View File

@ -1,7 +1,7 @@
use crate::{ use crate::{
arch::riscv::*,
println, println,
proc::{cpuid, exit, killed, mycpu, myproc, r#yield, setkilled, wakeup, ProcState}, proc::{cpuid, exit, killed, mycpu, myproc, r#yield, setkilled, wakeup, ProcState},
arch::riscv::*,
sync::mutex::Mutex, sync::mutex::Mutex,
syscall::syscall, syscall::syscall,
}; };
@ -22,13 +22,11 @@ extern "C" {
pub static CLOCK_TICKS: Mutex<usize> = Mutex::new(0); pub static CLOCK_TICKS: Mutex<usize> = Mutex::new(0);
/// Set up to take exceptions and traps while in the kernel. /// Set up to take exceptions and traps while in the kernel.
#[no_mangle] pub unsafe fn trapinithart() {
pub unsafe extern "C" fn trapinithart() {
w_stvec(kernelvec as usize as u64); w_stvec(kernelvec as usize as u64);
} }
#[no_mangle] pub fn clockintr() {
pub unsafe extern "C" fn clockintr() {
let mut ticks = CLOCK_TICKS.lock_spinning(); let mut ticks = CLOCK_TICKS.lock_spinning();
*ticks += 1; *ticks += 1;
@ -40,8 +38,7 @@ pub unsafe extern "C" fn clockintr() {
/// Check if it's an external interrupt or software interrupt and handle it. /// Check if it's an external interrupt or software interrupt and handle it.
/// ///
/// Returns 2 if timer interrupt, 1 if other device, 0 if not recognized. /// Returns 2 if timer interrupt, 1 if other device, 0 if not recognized.
#[no_mangle] pub unsafe fn devintr() -> i32 {
pub unsafe extern "C" fn devintr() -> i32 {
let scause = r_scause(); let scause = r_scause();
if (scause & 0x8000000000000000 > 0) && (scause & 0xff) == 9 { if (scause & 0x8000000000000000 > 0) && (scause & 0xff) == 9 {
@ -270,8 +267,7 @@ pub unsafe extern "C" fn usertrap() {
// it takes two pop_intr_off()s to undo two push_intr_off()s. Also, if interrupts // it takes two pop_intr_off()s to undo two push_intr_off()s. Also, if interrupts
// are initially off, then push_intr_off, pop_intr_off leaves them off. // are initially off, then push_intr_off, pop_intr_off leaves them off.
#[no_mangle] pub unsafe fn push_intr_off() {
pub unsafe extern "C" fn push_intr_off() {
let old = intr_get(); let old = intr_get();
let cpu = mycpu(); let cpu = mycpu();
@ -281,8 +277,7 @@ pub unsafe extern "C" fn push_intr_off() {
} }
(*cpu).interrupt_disable_layers += 1; (*cpu).interrupt_disable_layers += 1;
} }
#[no_mangle] pub unsafe fn pop_intr_off() {
pub unsafe extern "C" fn pop_intr_off() {
let cpu = mycpu(); let cpu = mycpu();
if intr_get() == 1 { if intr_get() == 1 {