[운영체제]🦖공룡책🦕2장 - 운영체제 구조(3)

https://seung2344.tistory.com/112

[운영체제]🦖공룡책🦕2장 - 운영체제 구조(2)

 

• 운영체제에서 제공하는 서비스 학습
• 사용자 인터페이스 종류에 대해 학습
• 서비스를 제공하기 위한 시스템 콜의 종류에 대해 학습
• 링커와 로더에 대해 학습
• 운영체제 설계를 위한 모놀리식, 계층화, 마이크로 커널, 모듈 및 하이브리드 전략에 대해 학습
• 운영체제 성능을 모니터링 하기 위한 도구 학습

운영체제 성능 모니터링에 관련한 내용은 XV6를 사용한 간단한 실습을 통해 진행해 볼 예정이다. 

xv6는 MIT에서 개발된 UNIX 기반의 운영체제로 주로 교육 목적으로 사용된다. 

brew install qemu
brew install i686-elf-gcc
git clone https://github.com/mit-pdos/xv6-public.git
#Makefile 수정 한 다음 실행
make
make qemu

나는 mac m2칩을 사용하고 있는 상태인데 도커나 별도의 vm을 구성하고 돌리기 살짝 귀찮아서 gcc와 qemu 설치해서 에뮬레이터 위에서 돌아가게끔 Makefile을 수정한 후 진행하였다. 

Makefile 코드

OBJS = \
	bio.o \
	console.o \
	exec.o \
	file.o \
	fs.o \
	ide.o \
	ioapic.o \
	kalloc.o \
	kbd.o \
	lapic.o \
	log.o \
	main.o \
	mp.o \
	picirq.o \
	pipe.o \
	proc.o \
	sleeplock.o \
	spinlock.o \
	string.o \
	swtch.o \
	syscall.o \
	sysfile.o \
	sysproc.o \
	trapasm.o \
	trap.o \
	uart.o \
	vectors.o \
	vm.o \

# Cross-compiling (e.g., on Mac OS X)
TOOLPREFIX = i686-elf-

# Using native tools (e.g., on X86 Linux)
# TOOLPREFIX = 

# Try to infer the correct TOOLPREFIX if not set
ifndef TOOLPREFIX
TOOLPREFIX := $(shell if i386-jos-elf-objdump -i 2>&1 | grep '^elf32-i386$$' >/dev/null 2>&1; \
	then echo 'i386-jos-elf-'; \
	elif objdump -i 2>&1 | grep 'elf32-i386' >/dev/null 2>&1; \
	then echo ''; \
	else echo "***" 1>&2; \
		echo "*** Error: Couldn't find an i386-*-elf version of GCC/binutils." 1>&2; \
		echo "*** Is the directory with i386-jos-elf-gcc in your PATH?" 1>&2; \
		echo "*** If your i386-*-elf toolchain is installed with a command" 1>&2; \
		echo "*** prefix other than 'i386-jos-elf-', set your TOOLPREFIX" 1>&2; \
		echo "*** environment variable to that prefix and run 'make' again." 1>&2; \
		echo "*** To turn off this error, run 'gmake TOOLPREFIX= ...'." 1>&2; \
		echo "***" 1>&2; exit 1; fi)
endif

# If the makefile can't find QEMU, specify its path here
# QEMU = qemu-system-i386

# Try to infer the correct QEMU
ifndef QEMU
QEMU = $(shell if which qemu > /dev/null; \
	then echo qemu; exit; \
	elif which qemu-system-i386 > /dev/null; \
	then echo qemu-system-i386; exit; \
	elif which qemu-system-x86_64 > /dev/null; \
	then echo qemu-system-x86_64; exit; \
	else \
		qemu=/Applications/Q.app/Contents/MacOS/i386-softmmu.app/Contents/MacOS/i386-softmmu; \
		if test -x $$qemu; then echo $$qemu; exit; fi; fi; \
		echo "***" 1>&2; \
		echo "*** Error: Couldn't find a working QEMU executable." 1>&2; \
		echo "*** Is the directory containing the qemu binary in your PATH" 1>&2; \
		echo "*** or have you tried setting the QEMU variable in Makefile?" 1>&2; \
		echo "***" 1>&2; exit 1)
endif

CC = $(TOOLPREFIX)gcc
AS = $(TOOLPREFIX)gas
LD = $(TOOLPREFIX)ld
OBJCOPY = $(TOOLPREFIX)objcopy
OBJDUMP = $(TOOLPREFIX)objdump
CFLAGS = -fno-pic -static -fno-builtin -fno-strict-aliasing -O2 -MD -ggdb -fno-omit-frame-pointer
CFLAGS += $(shell $(CC) -fno-stack-protector -E -x c /dev/null >/dev/null 2>&1 && echo -fno-stack-protector)
ASFLAGS = -gdwarf-2 -Wa,-divide
# FreeBSD ld wants ``elf_i386_fbsd''
LDFLAGS += -m $(shell $(LD) -V | grep elf_i386 2>/dev/null | head -n 1)

# 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
endif
ifneq ($(shell $(CC) -dumpspecs 2>/dev/null | grep -e '[^f]nopie'),)
CFLAGS += -fno-pie -nopie
endif

xv6.img: bootblock kernel
	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

xv6memfs.img: bootblock kernelmemfs
	dd if=/dev/zero of=xv6memfs.img count=10000
	dd if=bootblock of=xv6memfs.img conv=notrunc
	dd if=kernelmemfs of=xv6memfs.img seek=1 conv=notrunc

bootblock: bootasm.S bootmain.c
	$(CC) $(CFLAGS) -fno-pic -O -nostdinc -I. -c bootmain.c
	$(CC) $(CFLAGS) -fno-pic -nostdinc -I. -c bootasm.S
	$(LD) $(LDFLAGS) -N -e start -Ttext 0x7C00 -o bootblock.o bootasm.o bootmain.o
	$(OBJDUMP) -S bootblock.o > bootblock.asm
	$(OBJCOPY) -S -O binary -j .text bootblock.o bootblock
	./sign.pl bootblock

entryother: entryother.S
	$(CC) $(CFLAGS) -fno-pic -nostdinc -I. -c entryother.S
	$(LD) $(LDFLAGS) -N -e start -Ttext 0x7000 -o bootblockother.o entryother.o
	$(OBJCOPY) -S -O binary -j .text bootblockother.o entryother
	$(OBJDUMP) -S bootblockother.o > entryother.asm

initcode: initcode.S
	$(CC) $(CFLAGS) -nostdinc -I. -c initcode.S
	$(LD) $(LDFLAGS) -N -e start -Ttext 0 -o initcode.out initcode.o
	$(OBJCOPY) -S -O binary initcode.out initcode
	$(OBJDUMP) -S initcode.o > initcode.asm

kernel: $(OBJS) entry.o entryother initcode kernel.ld
	$(LD) $(LDFLAGS) -T kernel.ld -o kernel entry.o $(OBJS) -b binary initcode entryother
	$(OBJDUMP) -S kernel > kernel.asm
	$(OBJDUMP) -t kernel | sed '1,/SYMBOL TABLE/d; s/ .* / /; /^$$/d' > kernel.sym

# kernelmemfs is a copy of kernel that maintains the
# disk image in memory instead of writing to a disk.
# This is not so useful for testing persistent storage or
# exploring disk buffering implementations, but it is
# great for testing the kernel on real hardware without
# needing a scratch disk.
MEMFSOBJS = $(filter-out ide.o,$(OBJS)) memide.o
kernelmemfs: $(MEMFSOBJS) entry.o entryother initcode kernel.ld fs.img
	$(LD) $(LDFLAGS) -T kernel.ld -o kernelmemfs entry.o $(MEMFSOBJS) -b binary initcode entryother fs.img
	$(OBJDUMP) -S kernelmemfs > kernelmemfs.asm
	$(OBJDUMP) -t kernelmemfs | sed '1,/SYMBOL TABLE/d; s/ .* / /; /^$$/d' > kernelmemfs.sym

tags: $(OBJS) entryother.S _init
	etags *.S *.c

vectors.S: vectors.pl
	./vectors.pl > vectors.S

ULIB = ulib.o usys.o printf.o umalloc.o

_%: %.o $(ULIB)
	$(LD) $(LDFLAGS) -N -e main -Ttext 0 -o $@ $^
	$(OBJDUMP) -S $@ > $*.asm
	$(OBJDUMP) -t $@ | sed '1,/SYMBOL TABLE/d; s/ .* / /; /^$$/d' > $*.sym

_forktest: forktest.o $(ULIB)
	# forktest has less library code linked in - needs to be small
	# in order to be able to max out the proc table.
	$(LD) $(LDFLAGS) -N -e main -Ttext 0 -o _forktest forktest.o ulib.o usys.o
	$(OBJDUMP) -S _forktest > forktest.asm

mkfs: mkfs.c fs.h
	gcc -o 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
# details:
# http://www.gnu.org/software/make/manual/html_node/Chained-Rules.html
.PRECIOUS: %.o

UPROGS = \
	_cat \
	_echo \
	_forktest \
	_grep \
	_init \
	_kill \
	_ln \
	_ls \
	_mkdir \
	_rm \
	_sh \
	_stressfs \
	_usertests \
	_wc \
	_zombie \


fs.img: mkfs README $(UPROGS)
	./mkfs fs.img README $(UPROGS)

-include *.d

clean: 
	rm -f *.tex *.dvi *.idx *.aux *.log *.ind *.ilg \
	*.o *.d *.asm *.sym vectors.S bootblock entryother \
	initcode initcode.out kernel xv6.img fs.img kernelmemfs \
	xv6memfs.img mkfs .gdbinit \
	$(UPROGS)

# make a printout
FILES = $(shell grep -v '^\#' runoff.list)
PRINT = runoff.list runoff.spec README toc.hdr toc.ftr $(FILES)

xv6.pdf: $(PRINT)
	./runoff
	ls -l xv6.pdf

print: xv6.pdf

# run in emulators

bochs: fs.img xv6.img
	if [ ! -e .bochsrc ]; then ln -s dot-bochsrc .bochsrc; fi
	bochs -q

# try to generate a unique GDB port
GDBPORT = $(shell expr `id -u` % 5000 + 25000)
# QEMU's gdb stub command line changed in 0.11
QEMUGDB = $(shell if $(QEMU) -help | grep -q '^-gdb'; \
	then echo "-gdb tcp::$(GDBPORT)"; \
	else echo "-s -p $(GDBPORT)"; fi)
ifndef CPUS
CPUS := 2
endif
QEMUOPTS = -drive file=fs.img,index=1,media=disk,format=raw -drive file=xv6.img,index=0,media=disk,format=raw -smp $(CPUS) -m 512 $(QEMUEXTRA)

qemu: fs.img xv6.img
	$(QEMU) -serial mon:stdio $(QEMUOPTS)

qemu-memfs: xv6memfs.img
	$(QEMU) -drive file=xv6memfs.img,index=0,media=disk,format=raw -smp $(CPUS) -m 256

qemu-nox: fs.img xv6.img
	$(QEMU) -nographic $(QEMUOPTS)

.gdbinit: .gdbinit.tmpl
	sed "s/localhost:1234/localhost:$(GDBPORT)/" < $^ > $@

qemu-gdb: fs.img xv6.img .gdbinit
	@echo "*** Now run 'gdb'." 1>&2
	$(QEMU) -serial mon:stdio $(QEMUOPTS) -S $(QEMUGDB)

qemu-nox-gdb: fs.img xv6.img .gdbinit
	@echo "*** Now run 'gdb'." 1>&2
	$(QEMU) -nographic $(QEMUOPTS) -S $(QEMUGDB)

# CUT HERE
# prepare dist for students
# after running make dist, probably want to
# rename it to rev0 or rev1 or so on and then
# check in that version.

EXTRA = \
	mkfs.c ulib.c user.h cat.c echo.c forktest.c grep.c kill.c \
	ln.c ls.c mkdir.c rm.c stressfs.c usertests.c wc.c zombie.c \
	printf.c umalloc.c \
	README dot-bochsrc *.pl toc.* runoff runoff1 runoff.list \
	.gdbinit.tmpl gdbutil \

dist:
	rm -rf dist
	mkdir dist
	for i in $(FILES); \
	do \
		grep -v PAGEBREAK $$i >dist/$$i; \
	done
	sed '/CUT HERE/,$$d' Makefile >dist/Makefile
	echo >dist/runoff.spec
	cp $(EXTRA) dist

dist-test:
	rm -rf dist
	make dist
	rm -rf dist-test
	mkdir dist-test
	cp dist/* dist-test
	cd dist-test; $(MAKE) print
	cd dist-test; $(MAKE) bochs || true
	cd dist-test; $(MAKE) qemu

# update this rule (change rev#) when it is time to
# make a new revision.
tar:
	rm -rf /tmp/xv6
	mkdir -p /tmp/xv6
	cp dist/* dist/.gdbinit.tmpl /tmp/xv6
	(cd /tmp; tar cf - xv6) | gzip >xv6-rev10.tar.gz  # the next one will be 10 (9/17)

.PHONY: dist-test dist

xv6에서 시스템 콜과 관련된 실습을 진행하기 위해 파악해두어야 할 파일들은 다음과 같다.

• user.h : xv6의 시스템 콜 정의하는 헤더 파일
• usys.S : xv6의 시스템 콜 리스트
• defs.h : 데이터 타입, 매크로, 상수, 함수 정의를 갖는 헤더 파일
• syscall.h : 시스템 콜 번호를 매핑하는 헤ㄷㄱ더 파일. 새로운 시스템 콜을 추가하려면 번호를 추가해야 함
• syscall.c : 시스템 콜 인수를 구문 분석하는 함수 및 실제 시스템 콜 구현에 대한 포인터
• sysproc.c : 프로세스 관련 시스템 호출 구현. fork(), exec(), wait(), exit() 와 같은 시스템 호출의 실제 로직이 있음. 새로운 프로세스 관련 시스템 호출을 추가할 때 여기에 코드를 작성해야 함
• proc.h : 프로세스에 대한 구조체인 struct proc의 정의가 포함된 헤더 파일. 프로세스의 상태, PID(프로세스 ID), 부모 프로세스, 스택 포인터 등 프로세스에 대한 추가 정보를 추적하는 데 사용됨
• proc.c : 프로세스 간의 스케줄링 및 컨텍스트 전환을 수행하는 함수가 구현된 파일.

---

성능 관찰 및 조정

시스템의 성능을 개선시키기 위해선 병목 지점을 제거하는 것이 필수적이다. 이러한 병목 지점을 발견하기 위한 방법으로는 counter와 tracing 두 가지 접근 방식이 대표적이다.

• Counter : 호출된 시스템 콜 횟수 또는 네트워크 장치 또는 디스크에 수행된 작업 수와 같은 시스템 활동을 추적 
• Tracing : 시스템 콜과 관련된 단계와 같은 특정 이벤트에 대한 데이터를 수집

---

getforkcount 실습

fork가 발생할 때, 과연 관련 시스템 콜이 정확히 발생하는 지 확인하기 위해 그 수를 세는 간단한 시스템 콜이다. 시스템 콜을 추가하는 전체적인 과정은 다음과 같다.

1. 전역 변수 선언: sysproc.c 혹은proc.c에 전역 변수를 선언
2. 시스템 콜 함수 구현: 시스템 콜에 대한 동작을 정의하는 함수를 sysproc.c에 작성
3. 시스템 콜 번호 할당: syscall.h에 새로운 시스템 콜 번호를 할당
4. 시스템 콜 테이블 등록: syscall.c 파일에 시스템 콜 테이블에 새로운 시스템 콜을 등록
5. 유저 인터페이스 추가: usys.S 파일에 시스템 콜을 유저 공간에서 호출할 수 있도록 선언
6. 유저 프로그램 추가 : user.h 파일에 유저 공간에서 사용할 함수의 선언부 작성

(user.h는 함수의 프로토 타입이며, 실제로는 usys.S에서 시스템콜과 커널의 연결이 이루어진다.)

// sysproc.c에 전역 변수 설정 후, sys_fork 함수에 로직 추가 
// fork_count 값을 반환하는 함수 추가
int fork_count = 0;
int
sys_fork(void)
{
  fork_count++;
  return fork();
}
int
sys_getforkcount(void)
{
    return fork_count; 
}


// syscall.h에 시스템 콜 추가
#define SYS_getforkcount  23


// syscall.c에서 시스템 콜 테이블에 등록
extern int sys_getforkcount(void);
...
[SYS_getforkcount] sys_getforkcount,


//usys.S에 ps 시스템 콜 정의
SYSCALL(getforkcount)


// user.h에 추가. 사용자 모드에서의 사용을 위함
int getforkcount(void);


//getforkcount.c에서 시스템 콜 호출
#include "types.h"
#include "user.h"

int
main(void)
{
    int count = getforkcount();
    printf(1,"Initial fork count: %d\n", count);

    // fork 호출
    if (fork() == 0) {
        // 자식 프로세스에서는 exit만 수행
        exit();
    }
    wait();  // 자식 프로세스가 종료될 때까지 대기

    count = getforkcount();
    printf(1,"Fork count after fork: %d\n", count);

    exit();
}


//Makefile에 ps 추가
UPROGS = \
	...
	_getforkcount	\
	

EXTRA = \
	mkfs.c ... getforkcount.c\

fork 발생 시에 counter가 동작해야 하기 때문에 기존에 이미 작성되어 있는 fork 시스템 콜 로직에 count값을 늘리는 코드를 추가하는 방식으로 진행하였다. 

getforkcount에는 fork를 1회 수행하게끔 코드를 작성해 둔 상태이다. getforkcount 명령어 사용을 통해 forkcount 수가 1 증가 됨을 확인 할 수 있으며, xv6에서 기본적으로 제공하는 forktest 이후 다시 시스템 콜 호출 시 forkcount 수가 더 증가한 것을 확인 할 수 있다.

 

---

trace 실습

시스템 콜이 발생하면 어떤 프로세스가 테스크를 할당받아 시스템 콜을 호출했는지 확인할 수 있는 시스템 콜이다. 시스템 콜을 추가하는 대략적인 과정은 counter 실습과 동일하게 진행된다.

// sysproc.c에 전역 변수 설정
// trace 기능을 제어하는 시스템 콜 추가
extern int tracing_enabled; // 0: tracing 비활성화, 1: tracing 활성화
int
sys_trace(void)
{
    int enable;
    if(argint(0, &enable) < 0)
        return -1;
    tracing_enabled = enable;
    return 0;
}


// syscall.h에 시스템 콜 추가
#define SYS_trace  24


// syscall.c에서 시스템 콜 테이블에 등록
// syscall을 수정하여 시스템 콜 발생 시, 콘솔에 출력하게끔 수정
int tracing_enabled = 0;  
extern int sys_trace(void);
...
[SYS_getforkcount] sys_trace,

void
syscall(void)
{
  int num;
  struct proc *curproc = myproc();

  num = curproc->tf->eax;
  if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
    if(tracing_enabled) {  // tracing이 활성화된 경우
      cprintf("   pname : %s   pid : %d   syscall : %d\n", curproc->name, curproc->pid, num);
    }
    curproc->tf->eax = syscalls[num]();
  } else {
    cprintf("%d %s: unknown sys call %d\n",
            curproc->pid, curproc->name, num);
    curproc->tf->eax = -1;
  }
}


//usys.S에 시스템 콜 정의
SYSCALL(trace)


// user.h에 추가. 사용자 모드에서의 사용을 위함
int trace(int enable);


//trace.c
#include "types.h"
#include "user.h"

int
main(int argc, char *argv[])
{
    if(argc != 2) {
        printf(2, "Usage: trace [0|1]\n");
        exit();
    }

    int enable = atoi(argv[1]);
    if(enable != 0 && enable != 1) {
        printf(2, "Invalid argument. Use 0 to disable or 1 to enable tracing.\n");
        exit();
    }

    // 시스템 콜을 통해 tracing 활성화 또는 비활성화
    trace(enable);

    if(enable)
        printf(1, "Tracing enabled\n");
    else
        printf(1, "Tracing disabled\n");

    exit();
}



//Makefile에 ps 추가
UPROGS = \
	...
	_trace \
	

EXTRA = \
	mkfs.c ... trace.c\

시스템 콜이 동작할 때마다 어떤 프로세스가 어떤 작업을 하는지 알기 위해서 기존에 작성되어있는 syscall 함수를 수정하는 방식으로 실습을 진행하였다. trace 1 입력을 통해 tracing을 시작하고 trace 0을 통해 tracing을 종료하게 된다.

실행 결과는 다음과 같다. 70번 프로세스가 trace를 위한 작업을 위해 할당되어 시스템 콜을 호출 중이며 trace 시작 시 Tracing enabled를 출력하기 위해 write 시스템 콜(16번)을 호출 하였으며 출력이 끝나자 exit 시스템 콜(2번)을 호출하여 종료하고 쉘을 위한 2번 프로세스에게 제어를 넘겼다. 2번 프로세스는 공백과 $ 문구 출력을 위해 16번 시스템 콜을 호출한 후 사용자에게 값을 입력받기 위해 read 시스템 콜(5번)을 호출하였다.

 

이후 getforkcount 시스템 콜을 불러보았다. 작성한 글자를 읽어들이기 위해 5번 시스템 콜이 글자수 만큼 호출되었으며, 이후 fork 시스템 콜(1번)을 호출하여 프로세스를 생성하고 대기 상태로 들어가(3번) 자식 프로세스(71번 프로세스)에게 제어를 넘겼다. 71번 프로세스는 메모리를 할당받고(12번) 활성화 상태(7번)로 들어갔다. 그 후 getforkcount 시스템 콜(23번)을 호출하고 그 결과를 출력하기 위해 write 시스템 콜을 반복하였다. 

 

해당 실습을 통해 프로세스가 시스템 콜을 호출하는 아주 대략적인 과정을 확인 할 수 있었고 예상대로 동작함을 확인할 수 있었다.