greg/xv6
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
xv6/Makefile

144 lines
3.4 KiB
Makefile
Raw Normal View History

tidy up
2006-07-16 15:35:18 +00:00
OBJS = \
console.o\
fd.o\
ide.o\
kalloc.o\
lapic.o\
better interrupt plan---this one appears to work ioapic
2006-08-04 18:12:31 +00:00
ioapic.o\
tidy up
2006-07-16 15:35:18 +00:00
main.o\
mp.o\
picirq.o\
pipe.o\
proc.o\
setjmp.o\
spinlock.o\
string.o\
syscall.o\
rm rm
2006-09-06 18:18:43 +00:00
sysfile.o\
sysproc.o\
tidy up
2006-07-16 15:35:18 +00:00
trapasm.o\
trap.o\
vectors.o\
bread iget mkfs makes a file system image put this in your .bochsrc: ata0-slave: type=disk, mode=flat, path="fs.img", cylinders=1024, heads=1, spt=1
2006-07-21 13:18:04 +00:00
bio.o\
fs.o\
import
2006-06-12 15:22:12 +00:00
Changes to allow use of native x86 ELF compilers, which on my Linux 2.4 box using gcc 3.4.6 don't seem to follow the same conventions as the i386-jos-elf-gcc compilers. Can run make 'TOOLPREFIX=' or edit the Makefile. curproc[cpu()] can now be NULL, indicating that no proc is running. This seemed safer to me than having curproc[0] and curproc[1] both pointing at proc[0] potentially. The old implementation of swtch depended on the stack frame layout used inside swtch being okay to return from on the other stack (exactly the V6 you are not expected to understand this). It also could be called in two contexts: at boot time, to schedule the very first process, and later, on behalf of a process, to sleep or schedule some other process. I split this into two functions: scheduler and swtch. The scheduler is now a separate never-returning function, invoked by each cpu once set up. The scheduler looks like: scheduler() { setjmp(cpu.context); pick proc to schedule blah blah blah longjmp(proc.context) } The new swtch is intended to be called only when curproc[cpu()] is not NULL, that is, only on behalf of a user proc. It does: swtch() { if(setjmp(proc.context) == 0) longjmp(cpu.context) } to save the current proc context and then jump over to the scheduler, running on the cpu stack. Similarly the system call stubs are now in assembly in usys.S to avoid needing to know the details of stack frame layout used by the compiler. Also various changes in the debugging prints.
2006-07-11 01:07:40 +00:00
# Cross-compiling (e.g., on Mac OS X)
TOOLPREFIX = i386-jos-elf-
# Using native tools (e.g., on X86 Linux)
# TOOLPREFIX =
CC = $(TOOLPREFIX)gcc
LD = $(TOOLPREFIX)ld
OBJCOPY = $(TOOLPREFIX)objcopy
OBJDUMP = $(TOOLPREFIX)objdump
cleaner
2006-07-17 01:51:47 +00:00
CFLAGS = -fno-builtin -O2 -Wall -MD
Changes to allow use of native x86 ELF compilers, which on my Linux 2.4 box using gcc 3.4.6 don't seem to follow the same conventions as the i386-jos-elf-gcc compilers. Can run make 'TOOLPREFIX=' or edit the Makefile. curproc[cpu()] can now be NULL, indicating that no proc is running. This seemed safer to me than having curproc[0] and curproc[1] both pointing at proc[0] potentially. The old implementation of swtch depended on the stack frame layout used inside swtch being okay to return from on the other stack (exactly the V6 you are not expected to understand this). It also could be called in two contexts: at boot time, to schedule the very first process, and later, on behalf of a process, to sleep or schedule some other process. I split this into two functions: scheduler and swtch. The scheduler is now a separate never-returning function, invoked by each cpu once set up. The scheduler looks like: scheduler() { setjmp(cpu.context); pick proc to schedule blah blah blah longjmp(proc.context) } The new swtch is intended to be called only when curproc[cpu()] is not NULL, that is, only on behalf of a user proc. It does: swtch() { if(setjmp(proc.context) == 0) longjmp(cpu.context) } to save the current proc context and then jump over to the scheduler, running on the cpu stack. Similarly the system call stubs are now in assembly in usys.S to avoid needing to know the details of stack frame layout used by the compiler. Also various changes in the debugging prints.
2006-07-11 01:07:40 +00:00
AS = $(TOOLPREFIX)gas
import
2006-06-12 15:22:12 +00:00
bread iget mkfs makes a file system image put this in your .bochsrc: ata0-slave: type=disk, mode=flat, path="fs.img", cylinders=1024, heads=1, spt=1
2006-07-21 13:18:04 +00:00
xv6.img : bootblock kernel fs.img
import
2006-06-12 15:22:12 +00:00
dd if=/dev/zero of=xv6.img count=10000
dd if=bootblock of=xv6.img conv=notrunc
dd if=kernel of=xv6.img seek=1 conv=notrunc
bootblock : bootasm.S bootmain.c
$(CC) -O -nostdinc -I. -c bootmain.c
$(CC) -nostdinc -I. -c bootasm.S
$(LD) -N -e start -Ttext 0x7C00 -o bootblock.o bootasm.o bootmain.o
$(OBJDUMP) -S bootblock.o > bootblock.asm
$(OBJCOPY) -S -O binary bootblock.o bootblock
./sign.pl bootblock
proc[0] can sleep(), at least after it gets to main00() proc[0] calls iget(rootdev, 1) before forking init
2006-08-16 01:56:00 +00:00
kernel : $(OBJS) bootother.S init
checkpoint. booting second processor. stack is messed up, but thanks to cliff and plan 9 code, at least boots and gets into C code.
2006-06-22 01:28:57 +00:00
$(CC) -nostdinc -I. -c bootother.S
$(LD) -N -e start -Ttext 0x7000 -o bootother.out bootother.o
$(OBJCOPY) -S -O binary bootother.out bootother
$(OBJDUMP) -S bootother.o > bootother.asm
proc[0] can sleep(), at least after it gets to main00() proc[0] calls iget(rootdev, 1) before forking init
2006-08-16 01:56:00 +00:00
$(LD) -Ttext 0x100000 -e main0 -o kernel $(OBJS) -b binary bootother init
import
2006-06-12 15:22:12 +00:00
$(OBJDUMP) -S kernel > kernel.asm
some text in readme generate postscript printout
2006-08-28 18:31:33 +00:00
tags: $(OBJS) bootother.S init
etags *.S *.c
better printout
2006-08-29 17:50:19 +00:00
PRINT = \
New formatting scripts. The use/defs extraction in runoff still needs some work for xv6 code style.
2006-09-05 15:50:55 +00:00
runoff.list \
better printout
2006-08-29 17:50:19 +00:00
README\
some text in readme generate postscript printout
2006-08-28 18:31:33 +00:00
types.h param.h defs.h x86.h asm.h elf.h mmu.h spinlock.h\
bootasm.S bootother.S main.c init.c spinlock.c\
proc.h proc.c setjmp.S kalloc.c\
syscall.h trapasm.S traps.h trap.c vectors.pl syscall.c\
buf.h dev.h fcntl.h stat.h fd.h fs.h fsvar.h fd.c fs.c bio.c ide.c\
pipe.c\
mp.h ioapic.h mp.c lapic.c ioapic.c picirq.c\
console.c\
string.c\
New formatting scripts. The use/defs extraction in runoff still needs some work for xv6 code style.
2006-09-05 15:50:55 +00:00
# make a printout
xv6.pdf : $(PRINT)
./runoff
print : xv6.pdf
some text in readme generate postscript printout
2006-08-28 18:31:33 +00:00
more or less take traps/interrupts
2006-06-13 15:50:06 +00:00
vectors.S : vectors.pl
perl vectors.pl > vectors.S
user-level malloc (untested) nit in sbrk indirect block fix dup to share fd struct
2006-08-24 02:44:41 +00:00
ULIB = ulib.o usys.o printf.o umalloc.o
Changes to allow use of native x86 ELF compilers, which on my Linux 2.4 box using gcc 3.4.6 don't seem to follow the same conventions as the i386-jos-elf-gcc compilers. Can run make 'TOOLPREFIX=' or edit the Makefile. curproc[cpu()] can now be NULL, indicating that no proc is running. This seemed safer to me than having curproc[0] and curproc[1] both pointing at proc[0] potentially. The old implementation of swtch depended on the stack frame layout used inside swtch being okay to return from on the other stack (exactly the V6 you are not expected to understand this). It also could be called in two contexts: at boot time, to schedule the very first process, and later, on behalf of a process, to sleep or schedule some other process. I split this into two functions: scheduler and swtch. The scheduler is now a separate never-returning function, invoked by each cpu once set up. The scheduler looks like: scheduler() { setjmp(cpu.context); pick proc to schedule blah blah blah longjmp(proc.context) } The new swtch is intended to be called only when curproc[cpu()] is not NULL, that is, only on behalf of a user proc. It does: swtch() { if(setjmp(proc.context) == 0) longjmp(cpu.context) } to save the current proc context and then jump over to the scheduler, running on the cpu stack. Similarly the system call stubs are now in assembly in usys.S to avoid needing to know the details of stack frame layout used by the compiler. Also various changes in the debugging prints.
2006-07-11 01:07:40 +00:00
tidy up
2006-07-16 15:35:18 +00:00
user1 : user1.o $(ULIB)
Changes to allow use of native x86 ELF compilers, which on my Linux 2.4 box using gcc 3.4.6 don't seem to follow the same conventions as the i386-jos-elf-gcc compilers. Can run make 'TOOLPREFIX=' or edit the Makefile. curproc[cpu()] can now be NULL, indicating that no proc is running. This seemed safer to me than having curproc[0] and curproc[1] both pointing at proc[0] potentially. The old implementation of swtch depended on the stack frame layout used inside swtch being okay to return from on the other stack (exactly the V6 you are not expected to understand this). It also could be called in two contexts: at boot time, to schedule the very first process, and later, on behalf of a process, to sleep or schedule some other process. I split this into two functions: scheduler and swtch. The scheduler is now a separate never-returning function, invoked by each cpu once set up. The scheduler looks like: scheduler() { setjmp(cpu.context); pick proc to schedule blah blah blah longjmp(proc.context) } The new swtch is intended to be called only when curproc[cpu()] is not NULL, that is, only on behalf of a user proc. It does: swtch() { if(setjmp(proc.context) == 0) longjmp(cpu.context) } to save the current proc context and then jump over to the scheduler, running on the cpu stack. Similarly the system call stubs are now in assembly in usys.S to avoid needing to know the details of stack frame layout used by the compiler. Also various changes in the debugging prints.
2006-07-11 01:07:40 +00:00
$(LD) -N -e main -Ttext 0 -o user1 user1.o $(ULIB)
system call arguments
2006-06-26 15:11:19 +00:00
$(OBJDUMP) -S user1 > user1.asm
compile "user programs" curproc array
2006-06-22 20:47:23 +00:00
tidy up
2006-07-16 15:35:18 +00:00
usertests : usertests.o $(ULIB)
Changes to allow use of native x86 ELF compilers, which on my Linux 2.4 box using gcc 3.4.6 don't seem to follow the same conventions as the i386-jos-elf-gcc compilers. Can run make 'TOOLPREFIX=' or edit the Makefile. curproc[cpu()] can now be NULL, indicating that no proc is running. This seemed safer to me than having curproc[0] and curproc[1] both pointing at proc[0] potentially. The old implementation of swtch depended on the stack frame layout used inside swtch being okay to return from on the other stack (exactly the V6 you are not expected to understand this). It also could be called in two contexts: at boot time, to schedule the very first process, and later, on behalf of a process, to sleep or schedule some other process. I split this into two functions: scheduler and swtch. The scheduler is now a separate never-returning function, invoked by each cpu once set up. The scheduler looks like: scheduler() { setjmp(cpu.context); pick proc to schedule blah blah blah longjmp(proc.context) } The new swtch is intended to be called only when curproc[cpu()] is not NULL, that is, only on behalf of a user proc. It does: swtch() { if(setjmp(proc.context) == 0) longjmp(cpu.context) } to save the current proc context and then jump over to the scheduler, running on the cpu stack. Similarly the system call stubs are now in assembly in usys.S to avoid needing to know the details of stack frame layout used by the compiler. Also various changes in the debugging prints.
2006-07-11 01:07:40 +00:00
$(LD) -N -e main -Ttext 0 -o usertests usertests.o $(ULIB)
file descriptors pipes
2006-06-27 14:35:53 +00:00
$(OBJDUMP) -S usertests > usertests.asm
no more proc[] entry per cpu for idle loop each cpu[] has its own gdt and tss no per-proc gdt or tss, re-write cpu's in scheduler (you win, cliff) main0() switches to cpu[0].mpstack
2006-08-15 22:18:20 +00:00
fstests : fstests.o $(ULIB)
$(LD) -N -e main -Ttext 0 -o fstests fstests.o $(ULIB)
$(OBJDUMP) -S fstests > fstests.asm
exec arguments
2006-07-28 22:33:07 +00:00
echo : echo.o $(ULIB)
$(LD) -N -e main -Ttext 0 -o echo echo.o $(ULIB)
$(OBJDUMP) -S echo > echo.asm
fix race in holding() check in acquire() give cpu1 a TSS and gdt for when it enters scheduler() and a pseudo proc[] entry for each cpu cpu0 waits for each other cpu to start up read() for files
2006-08-08 19:58:06 +00:00
cat : cat.o $(ULIB)
$(LD) -N -e main -Ttext 0 -o cat cat.o $(ULIB)
$(OBJDUMP) -S cat > cat.asm
tidy up
2006-07-16 15:35:18 +00:00
userfs : userfs.o $(ULIB)
Changes to allow use of native x86 ELF compilers, which on my Linux 2.4 box using gcc 3.4.6 don't seem to follow the same conventions as the i386-jos-elf-gcc compilers. Can run make 'TOOLPREFIX=' or edit the Makefile. curproc[cpu()] can now be NULL, indicating that no proc is running. This seemed safer to me than having curproc[0] and curproc[1] both pointing at proc[0] potentially. The old implementation of swtch depended on the stack frame layout used inside swtch being okay to return from on the other stack (exactly the V6 you are not expected to understand this). It also could be called in two contexts: at boot time, to schedule the very first process, and later, on behalf of a process, to sleep or schedule some other process. I split this into two functions: scheduler and swtch. The scheduler is now a separate never-returning function, invoked by each cpu once set up. The scheduler looks like: scheduler() { setjmp(cpu.context); pick proc to schedule blah blah blah longjmp(proc.context) } The new swtch is intended to be called only when curproc[cpu()] is not NULL, that is, only on behalf of a user proc. It does: swtch() { if(setjmp(proc.context) == 0) longjmp(cpu.context) } to save the current proc context and then jump over to the scheduler, running on the cpu stack. Similarly the system call stubs are now in assembly in usys.S to avoid needing to know the details of stack frame layout used by the compiler. Also various changes in the debugging prints.
2006-07-11 01:07:40 +00:00
$(LD) -N -e main -Ttext 0 -o userfs userfs.o $(ULIB)
disable all interrupts when acquiring lock user program that makes a blocking system call
2006-07-06 21:47:22 +00:00
$(OBJDUMP) -S userfs > userfs.asm
init creates console, opens 0/1/2, runs sh sh accepts 0-argument commands (like userfs) reads from console
2006-08-11 13:55:18 +00:00
init : init.o $(ULIB)
$(LD) -N -e main -Ttext 0 -o init init.o $(ULIB)
$(OBJDUMP) -S init > init.asm
sh : sh.o $(ULIB)
$(LD) -N -e main -Ttext 0 -o sh sh.o $(ULIB)
$(OBJDUMP) -S sh > sh.asm
fstat primitive ls
2006-08-12 04:33:50 +00:00
ls : ls.o $(ULIB)
$(LD) -N -e main -Ttext 0 -o ls ls.o $(ULIB)
$(OBJDUMP) -S ls > ls.asm
user-level programs: mkdir and rm shell parses arguments (very simplistic) readme version of README (sh doesn't deal with capital characters) printf recognizes %c nicer output format for ls
2006-08-14 21:22:13 +00:00
mkdir : mkdir.o $(ULIB)
$(LD) -N -e main -Ttext 0 -o mkdir mkdir.o $(ULIB)
$(OBJDUMP) -S mkdir > mkdir.asm
rm : rm.o $(ULIB)
$(LD) -N -e main -Ttext 0 -o rm rm.o $(ULIB)
$(OBJDUMP) -S rm > rm.asm
bread iget mkfs makes a file system image put this in your .bochsrc: ata0-slave: type=disk, mode=flat, path="fs.img", cylinders=1024, heads=1, spt=1
2006-07-21 13:18:04 +00:00
mkfs : mkfs.c fs.h
cc -o mkfs mkfs.c
nits
2006-09-06 01:25:41 +00:00
fs.img : mkfs userfs usertests echo cat README init sh ls mkdir rm fstests
./mkfs fs.img userfs usertests echo cat README init sh ls mkdir rm fstests
bread iget mkfs makes a file system image put this in your .bochsrc: ata0-slave: type=disk, mode=flat, path="fs.img", cylinders=1024, heads=1, spt=1
2006-07-21 13:18:04 +00:00
sleep, wakeup, wait, exit
2006-06-15 19:58:01 +00:00
-include *.d
import
2006-06-12 15:22:12 +00:00
clean :
rm rm
2006-09-06 18:18:43 +00:00
/bin/rm -f rm
index for printout some cleanup
2006-09-03 14:38:10 +00:00
rm -f *.ps *.tex *.dvi *.idx *.aux *.log *.ind *.ilg \
better printout
2006-08-29 17:50:19 +00:00
*.o *.d *.asm vectors.S parport.out \
bootblock kernel xv6.img user1 userfs usertests \
fs.img mkfs echo init fstests
Reference in a new issue Copy permalink