操作系统 on UOG的BLOG

SELinux 学习

Sat, 30 May 2026 21:25:58 +0800

SElinux简介链接到标题

SElinux 阻止小白学习linux的一大拦路虎
这东西其实就是用来防止小白误操作的。
但是你学linux怎么能不误操作几次呢
哪有每个命令都敲对的，不错几次不是人。
这个东西，主要是在rwx这个限制上加上另一种限制
防止进程访问一些他不能访问的资源。有些意思的是
限制是加在inode上的，ntfs其实有可能不能用这个（我没调查过）
具体的机制我很难几句话说清楚，所以建议看鸟哥书。

SElinux工作模式链接到标题

3个： disable：不工作 permissive：有问题只写写log enforcing：有问题直接禁止 SElinux的限制只发生在rwx这些权限后！！

SElinux某些概念链接到标题

政策（策略比较合适其实）与规则：其实有点像默认配置，说默认那种那种什么什么限制，有多种政策。

安全本文(security context):另一种rwx权限罢了，但是设计的很闹心，每个不同对象（进程，文件，端口）含义不一样

对象	安全本文	含义
进程如chronyd守护进程	system_u:system_r:chronyd_t	他是system用户权限，可以使用system_r角色（system_u还可以使用其他的），他这个的作用域是chrony_t（这个角色还可以使用其他的域），chrony_t基本决定他可以碰那些文件
文件如chronyd的2进制文件	system_u:object_r:chronyd_exec_t	第一个表示谁创建的，第2个表示他是文件，无意义，第3个表示他一般属于chronyd域（这个有默认命名规则的）

模式操作链接到标题

getenforce # 看看是3种的哪一种模式
setenforce 0 # 调成permissive
setenforce 1 # 调成enforcing

sestatus # 详细设置，看策略

SELinux status:                 enabled
SELinuxfs mount:                /sys/fs/selinux
SELinux root directory:         /etc/selinux
Loaded policy name:             targeted
Current mode:                   enforcing
Mode from config file:          enforcing
Policy MLS status:              enabled
Policy deny_unknown status:     allowed
Memory protection checking:     actual (secure)
Max kernel policy version:      33

设置开机下的模式

Linux_kvm

Wed, 27 May 2026 22:12:04 +0800

linux看cpu是否支持和kvm是否加载链接到标题

看cpu支不支持虚拟化链接到标题

lscpu | grep vmx # intel 用这个 
lscpu | grep svm # amd 用这个

lsmod | grep kvm # 看kvm是否加载
modeprone kvm # 加载kvm

安装虚拟化软件链接到标题

apt/yum/pacman qemu # 虚拟外围设备
apt/yum/pacman dnsmasq # dns服务器，虚拟网络需要
apt/yum/pacman libvirt # 虚拟化服务
systemctl start libvirtd.socket # 启动虚拟化服务

virsh 使用看虚拟化能力链接到标题

virsh是一个整合好的，用于启动配置虚拟化的工具包

# 检查本机的相关虚拟化能力
virsh capabilities | less # 具体参数是什么意思可以看鸟哥的网站
# 检查支持的 q35 芯片组，内部硬件仿真可以是什么样
virsh domcapabilities --machine q35 --arch x86_64 # 我是不懂为什么鸟哥书上要搞个machine，其实我感觉看一个架构x86_64就好
#结果中重要是看virtio是否可行,一般都行

xv6-fs实验

Sat, 14 Mar 2026 01:33:23 +0800

实验一 bigfile 链接到标题

其实这个实验的要求并不难，主要是要理解xv6的文件系统的实现细节。
几个我认为的重点:

buffer层的函数细节要弄清楚
log层的函数使用要弄清楚
索引节点的结构和使用要弄清楚
一点define的细节要弄清楚代码:

static uint bmap(struct inode *ip, uint bn) {
  uint addr, *a;
  struct buf *bp;

  if (bn < NDIRECT) {
    if ((addr = ip->addrs[bn]) == 0) {
      addr = balloc(ip->dev);
      if (addr == 0)
        return 0;
      ip->addrs[bn] = addr;
    }
    return addr;
  }
  bn -= NDIRECT;

  if (bn < NINDIRECT) {
    // Load indirect block, allocating if necessary.
    if ((addr = ip->addrs[NDIRECT]) == 0) {
      addr = balloc(ip->dev);
      if (addr == 0)
        return 0;
      ip->addrs[NDIRECT] = addr;
    }
    bp = bread(ip->dev, addr);
    a = (uint *)bp->data;
    if ((addr = a[bn]) == 0) {
      addr = balloc(ip->dev);
      if (addr) {
        a[bn] = addr;
        log_write(bp);
      }
    }
    brelse(bp);
    return addr;
  }

  bn -= NINDIRECT;
  if (bn < NINDIRECT * NINDIRECT) {
    // Load indirect block, allocating if necessary.
    if ((addr = ip->addrs[NDIRECT + 1]) == 0) {
      addr = balloc(ip->dev);
      if (addr == 0)
        return 0;
      ip->addrs[NDIRECT + 1] = addr;
    }
    bp = bread(ip->dev, addr); // 读一个buff，addr指磁盘地址,这里是读一个间接块
    a = (uint *)bp->data;
    // 一个uint占4字节，一个block的地址是4字节
    // a就是一个uint数组，a[0]是第一个block的地址，a[1]是第二个block的地址
    if ((addr = a[bn / NINDIRECT]) == 0) {
      addr = balloc(ip->dev);
      if (addr) {
        a[bn / NINDIRECT] = addr;
        log_write(bp);
      }
    }
    brelse(bp);
    bp = bread(ip->dev, addr); // 读一个buff，addr指2级间接块的地址
    a = (uint *)bp->data;
    if ((addr = a[bn % NINDIRECT]) == 0) {
      addr = balloc(ip->dev);
      if (addr) {
        a[bn % NINDIRECT] = addr;
        log_write(bp);
      }
    }
    brelse(bp);
    return addr;
  }
  panic("bmap: out of range");
}

实验二 symlink 链接到标题

这个实验主要是多个细节点要想好
我现在其实也没有想太好，虽然弄出来了，但是感觉有点乱，主要是因为我没有把整个文件系统的实现细节弄清楚，所以在实现这个功能的时候有点乱，感觉有点像在拼图一样，虽然最后拼出来了，但是感觉不是很清晰。
整体sys_symlink的实现可以参照create的实现，主要是要弄清楚create的实现细节，尤其是普通文件的实现细节，其中得自己注意inode的创建，日志（log）的处理，文件夹操作（dirlookup，namex）和已有软连接文件重复创建。这好些细节。
然后就是sys_open的代码增加，注意不要搞个死循环。

xv6_lock实验

Sat, 28 Feb 2026 14:51:29 +0800

lock的实验一链接到标题

全局变量的修改和增加链接到标题

这里的str必须是全局变量，搞成局部变量会导致lock的name指令指向一个虚无位置

struct {
  struct spinlock lock;
  struct run *freelist;
} kmem[NCPU];

char str[NCPU][6];

kinit的修改链接到标题

这里lab里说，要让每个CPU去初始化一下
hint里又说，先让一个CPU有全部的内存块

void
kinit()
{
  for(int i = 0; i < NCPU;++i){
    memmove(str[i],"kmem",5);
    str[i][4] = i+'0';
    str[i][5] = 0;
    initlock(&kmem[i].lock, str[i]);
    kmem[i].freelist = 0;
  }
  freerange(end, (void*)PHYSTOP);
  struct run * t = kmem[0].freelist;
  kmem[0].freelist = 0;
  int i = 0;
  while(t){
    struct run * r = t;
    t = t->next;
    r->next = kmem[i].freelist;
    kmem[i].freelist = r;
    i++;
    i %= 3;
  }
}

kfree的修改链接到标题

void
kfree(void *pa)
{
  struct run *r;

  if(((uint64)pa % PGSIZE) != 0 || (char*)pa < end || (uint64)pa >= PHYSTOP)
    panic("kfree");

  // Fill with junk to catch dangling refs.
  memset(pa, 1, PGSIZE);

  r = (struct run*)pa;
 
  push_off();
  int cpu_id = cpuid();
 //int cpu_id = (uint64)r % NCPU;
  acquire(&kmem[cpu_id].lock);
  r->next = kmem[cpu_id].freelist;
  kmem[cpu_id].freelist = r;
  release(&kmem[cpu_id].lock);
  pop_off();
}

kalloc的修改链接到标题

// Allocate one 4096-byte page of physical memory.
// Returns a pointer that the kernel can use.
// Returns 0 if the memory cannot be allocated.
void *
kalloc(void)
{
  struct run *r = 0;
  push_off();
  int cpu_id = cpuid();
  acquire(&kmem[cpu_id].lock);
  if(kmem[cpu_id].freelist){
        r = kmem[cpu_id].freelist;
    kmem[cpu_id].freelist = r->next;
    //kmem[cpu_id].num--;
  }
  release(&kmem[cpu_id].lock);
  pop_off();
//这里可以关了，总之开偷了肯定会有冲突

  int i = (cpu_id+1)%NCPU;
  // 2. 本地失败，尝试窃取
  if(!r){
    for(int j = 0 ; j < NCPU; ++j){//这里用NCPU保证所有内存可以分配
      acquire(&kmem[i].lock);
      if( kmem[i].freelist ){
        r = kmem[i].freelist;
        kmem[i].freelist = r->next;
        release(&kmem[i].lock);
        break;
        }
        release(&kmem[i].lock);
        i++;
        i%=NCPU;
        }
  }

  if (r) {
    memset((char*)r, 5, PGSIZE);
  }

  return (void*)r;
}

优化链接到标题

每个CPU在开始时均分内存 //只有前3个，因为运行时实际上只有3个核
kfree时看进程看自己在那个CPU上就将内存放在哪里
kalloc在有时，只从自己身上拿，没有时窃取

坑链接到标题

一定要在linux上跑，不能在wsl上，在wsl上永远过不了test3。
KIMI跟我说要优化，一次偷别人的一半的内存搞得我走了好久弯路。

lock的实验二链接到标题

定义修改链接到标题

struct {
  struct spinlock lock;//保留这里是为了bpin和bunpin不用修改，目前不知道这两徒弟是干啥的
  struct buf buf[NBUF];
  struct spinlock buf_spin_lock[NBUF];//每个buf状态的访问锁
  // struct buf head;
} bcache;

所有锁的初始化链接到标题

void binit(void) {
  initlock(&bcache.lock, "bcache");
  for (int i = 0; i < NBUF; ++i) {
    initsleeplock(&bcache.buf[i].lock, "buffer");
    initlock(&bcache.buf_spin_lock[i], "bcache");
  }
}

bget改成hash查找链接到标题

他hint里说要搞个hash表，让后用13个的大小，搞什么桶什么什么乱七八糟的，我懒得看了，直接搞了个30大小的hash，按访问dev和blockno这两变量hash一下，冲突了就用顺序查找。

操作系统 on UOG的BLOG

SELinux 学习

SElinux简介 链接到标题

SElinux工作模式 链接到标题

SElinux某些概念 链接到标题

模式操作 链接到标题

Linux_kvm

linux看cpu是否支持和kvm是否加载 链接到标题

看cpu支不支持虚拟化 链接到标题

安装虚拟化软件 链接到标题

virsh 使用 看虚拟化能力 链接到标题

推荐配置目录 链接到标题

xv6-fs实验

实验一 bigfile 链接到标题

实验二 symlink 链接到标题

xv6_lock实验

lock的实验一 链接到标题

全局变量的修改和增加 链接到标题

kinit的修改 链接到标题

kfree的修改 链接到标题

kalloc的修改 链接到标题

优化 链接到标题

坑 链接到标题

lock的实验二 链接到标题

定义修改 链接到标题

所有锁的初始化 链接到标题

bget改成hash查找 链接到标题