基于xv6的类Uinx操作系统实现

已于 2022-11-11 21:14:51 修改
阅读量700 收藏 4
点赞数 3
分类专栏： # 嵌入式系统开发 文章标签： linux
于 2022-11-04 16:29:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41945053/article/details/127691780
版权

总结

在这里插入图片描述

01 低级

1.1 添加简单程序

app.c

#include "types.h"
#include "stat.h"
#include "user.h"

int main(int argc, char *argv[]) {
    printf(1, "Hello World\n");
    exit();
}

UPROGS 中添加

image-20221011192416325

make 后生成

image-20221011192506673

运行结果

image-20221011192624816

1.2 系统调用示例

查看pid

image-20221011193106471

1.3 系统调用getcpuid（）

  • 编写 pcpuid.c 代码
  • 同样修改 Makefile，添加一行 pcpuid 即可， 系统启动以后直接输入 pcpuid 打印cpu号
  • 在 syscall.h 中添加一行系统调用号 22 号
  • 然后再增加用户态的进入接口，在 user.h 中添加一行 int getcpuid(void); （getcpuid函数在 pcpuid.c中调用了）
  • 在 usys.S 中加入一行 SYSCALL(getcpuid) 以定义用户态的入口。将系统调用号保存在eax寄存器中 触发软中断 int 0x40（int 64）进入内核的中断处理函数

=====================================================================================================================================================================内核与应用层分割线

  • 在 syscall.c 中的分发函数表中添加 getcpuid 函数所对应的表项 [SYS_getcpuid] sys_getcpuid （以eax及系统调用号 在 syscalls[]系统调用表中找到需要执行的代码）
  • 然后修改 syscall.c，添加一行 sys_getcpuid 函数的声明 extern int sys_getcpuid(void);
  • 然后开始实现 sys_getcpuid 函数。在 sysproc.c 中添加 sys_getcpuid 的实现
sys_getcpuid(void) {
  return getcpuid();
}
  • 在 proc.c 中实现内核态的 getcpuid 函数
int getcpuid() {
  return cpunum();
}
  • 最后在defs.h中加入 getcpuid 用作内核态代码调用 getcpuid()时的函数原型 （为了让sysproc.c中的sys_getcpuid()可以调用proc.c中的getcpuid()）

运行结果

image-20221012211425369

1.4 观察调度过程

#include "types.h"
#include "stat.h"
#include "user.h"

int main(int argc, char *argv[]) {
    printf(1, "Hello World\n");
    int a;
    a = fork();
    a = fork();
    while(1) {
        a++;
    } 
    exit();
}

实验结果：

image-20221012213415509

可以看出每次在不同的进程运行，说明时间片在轮转

image-20221012213717132

02 中级

2.1 调整时间片长度

运行结果

cprintf(“slice left:%d ticks,%d %s %s”, p->slot, p->pid, state, p->name);

输出4个参数 时间片剩余数 进程号 进程状态 进程名字

image-20221013224300917

2.2 信号量

spinlock.c

int sys_sem_create(void) {
    int n_sem, i;
    if(argint(0, &n_sem) < 0 )
        return -1;
    for(i = 0; i < SEM_MAX_NUM; i++) {
        acquire(&sems[i].lock);
        if(sems[i].allocated == 0) {
            sems[i].allocated = 1;
            sems[i].resource_count = n_sem;
            cprintf("create %d sem\n",i);
            release(&sems[i].lock);
            return i;
        }
        release(&sems[i].lock);
    }
    return -1;
 }


int sys_sem_free(){
    int id;    
    if(argint(0,&id)<0)        
      return -1;
    acquire(&sems[id].lock);    
    if(sems[id].allocated == 1 && sems[id].resource_count > 0){        
        sems[id].allocated = 0;        
        cprintf("free %d sem\n", id);    
    }    
    release(&sems[id].lock);
    return 0;
}

int sys_sem_p()
{       int id;
    if(argint(0, &id) < 0)
      return -1;
    acquire(&sems[id].lock);
    sems[id]. resource_count--;
    if(sems[id].resource_count<0)           //首次进入、或被唤醒时，资源不足
      sleep(&sems[id],&sems[id].lock);        //睡眠（会释放sems[id].lock才阻塞）
    release(&sems[id].lock);                                //解锁（唤醒到此处时，重新持有sems[id].lock）
    return 0;                                               //此时获得信号量资源
}

int sys_sem_v()
{       int id;
    if(argint(0,&id)<0)
      return -1;
    acquire(&sems[id].lock);
    sems[id]. resource_count+=1;            //增1
    if(sems[id].resource_count<1)                   //有阻塞等待该资源的进程
      wakeup1p(&sems[id]);                    //唤醒等待该资源的1个进程
    release(&sems[id].lock);                                //释放锁
    return 0;
}

sh_rw_lock.c文件

#include "types.h"
#include "stat.h"
#include "user.h"

int main(){
	int id=sem_create(1);
	int pid = fork();
	int i;
	for(i=0;i<100000;i++){
		sem_p(id);
		sh_var_write(sh_var_read()+1);
		sem_v(id);
	}
	if(pid >0){
		wait();
		sem_free(id);
	}
	printf(1,"sum=%d\n",sh_var_read());
	exit();
}

运行结果

image-20221020193157565

2.3 进程间通信

2.3.1 共享内存

sharemem.c

#include "types.h"
#include "defs.h"
#include "param.h"
#include "mmu.h"
#include "proc.h"
#include "spinlock.h"
#include "memlayout.h"
#define MAX_SHM_PGNUM (4) 	//每个共享内存最带4页内存

struct sharemem
{
    int refcount;     		//当前共享内存引用数，当引用数为0时才会真正回收
    int pagenum;		//占用的页数（0-4）
    void* physaddr[MAX_SHM_PGNUM];   		//对应每页的物理地址
};
struct spinlock shmlock;    			//用于互斥访问的锁
struct sharemem shmtab[8];  			//整个系统最多8个共享内存

void
sharememinit()
{
    initlock(&shmlock,"shmlock");   //初始化锁
    for (int i = 0; i < 8; i++)     //初始化shmtab
    {
        shmtab[i].refcount = 0;
    }
    
    cprintf("shm init finished.\n");
}

int
shmkeyused(uint key, uint mask)
{
    if(key<0 || 8<=key){
        return 0;
    }
    return (mask >> key) & 0x1;  //这里判断对应的系统共享内存区是否已经启用
}


int
shmrm(int key)
{
    if(key<0||8<=key){
        return -1;
    }
    //cprintf("shmrm: key is %d\n",key);
    struct sharemem* shmem = &shmtab[key];
    for(int i=0;i<shmem->pagenum;i++){
        kfree((char*)P2V(shmem->physaddr[i]));   		//逐个页帧回收
    }
    shmem->refcount = 0;
    return 0;
}


int
shmadd(uint key, uint pagenum, void* physaddr[MAX_SHM_PGNUM])
{
    if(key<0 || 8<=key || pagenum<0 || MAX_SHM_PGNUM < pagenum){
        return -1;
    }
    shmtab[key].refcount = 1;
    shmtab[key].pagenum = pagenum;
    for(int i = 0;i<pagenum;++i){
        shmtab[key].physaddr[i] = physaddr[i];
    }
    return 0;
}

int
mapshm(pde_t *pgdir, uint oldshm, uint newshm, uint sz, void **physaddr)
{
    uint a;
    if(oldshm & 0xFFF || newshm & 0xFFF || oldshm > KERNBASE || newshm < sz)
        return 0;  												//验证参数
    a=newshm;
    for (int i = 0;a<oldshm;a+=PGSIZE, i++) 					//逐页映射
    {
        mappages(pgdir,(char*)a,PGSIZE,(uint)physaddr[i],PTE_W|PTE_U);
    }
    return newshm;
}

int
deallocshm(pde_t *pgdir, uint oldshm, uint newshm)
{
	pte_t *pte;
	uint a, pa;
	if(newshm <= oldshm)
		return oldshm;
	a = (uint)PGROUNDDOWN(newshm - PGSIZE);
	for (; oldshm <= a; a-=PGSIZE)
	{
		pte = walkpgdir(pgdir,(char*)a,0);
		if(pte && (*pte & PTE_P)!=0){
			pa = PTE_ADDR(*pte);
		if(pa == 0){
			panic("kfree");
		}
		*pte = 0;
		}
	}
	return newshm;
}

// 这个方法和allcouvm实现基本一样
int
allocshm(pde_t *pgdir, uint oldshm, uint newshm, uint sz,void *phyaddr[MAX_SHM_PGNUM])
{
    char *mem;
    uint a;
    
    if(oldshm & 0xFFF || newshm & 0xFFF || oldshm > KERNBASE || newshm < sz)
        return 0;
    a = newshm;
    for (int i = 0; a < oldshm; a+=PGSIZE, i++)
    {
        mem = kalloc(); 		//分配物理页帧
        if(mem == 0){
            // cprintf("allocshm out of memory\n");
            deallocshm(pgdir,newshm,oldshm);
            return 0;
        }
        memset(mem,0,PGSIZE);
        mappages(pgdir,(char*)a,PGSIZE,(uint)V2P(mem),PTE_W|PTE_U);	//页表映射
        phyaddr[i] = (void *)V2P(mem);
        // cprintf("allocshm : %x\n",a);
    }
    return newshm;
}


void*
shmgetat(uint key, uint num)
{
    pde_t *pgdir;
    void *phyaddr[MAX_SHM_PGNUM];
    uint shm =0;
    if(key<0||8<=key||num<0||MAX_SHM_PGNUM<num) 	//校验参数
        return (void*)-1;
    acquire(&shmlock);
    pgdir = proc->pgdir;
shm = proc->shm;

// 情况1.如果当前进程已经映射了该key的共享内存，直接返回地址
    if(proc->shmkeymask>>key & 1){ 
        release(&shmlock);
        return proc->shmva[key];
}

// 情况2.如果系统还未创建此key对应的共享内存，则分配内存并映射
    if(shmtab[key].refcount == 0){
        shm = allocshm(pgdir, shm, shm - num * PGSIZE, proc->sz, phyaddr); 
//新增的allocshm()分配内存并映射，其原理和allcouvm()相同
        if(shm == 0){
            release(&shmlock);
            return (void*)-1;
        }
        proc->shmva[key] = (void*)shm;
        shmadd(key, num, phyaddr);	//将新内存区信息填入shmtab[8]数组
    }else { 

//情况3.如果未持有且已经系统中分配此key对应的共享内存，则直接映射
        for(int i = 0;i<num;i++)
        {
            phyaddr[i] = shmtab[key].physaddr[i];
        }
        num = shmtab[key].pagenum;
		//mapshm方法新建映射
        if((shm = mapshm(pgdir,shm,shm-num*PGSIZE,proc->sz,phyaddr))==0){
            release(&shmlock);
            return (void*)-1;
        }
        proc->shmva[key] = (void*)shm;
        shmtab[key].refcount++;			//引用计数+1
    }
    proc->shm = shm;
    proc->shmkeymask |= 1<<key;
    release(&shmlock);
    return (void*)shm;
}

void
shmaddcount(uint mask)
{
	acquire(&shmlock);
	for (int key = 0; key < 8; key++)
	{
	if(shmkeyused(key,mask)){   //对目前进程所有引用的共享内存的引用数加1
		shmtab[key].refcount++;   
		}
	}
	release(&shmlock);
}

int
shmrelease(pde_t *pgdir, uint shm, uint keymask)
{
    //cprintf("shmrelease: shm is %x, keymask is %x.\n",shm, keymask);
    acquire(&shmlock);
    deallocshm(pgdir,shm,KERNBASE); 				//释放用户空间的内存
    for (int k = 0; k < 8; k++)
    {
        if(shmkeyused(k,keymask)){
            shmtab[k].refcount--;   				//引用数目减1
            if(shmtab[k].refcount==0){  			//若为0 ，即可以回收物理内存
                shmrm(k);    
            }
        }
    }
    release(&shmlock);
    return 0;
}

int
shmrefcount(uint key)
{
    acquire(&shmlock);
    int count;
    count = (key<0||8<=key)? -1:shmtab[key].refcount;
    release(&shmlock);
    return count;
}

test.c

#include "types.h"
#include "stat.h"
#include "user.h"
#include "fs.h"
int main(void)
{
  char *shm;
  int pid = fork();
  if(pid == 0){
    sleep(1);
    shm = (char*)shmgetat(1,3);//key为1，大小为3页的共享内存
    printf(1,"child  process pid:%d shm is %s refcount of 1 is:%d\n", getpid(), shm, shmrefcount(1));
    strcpy(shm, "hello_world!");
    printf(1, "child  process pid:%d write %s into the shm\n", getpid(), shm);
  } else if (pid > 0) {
    shm = (char*)shmgetat(1,3);
    printf(1,"parent process pid:%d before wait() shm is %s refcount of 1 is:%d\n", getpid(), shm, shmrefcount(1));
    strcpy(shm, "share_memory!");
    printf(1,"parent process pid:%d write  %s into the shm\n", getpid(), shm);
    wait();
    printf(1,"parent process pid:%d after wait() shm is %s refcount of 1 is:%d\n", getpid(), shm, shmrefcount(1));
  }
  exit();
}

image-20221020202119861

2.3.2 消息队列

messagequeue.c

#include "types.h"
#include "defs.h"
#include "param.h"
#include "mmu.h"
#include "proc.h"
#include "spinlock.h"

struct msg {
    struct msg *next;
    long type;
    char *dataaddr;
    int  datasize;
};

struct mq {
    int key;
    int status;
    struct msg *msgs;
    int maxbytes;
    int curbytes;
    int refcount;
};

struct spinlock mqlock;
struct mq mqs[MQMAX];
struct proc* wqueue[NPROC];
int wstart=0;

struct proc* rqueue[NPROC];
int rstart=0;

void
mqinit()
{
    cprintf("mqinit.\n");
    initlock(&mqlock,"mqlock");
    for(int i =0;i<MQMAX;++i){
        mqs[i].status = 0;
    }
}

int findkey(int key)
{
    int idx =-1;
    for(int i = 0;i<MQMAX;++i){
        if(mqs[i].status != 0 && mqs[i].key == key){
            idx = i;
            break;
        }
    }
    return idx;
}

int newmq(int key)
{
    int idx =-1;
    for(int i=0;i<MQMAX;++i){
        if(mqs[i].status == 0){
            idx = i;
            break;
        }
    }
    if(idx == -1){
        cprintf("newmq failed: can not get idx.\n");
        return -1;
    }
    mqs[idx].key = key;
    mqs[idx].status = 1;
    mqs[idx].msgs = (struct msg*)kalloc();
    if(mqs[idx].msgs == 0){
        cprintf("newmq failed: can not alloc page.\n");
        return -1;
    }
    memset(mqs[idx].msgs,0,PGSIZE);
    mqs[idx].msgs -> next = 0;
    mqs[idx].msgs -> datasize = 0;
    mqs[idx].maxbytes = PGSIZE;
    mqs[idx].curbytes = 16;
    mqs[idx].refcount = 1;
    proc->mqmask |= 1 << idx;
    return idx;

}

int
mqget(uint key)
{
    acquire(&mqlock);
    int idx = findkey(key);
    if(idx != -1){
        if(!(proc->mqmask >> idx & 1)){
            proc->mqmask |= 1 << idx;
            mqs[idx].refcount++;
        }
        release(&mqlock);
        return idx;
    }
    idx = newmq(key);
    release(&mqlock);
    return idx;
}
int
msgsnd(uint mqid, void* msg, int sz)
{
    if(mqid<0 || MQMAX<=mqid || mqs[mqid].status == 0){
        return -1;
    }

    char *data = (char *)(*((int *) (msg + 4)));
    int  *type = (int *)msg;

    if(mqs[mqid].msgs == 0){
        cprintf("msgsnd failed: msgs == 0.\n");
        return -1;
    }

    acquire(&mqlock);

    while(1){
        if(mqs[mqid].curbytes + sz + 16 <= mqs[mqid].maxbytes){
            struct msg *m = mqs[mqid].msgs;
            while(m->next != 0){
                m = m -> next;
            }
            m->next = (void *)m + m->datasize + 16;
            m = m -> next;
            m->type = *(type);
            m->next = 0;
            m->dataaddr = (void*)m + 16;
            m->datasize = sz;
            memmove(m->dataaddr, data, sz);
            mqs[mqid].curbytes += (sz+16);

            for(int i=0; i<rstart; i++)
            {
                wakeup(rqueue[i]);
            }
            rstart = 0;

            release(&mqlock);
            return 0;
        } else {
            cprintf("msgsnd: can not alloc: pthread: %d sleep.\n",proc->pid);
            wqueue[wstart++] = proc;

            sleep(proc,&mqlock);
        }
        
    }

    return -1;
}



int reloc(int mqid)
{
    struct msg *pages = mqs[mqid].msgs;
    struct msg *m  = pages;
    struct msg *t;
    struct msg *pre = pages;
    while (m != 0)
    {
        t = m->next;
        memmove(pages, m, m->datasize+16);
        pages->next = (struct msg *)((char *)pages + pages->datasize + 16);
        pages->dataaddr = ((char *)pages + 16);
        pre = pages;
        pages = pages->next;
        m = t;
    }
    pre->next = 0;
    return 0;
}



int
msgrcv(uint mqid, void* msg, int sz)
{
    if(mqid<0 || MQMAX<=mqid || mqs[mqid].status ==0){
        return -1;
    }
    int *type = msg;
    int *data = msg + 4;
    acquire(&mqlock);
    
    while(1){
        struct msg *m = mqs[mqid].msgs->next;
        struct msg *pre = mqs[mqid].msgs;
        while (m != 0)
        {
            if(m->type == *type){
                memmove((char *)*data, m->dataaddr, sz);
                pre->next = m->next;
                mqs[mqid].curbytes -= (m->datasize + 16);
                reloc(mqid);

                for(int i=0; i<wstart; i++)
                {
                    wakeup(wqueue[i]);
                }
                wstart = 0;

                release(&mqlock);
                return 0;
            }
            pre = m;
            m = m->next;
        }
        cprintf("msgrcv: can not read: pthread: %d sleep.\n",proc->pid);
        rqueue[rstart++] = proc;
        sleep(proc,&mqlock);
    }
    return -1;
}

void
rmmq(int mqid)
{
    kfree((char *)mqs[mqid].msgs);
    mqs[mqid].status = 0;
}

void
releasemq2(int mask)
{
    acquire(&mqlock);
    for(int id = 0;id<MQMAX;++id){
        if( mask >> id & 0x1){
            mqs[id].refcount--;
            if(mqs[id].refcount == 0){
                rmmq(id);
            }
        }
    }
    release(&mqlock);
}


void
releasemq(uint key)
{
    //cprintf("releasemq: %d.\n",key);
  int idx= findkey(key);
  if (idx!=-1){
      acquire(&mqlock);
          mqs[idx].refcount--;   //引用数目减1
            if(mqs[idx].refcount == 0)  //引用数目为0时候需要回收物理内存
                rmmq(idx);
       release(&mqlock);
     }
}



void
addmqcount(uint mask)
{
    acquire(&mqlock);
    for (int key = 0; key < MQMAX; key++)
    {
        if(mask >> key & 1){
            mqs[key].refcount++;
        }
    }
    release(&mqlock);
}

msg_test.c

#include "param.h"
#include "types.h"
#include "stat.h"
#include "user.h"
#include "fs.h"
#include "fcntl.h"
#include "syscall.h"
#include "traps.h"
#include "memlayout.h"


struct msg{
  int type;
  char *dataaddr;
}s1,s2,g;

void msg_test()
{
  int mqid = mqget(123);
  // int msg_len = 48;
  // s1.dataaddr = "total number:47 : hello, this is child process.";
  int pid = fork();
  if(pid == 0){
    s1.type = 1;
    s1.dataaddr = "This is the first message!";
    msgsnd(mqid, &s1, 27);
    s1.type = 2;
    s1.dataaddr = "Hello, another message comes!";
    msgsnd(mqid, &s1, 30);
    s1.type = 3;
    s1.dataaddr = "This is the third message, and this message has great many characters!";
    msgsnd(mqid, &s1, 70);
    // sleep(10);
    // for(int i=0; i<70; i++)
    // {
    //   s1.type = i;
    //   msgsnd(mqid, &s1, msg_len);
    // }
    printf(1,"all messages have been sent.\n");
  } else if (pid >0)
  {
    // sleep(10);     // sleep保证子进程消息写入
    // g.dataaddr = malloc(msg_len);
    // for(int i=0; i<70; i++)
    // {
    //   g.type = i;
    //   msgrcv(mqid, &g, msg_len);
    //   printf(1, "读取第%d个消息： %s\n", i, g.dataaddr);

    // }
    sleep(10);      // sleep保证子进程消息写入
    g.dataaddr = malloc(70);
    g.type = 2;
    msgrcv(mqid,&g, 30);
    printf(1, "receive the %dth message: %s\n", 2, g.dataaddr);
    g.type = 1;
    msgrcv(mqid,&g, 27);
    printf(1, "receive the %dth message: %s\n", 1, g.dataaddr);
    g.type = 3;
    msgrcv(mqid,&g, 70);
    printf(1, "receive the %dth message: %s\n", 3, g.dataaddr);

    wait();

  }
  exit();
}


int
main(int argc, char *argv[])
{
  // printf(1, "消息队列测试\n");
  msg_test();
  exit();
}

运行结果

image-20221021200348259

2.4 内存管理

2.4.1 实现myfree（）和myalloc（）系统调用\

myalloc.c

#include "types.h"
#include "stat.h"
#include "user.h"


int
main(int argc, char *argv[]) {
  // int pid = getpid();   
  // map(pid);
  
  char* m1 = (char*)myalloc(2 * 4096);
  char* m2 = (char*)myalloc(3 * 4096);
  char* m3 = (char*)myalloc(1 * 4096);
  char* m4 = (char*)myalloc(7 * 4096);
  char* m5 = (char*)myalloc(9 * 4096);

  m1[0] = 'h';
  m1[1] = '\0';


  printf(1,"m1:%s\n",m1);
  myfree(m2);

  //m2[1] = 'p';

  myfree(m4);
  
  // map(pid);
  sleep(5000);
  myfree(m1);
  myfree(m3);
  myfree(m5);
  // char *p=(char *)0x0000;
  // for(int i=0x0000;i<0x08;i++)
  //     *(p+i)='*';

  // printf(1,"This string shouldn't be modified!\n");
  // exit();


  exit();
}

运行结果：

image-20221021211837168

遇见问题：

image-20221021212021956

解决：

image-20221021212625546

03 高级

3.1 实现xv6内核线程

创建线程的开销比创建进程要小，线程可以共享进程的主要资源，例如内存映像、打开的文件等。在xv6上实现线程所涉及的主要工作如下：

  • 实现clone系统调用，用于创建一个内核线程
  • 实现join系统调用，用于回收一个内核线程
  • 实现用户线程库，封装对线程的管理，而用户只需要知道接口即可
  • 提供测试样例，包括共享进程空间、多线程并行

注意：建立在2.4.1基础上

3.2 文件系统

文件系统方面主要实现了三个功能

  • 为xv6文件系统增加文件读写权限控制
  • 实现恢复被删除的文件内容
  • 和设备有关的磁盘裸设备的读写

3.3 虚拟内存

实现的虚存交换机制比较简陋，换出的页帧内容保存到磁盘文件系统的普通文件数据区，而不是Linux那样使用独立的交换分区获得交换文件。换出的页帧所在盘块号直接保存在其pte的高位，其pte低12位仍用作标志用途。

-特立独行的猪-
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
UNIX操作系统设计--中文版
06-21
UNIX操作系统设计--中文版 入门的话很简单~~~好好学吧！
文件模拟系统 uinx
01-12
在实际的Unix系统中，这些操作由更复杂的系统调用如`mkdir`, `chdir`, `ls`等实现，它们涉及到更底层的文件系统接口和权限管理。 为了进一步完善这个模拟系统，可以考虑以下几个扩展点： 1. 添加文件操作：创建、...
XV6实验(2020)
weixin_47037146的博客
02-02 2233
Xv6（和其他Unix操作系统一样）中的隔离单位是一个进程。进程抽象防止一个进程破坏或监视另一个进程的内存、CPU、文件描述符等。它还防止一个进程破坏内核本身，这样一个进程就不能破坏内核的隔离机制。内核用来实现进程的机制包括用户/管理模式标志、地址空间和线程的时间切片。Xv6为每个进程维护一个单独的页表，定义了该进程的地址空间。如图2.3所示，以虚拟内存地址0开始的进程的用户内存地址空间。首先是指令，然后是全局变量，然后是栈区，最后是一个堆区域（用于malloc）以供进程根据需要进行扩展。
6.S081——CPU调度部分(CPU的复用和调度)——xv6源码完全解析系列(10)
zheyuan的博客
07-11 1351
终于到这里了，我们在之前阅读很多地方的内核代码时，总是习惯性地绕开CPU调度的部分(比如yield函数)。现在我们总算可以深入进去一探究竟了，这次总算是将整个操作系统中的一块重要拼图拼上去了。有操作系统相关基础概念的人应该知道，操作系统的其中一个重要功能是虚拟化(Virtulization)。这是OSTEP(Operating System : Three Easy Pieces，中译名：操作系统导论)提出的操作系统三大主题之一，另外两个是并发(Concurrency)和持久性(Consistency)。虚
第三章 xv6操作系统中级实验1——xv6操作系统进程调度
最新发布
fantasticHQ的博客
05-13 2万+
Hello，小伙伴们，经过本专栏的第一章和第二章实验，相信大家对xv6操作系统实验有了一个很好的入门，第一章讲述了对如何根据自己的需求添加一些简单的自定义操作系统功能（其实就是把我们写的C程序代码加入到xv6源码中，并且关联到Makefile文件中），第二章讲述了如何在进程之间共享内核全局变量（这是进程间通信的基础，完成了这个实验，对进程间通信会有一个简单的认识）。需要在更多的xv6源代码文件中添加我们自己的代码块，可以使得我们对xv6操作系统源代码有更加深入的认识，并且巩固对应的操作系统理论知识。
操作系统实验Lab 1:Xv6 and Unix utilities(MIT 6.S081 FALL 2020)
菜籽爱编程
10-04 1万+
Lab 1 Xv6 and Unix utilities 实验要求链接 Boot xv6 (easy) 实验目的 切换到 xv6-labs-2020 代码的 util 分支，并利用 QEMU 模拟器启动 xv6 系统。 实验步骤 使用下面的命令克隆 xv6-labs-2020 代码到本地。 git clone git://g.csail.mit.edu/xv6-labs-2020 使用下面的命令进入 xv6-labs-2020 代码目录。 cd xv6-labs-2020 使用下面的命令切换到 util
从零开始使用Vscode调试XV6
zion--6135的博客
09-18 2347
针对makefile: 安装compiledb【git clone https://github.com/nickdiego/compiledb.git】来自动生成compile_commands.json。注意：由于有 "miDebuggerServerAddress": "127.0.0.1:26000", //所以需要吧.gdbinit 中 target remote xxxx:xx改为。一天时间的教训---系统要ubuntu20.04的 ，用ubuntu18.04的搞了一天。
信号量机制实现进程互斥、同步、前驱关系
xzy的博客
06-21 696
文章目录信号量机制实现进程互斥、同步、前驱关系知识总览图信号量机制实现进程互斥信号量机制实现进程同步信号量机制实现前驱关系 信号量机制实现进程互斥、同步、前驱关系 知识总览图 信号量机制实现进程互斥 信号量机制实现进程同步 题目同步要求：要求线程P2的代码4要执行在线程P1的代码2的后面，如下图： 分析如下图: “前操作”指的就是代码2，“后操作”指的就是代码4 上图中的目的是要实现同步，要让代码4执行在代码2的前面，假如刚开始执行的是线程P1，那么等到代码2执行之后，会执行V(S)操作，这
xv6实验课程--xv6的写时拷贝(COW)(2021)
lhwhit的专栏
10-09 3517
虚拟内存提供了一个间接层（a level of indirection）：内核可以通过将PTE标记为无效或只读来拦截内存引用，从而导致页面错误，并可以通过修改PTE来更改地址的含义。在计算机系统中有一种说法，任何系统问题都可以通过间接层来解决。懒页分配实验提供了一个例子，本实验探索了另一个例子：写时拷贝。注：懒页分配实验是2020年课程中的一个实验，目前，在2021年课程中缺少了这个实验，感兴趣的读者可在本公众号中找到。请切换到cow分支，开始本次实验。$ git fetch$ git checkout c
操作系统讲义【李胜利版】
05-28
C语言标准库中的stdio函数集就是基于这些系统调用实现的。 六、网络编程 Unix系统在网络编程方面具有强大支持，如socket API，用于创建网络连接，实现TCP/IP和UDP协议。程序员可以编写服务器和客户端应用程序，实现...
xv6源码解析（四）——进程管理
yttt的博客
11-11 1222
xv6源码解析（四）——进程管理
操作系统OS lab4 (xv6) 实验报告
四十不嚯的博客
04-12 8183
Lab 4: 调度 实验简介 实验目的： 1.理解操作系统的调度管理机制 2.熟悉 xv6的系统调度器框架，以及缺省的Round-Robin 调度算法 3.实现Priority based scheduling调度算法来替换缺省的调度算法 实验背景 1.调度： 任何操作系统都可能碰到进程数多于处理器数的情况，这样就需要考虑如何分享处理器资源。理想的做法是让分享机制对进程透明。这就要求进程调度...
信号量-实现进程互斥，同步
m0_52559870的博客
05-20 3926
一、实现进程互斥 1．分析并发进程的关键活动，划定临界区（如:对临界资源打印机的访问就应放在临界区) 2.设置互斥信号量mutex，初值为1 3．在临界区之前执行P(mutex) 4．在临界区之后执行V(mutex) 注意: 对不同的临界资源需要设置不同的互斥信号量。 P、V操作必须成对出现。缺少P(mutex)就不能保证临界资源的互斥访问。缺少V(mutex)会导致资源永不被释放，等待进程永不被唤醒。 二、实现进程同步 因为进程并发，所以进程的执行顺序是不确定的 进...
二、操作系统——用信号量机制实现进程互斥、同步、前驱关系（详解）
zep
05-16 1万+
一、什么是进程同步？ 二、什么是进程互斥？ 临界资源：一个时间段内只允许一个进程使用的资源 为了实现对临界资源的互斥访问，同时保证系统整体性能，需要遵循以下原则： 空闲让进。临界区空闲时，可以允许一个请求进入临界区的进程立即进入临界区； 忙则等待。当已有进程进入临界区时，其他试图进入临界区的进程必须等待； 有限等待。对请求访问的进程，应保证能在有限时间内进入临界区（保证不会饥饿）； 让权等待。当进程不能进入临界区时，应立即释放处理机，防止进程忙等待。 注意： 5. 进程同步也可以说是进程之间的直
实验5 利用信号量实现进程互斥
江南、寻你的博客
05-11 1745
【实验目的】 理解互斥概念、信号量机制及信号量结构； 掌握信号量的使用方法； 掌握PV操作的定义； 掌握PV操作实现互斥的方法。 【实验环境】VMware Workstation、RedHat 【实验步骤】 一、父子进程以非互斥方式共享访问临界资源 创建父子进程，父子进程共享一个临界资源,每个进程循环进入该临界区3次；父进程每次进入临界区后显示“parent in”，出临界区显示“parent out”。 子进程每次进入临界区后显示“child in”，出临界区显示“child out”。
信号量机制实现进程的互斥、同步、前驱
kkyh28的博客
12-05 5028
1965年，荷兰学者Dijkstra提出了一种卓有成效的实现进程互斥、同步的方法——信号量机制 信号量其实就是一个变量（可以是一个整数，也可以是一个更复杂的变量），可以用信号量来表示系统中某种资源的数量。比如：系统中只有一台打印机，就可以设置一个初值为1的信号量。 P、V操作： P表示通过，V表示释放 1.整型信号量： 整型信号量与普通的信号量的区别： 对信号量的操作只有：初始化、P操作、V操作 缺点：不满足“让权等待”原...
【OS xv6】2 万字详解xv6如何启动和运行第一个进程（文档第二章文摘+相关源码分析）
深大cs课程实验及学习笔记，ccfcsp部分真题，华为题库
10-28 2351
xv6是仿unix基本接口和内部设计的简化教学操作系统。本文对XV6帮助文档第二章2 Operating system organization操作系统概要做文摘，并对xv6启动源码做了详细解析（2.6 Code: starting xv6 and the first process），补充源码阅读理解可能需要的qemu、字长、嵌入汇编、TLB相关知识补充；内含有助于源码阅读的优质博客推荐，对xv6启动相关源码进行注释解析展示，并提供第一个用户进程初始化函数userinit()具体解析流程图。
Linux/uinx系统的文件权限位包括哪些域,每个域可能包含哪些具体文件操作权限
08-08
### 回答1： Linux/Unix 系统的文件权限位包括 3 个域：用户（即文件拥有者）...文件权限是Linux/Unix系统中重要的安全特性，可以控制对系统中文件和目录的访问权限，确保只有授权的用户或组能够对文件进行相应的操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

-特立独行的猪-

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值