自制操作系统日志——第十三天

最新推荐文章于 2024-04-29 21:58:18 发布
最新推荐文章于 2024-04-29 21:58:18 发布
阅读量153 收藏 1
点赞数 1
分类专栏： 自制操作系统雏形日志 文章标签： linux windows 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43696276/article/details/126053914
版权

自制操作系统日志——第十三天

今天续上昨天未完成的定时器的任务，再接再厉，争取今天将这部分弄完！！

文章目录

一、简化主程序的字符串显示部分

由于在主程序中，每次显示字符都需要做如下三个步骤：先涂上背景色，然后写上字符，最后完成刷新这三个操作，因此为了简化程序，我们可以直接将这三个或者由前两个组成的语句进行浓缩成一个函数来使用：
在这里插入图片描述

//这里主要完成的任务是：先涂上背景色，然后在这之上描绘字符，然后刷新图层！！ x,y显示位置坐标，c字符颜色，b背景颜色，s字符串，l字符串长度
void putfonts8_asc_sht(struct SHEET *sht, int x, int y, int c, int b, char *s, int l)
{
	boxfill8(sht->buf, sht->bxsize, b, x, y, x + l * 8 - 1, y + 15);
	putfonts8_asc(sht->buf, sht->bxsize, x, y, c, s);
	sheet_refresh(sht, x, y, x + l * 8, y + 16);
	return;
}

然后进行替换即可！！！

二、调整fifo缓冲区

1.简化定时器的缓冲区

由于在前所述中，我们对于每一个计时器都给予一个fifo缓冲区，这在只有3个时候还好，倘若有100个的话，这种方法不仅占用内存，会让判断的的那一句if语句显得过长，因此这里将对其进行简化，利用一个缓冲区但是不同计时器向缓冲区发送不同的内容来进行判断！！！主要修改如下：

	fifo8_init(&timerfifo, 8, timerbuf);
	timer = timer_alloc();
	timer_init(timer, &timerfifo, 10);
	timer_settime(timer, 1000);
	timer2 = timer_alloc();
	timer_init(timer2, &timerfifo, 3);
	timer_settime(timer2, 300);
	timer3 = timer_alloc();
	timer_init(timer3, &timerfifo, 1);
	timer_settime(timer3, 50);
略
else if (fifo8_status(&timerfifo) != 0)
			{
				i = fifo8_get(&timerfifo);//首先读入，为了设定起始点
				io_sti();
				if(i == 10)
				{
					putfonts8_asc_sht(sht_back, 0, 64, COL8_FFFFFF, COL8_008484, "10[sec]", 7);
				}else if (i == 3)
				{
					putfonts8_asc_sht(sht_back, 0, 80, COL8_FFFFFF, COL8_008484, "3[sec]", 6);
				}else{
					if (i != 0) {
					timer_init(timer3, &timerfifo, 0); //然后设置为0
					boxfill8(buf_back, binfo->scrnx, COL8_FFFFFF, 8, 96, 15, 111);
				    } else {
						timer_init(timer3, &timerfifo, 1); //然后设置为1
						boxfill8(buf_back, binfo->scrnx, COL8_008484, 8, 96, 15, 111);
				    }
				    timer_settime(timer3, 50);
				    sheet_refresh(sht_back, 8, 96, 16, 112);
				}

			}

然后，make run即可！！应该是没啥问题可以运行的！ 注意顺便将之前声明的那些变量删了。。。

2、简化所有的fifo缓冲区

这里，如图前面所述，我们继续进一步的将所有的FIFO缓冲区全部浓缩在一个缓冲区当中！！！

具体的传送数据如下：
/*缓冲区读入的数据：
0~1 表示光标闪烁
3 表示3秒定时器
10 表示10s定时器
256~511 表示键盘输入（键盘输入值+256）
512~767 表示鼠标输入（鼠标输入值+512）
*/

因此，我们需要将之前的fifo缓冲区修改一下，将之前buf的char类型变为int型：

/* fifo.c */
struct FIFO32{
	int *buf;//缓冲区地址
	int p, q, size, free, flags;//p 下一写入地址；q 下一读出地址； size是总字节数，free是缓冲区中没有数据的字节数；flag判断溢出
};
void fifo32_init(struct FIFO32 *fifo, int size, int *buf);
int fifo32_put(struct FIFO32 *fifo, unsigned char data);
int fifo32_get(struct FIFO32 *fifo);
int fifo32_status(struct FIFO32 *fifo);

然后，对应的修改一下fifo.c的内容：

void fifo32_init(struct FIFO32 *fifo, int size, int *buf)
//初始化fifo地址
{
	fifo->size = size;
	fifo->buf = buf;
	fifo->free = size; //空
	fifo->flags = 0;
	fifo->p = 0 ;   //写入位置
	fifo->q = 0 ;   //读取位置
	return;
}

int fifo32_put(struct FIFO32 *fifo, unsigned char data) 
//向fifo传递数据并保存
{
	if(fifo->free == 0)
	{
		//无空余，溢出
		fifo->flags |= FLAGS_OVERRUN;
		return -1;
	}
	fifo->buf[fifo->p] = data;
	fifo->p++;
	if(fifo->p == fifo->size)
	{
		fifo->p = 0;
	}
	fifo->free--;
	return 0;
}

int fifo32_get(struct FIFO32 *fifo)
//从fifo中获取一个数据
{
	int data;
	if (fifo->free == fifo->size)
	//缓冲区为空返回-1
	{
		return -1;
	}
	data = fifo->buf[fifo->q];
	fifo->q++;
	if(fifo->q == fifo->size)
	{
		fifo->q = 0;
	}
	fifo->free++;
	return data;
}

int fifo32_status(struct FIFO32 *fifo)
{
	return fifo->size - fifo->free;
}

继续对应的修改一下，mouse

struct FIFO32 *mousefifo;
int mousedata0;

#define KEYCMD_SENDTO_MOUSE		0xd4
#define MOUSECMD_ENABLE			0xf4

void enable_mouse(struct FIFO32 *fifo, int data0, struct MOUSE_DEC *mdec)
{
	//将FIFO缓冲区内容保存到全局
	mousefifo = fifo;
	mousedata0 = data0;
	//鼠标有效，且激活
	wait_KBC_sendready();
	io_out8(PORT_KEYCMD, KEYCMD_SENDTO_MOUSE);//往键盘控制电路发送0xd4，则代表下一个数据发给鼠标
	wait_KBC_sendready();
	io_out8(PORT_KEYDAT, MOUSECMD_ENABLE);//激活鼠标数据 0xfa，键盘控制其返回ACK（0xfa) <== 答复信息
	//如果激活了，就会传送0xfa过来
	mdec->phase = 0;//等待0xfa阶段
	return; 
}

void inthandler2c(int *esp)
/* 来自PS/2鼠标的中断 */
{
		int data;
		io_out8(PIC1_OCW2,0X64); //通知PIC1 已经完成IRQ-12
		io_out8(PIC0_OCW2,0X62);//通知PIC0 已经完成IRQ-2
		data = io_in8(PORT_KEYDAT);
		fifo32_put(mousefifo, data + mousedata0);
  	return;
}

修改keyboard：

struct FIFO32 *keyfifo;
int keydata0;

void inthandler21(int *esp)
{
	int data;

 /*通知PIC “IRQ-01”已经受理完毕;这里的计算公式是0x60+IRQ号码
  只有输出到ocw2后，PIC才会继续监视IRQ1中断是否发生，如果不写这句话则后面不会再产生中断了
  */
	io_out8(PIC0_OCW2,0X61);
	data = io_in8(PORT_KEYDAT);
	fifo32_put(keyfifo, data + keydata0);
	return;
}

#define PORT_KEYSTA				0x0064
#define KEYSTA_SEND_NOTREADY	0x02
#define KEYCMD_WRITE_MODE		0x60
#define KBC_MODE				0x47

void wait_KBC_sendready(void)
{
	for(;;)
	{
	//等待键盘控制电路准备完毕，检测到设备号0x0064处数据的第2位是0时，就跳出等待
		if ((io_in8(PORT_KEYSTA) & KEYSTA_SEND_NOTREADY) == 0) {
			break;
		}
	}
	return;
}

void init_keyboard(struct FIFO32 *fifo, int data0)
{
	keyfifo = fifo;
	keydata0 = data0;
	/* 初始化键盘控制电路 */
	wait_KBC_sendready();
	io_out8(PORT_KEYCMD, KEYCMD_WRITE_MODE);//向键盘控制电路发送模式设定指令，模式设定指令是0x60
	wait_KBC_sendready();
	io_out8(PORT_KEYDAT, KBC_MODE);//向键盘控制电路发送模式设定指令，鼠标的模式号码是0x47
	return;
}

然后，也继续修改一下定时器的结构：

struct TIMER
{
	unsigned int timeout, flags;//flags表示各个定时器的状态； timeout的含义，这里指予定时刻，通过settime中赋予的超时时间+当前时刻来计算，当到达多少时间后算超时
	struct FIFO32 *fifo;//用于将超时的信息传给缓冲区。
	int data;
};

最后改一下主程序就行了：

void HariMain(void)
{
	//鼠标键盘，bootinfo等等的定义
	struct BOOTINFO *binfo = ( struct BOOTINFO *) ADR_BOOTINFO;
	struct FIFO32 fifo;
	int fifobuf[128];
	char s[40];
	略
	    //初始化的部分
	init_gdtidt();//初始化gdt、idt表
	init_pic();  //初始化pic控制器
	io_sti();
    fifo32_init(&fifo, 128, fifobuf);
	init_pit();
	init_keyboard(&fifo, 256);
    enable_mouse(&fifo, 512, &mdec);
    io_out8(PIC0_IMR, 0xf8); /* 开放PIC1和键盘中断(11111000),键盘是IRQ1 */
	io_out8(PIC1_IMR, 0xef); /* 开放鼠标中断(11101111) ，鼠标是IRQ12*/

	timer = timer_alloc();
	timer_init(timer, &fifo, 10);
	timer_settime(timer, 1000);
	timer2 = timer_alloc();
	timer_init(timer2, &fifo, 3);
	timer_settime(timer2, 300);
	timer3 = timer_alloc();
	timer_init(timer3, &fifo, 1);
	timer_settime(timer3, 50);
	略
	for(;;)   
	{
		count++;

		io_cli(); //IF=0
		if (fifo32_status(&fifo) == 0)
		{
			io_sti();
		}else 
		{ 
			i = fifo32_get(&fifo);
			io_sti();
			if (256 <= i && i <= 511) { /*键盘数据 */
				sprintf(s, "%02X", i - 256);
				putfonts8_asc_sht(sht_back, 0, 16, COL8_FFFFFF, COL8_008484, s, 2);
			} else if (512 <= i && i <= 767) { /* 鼠标数据 */
				if (mouse_decode(&mdec, i - 512) != 0) {
					/* 已经收集3字节数据，显示出来 */
					sprintf(s, "[lcr %4d %4d]", mdec.x, mdec.y);
					if ((mdec.btn & 0x01) != 0) {
						s[1] = 'L';
					}
					if ((mdec.btn & 0x02) != 0) {
						s[3] = 'R';
					}
					if ((mdec.btn & 0x04) != 0) {
						s[2] = 'C';
					}
					putfonts8_asc_sht(sht_back, 32, 16, COL8_FFFFFF, COL8_008484, s, 15);
					/* 鼠标的移动 */
					mx += mdec.x;
					my += mdec.y;
					if (mx < 0) {
						mx = 0;
					}
					if (my < 0) {
						my = 0;
					}
					if (mx > binfo->scrnx - 1) {
						mx = binfo->scrnx - 1;
					}
					if (my > binfo->scrny - 1) {
						my = binfo->scrny - 1;
					}
					sprintf(s, "(%3d, %3d)", mx, my);
					putfonts8_asc_sht(sht_back, 0, 0, COL8_FFFFFF, COL8_008484, s, 10);
					sheet_slide(sht_mouse, mx, my);
				}
			} else if (i == 10) { /*10秒计时器 */
				putfonts8_asc_sht(sht_back, 0, 64, COL8_FFFFFF, COL8_008484, "10[sec]", 7);
				sprintf(s, "%010d", count);
				putfonts8_asc_sht(sht_win, 40, 28, COL8_000000, COL8_C6C6C6, s, 10);
			} else if (i == 3) { /* 3秒计时器 */
				putfonts8_asc_sht(sht_back, 0, 80, COL8_FFFFFF, COL8_008484, "3[sec]", 6);
				count = 0; /* 测定开始 */
			} else if (i == 1) { /* 光标用计时器 */
				timer_init(timer3, &fifo, 0); /* 设定为0 */
				boxfill8(buf_back, binfo->scrnx, COL8_FFFFFF, 8, 96, 15, 111);
				timer_settime(timer3, 50);
				sheet_refresh(sht_back, 8, 96, 16, 112);
			} else if (i == 0) { /* 光标用计时器 */
				timer_init(timer3, &fifo, 1); /* 设定为1 */
				boxfill8(buf_back, binfo->scrnx, COL8_008484, 8, 96, 15, 111);
				timer_settime(timer3, 50);
				sheet_refresh(sht_back, 8, 96, 16, 112);
			}	
	   }
	}
	}

至此，修改完毕！！！这里我们改进了代码中断交互操作，从以前每次循环都要查询三次的缓冲区，改成了一个。这样子就可以使得count中执行语句执行的更多次了！！！ 具体的可以必交一下之前的程序，会发现差距还蛮大的。

加快中断处理

由于前面的过程中，我们采用的都是利用移位的操作来进行将timers中的计时器进行排序的。这种方法可能会使得再拥有多个计时器的情况下，在这一步的中断过程中时间明显会变长很多！！！

所以，我们计划利用链表的形式进行进行链接管理整个计时器的表，这样子就可以不用移位了！！而是直接更改链表指针的指向就可以实现移位了：
更改结构体：

#define MAX_TIMER 500
struct TIMER
{
	struct TIMER *next_timer;//指下一个定时器的地址
	unsigned int timeout, flags;//flags表示各个定时器的状态； timeout的含义，这里指予定时刻，通过settime中赋予的超时时间+当前时刻来计算，当到达多少时间后算超时
	struct FIFO32 *fifo;//用于将超时的信息传给缓冲区。
	int data;
};
struct TIMERCTL
{
	unsigned int count, next_time, using;//using用于记录现在有几个定时器处于活动中，这里的next是指下一个超时时刻
	struct TIMER *t0;
	struct TIMER timers0[MAX_TIMER];
};

然后更改timer.c的部分函数即可：

/主程序中对于pit计时器是先注册并设置完一个之后再弄另一个的！！
//t用于进行遍历的，s保存t的前一个值
void timer_settime(struct TIMER *timer, unsigned int timeout)
{
    int e;
    struct TIMER *t, *s;
    timer->timeout = timeout + timerctl.count;//从现在开始后多少秒以后算超时
    timer->flags = TIMER_FLAGS_USING;
    e = io_load_eflags();
    io_cli();
    timerctl.using++;
    if(timerctl.using == 1)
    {
        //运行状态的定时器只有一个时
        timerctl.t0 = timer;
        timer->next_timer = 0; //没有下一个
        timerctl.next_time = timer->timeout;
        io_store_eflags(e);
        return;
    }
    t = timerctl.t0;
    if(timer->timeout <= t->timeout)//插入最前面
    {
        timerctl.t0 = timer;
        timer->next_timer = t;//接下来是t
        timerctl.next_time = timer->timeout;
        io_store_eflags(e);
        return;
    }
    //搜索注册位置
    for(;;)  //找到比当前计时器拟到达时刻还要晚的计时器，然后插入在此前面
    {
        s = t;
        t = t->next_timer;
        if(t == 0)
        {
            break;
        }
        if(timer->timeout <= t->timeout)
        {//插入到s和t中间
           s->next_timer = timer;//s的下一个是timer
           timer->next_timer = t;//timer的下一个是t
           io_store_eflags(e);
           return;
        }
        //插入的是最后一位
        s->next_timer = timer;
        timer->next_timer = 0;
        io_store_eflags(e);
        return;
    }
}


void inthandler20(int *esp)
{
    int i;
    struct TIMER *timer;
    io_out8(PIC0_OCW2, 0x60);//IRQ-0信号接收完后告知PIC
    timerctl.count++;
    if(timerctl.next_time > timerctl.count)
    {
        return; //还不到下一个时刻，因此返回
    }
    timer = timerctl.t0;//先把最前面的赋予给timer
	for (i = 0; i < timerctl.using; i++) {// timers的定时器都是活动中的因此不需要确认flags
        if(timer->timeout > timerctl.count )
        {
            break;
        }
        //超时
        timer->flags = TIMER_FLAGS_ALLOC;
        fifo32_put(timer->fifo, timer->data);
		timer = timer->next_timer;//将下一定时器地址赋予给timer
    }
    //正好有i个计时器所以移位
    timerctl.using -= i;
    //新移位
    timerctl.t0 = timer;
    //timerctl.next的设定
    if (timerctl.using > 0) {
		timerctl.next_time = timerctl.t0->timeout;
	} else {
		timerctl.next_time = 0xffffffff;
	}
	return;
}

然后，makerun运行：
在这里插入图片描述

使用哨兵化进行处理

所谓“哨兵”，就是程序技巧中的专门用于，其目的是在某一串链接中，设置一个留下了进行"看门、巡逻”等等的，其目的不在于使用，而是可以减少我们程序的语句判断的逻辑！！

在前面的逻辑中，settime里，我们必须做如下四种情况：

  1. 运行中的定时器只有一种情况；
  2. 插入到最前面；
  3. 插入到t和s之间；
  4. 插入到最后面。

试想，这里我们建立起一个时刻为0xfffffff的定时器，置于整个计时器表中的最后一位（一般来说是到达不了的，就算可能要到达这个时刻，我们也可以进行修改时刻！）。那么这一个定时器，就会一直处于最后一个，像是留下来看家的一个，因此也可以称之为哨兵。 那么这个哨兵有什么用? 他的好处在于，我们可以极大的减少我们的判断语句，也就是说此时上面的四个条件我们已经可以去除掉两个了！！

  1. 运行中的定时器只有一种情况；×（因为有哨兵所以至少两个）
  2. 插入到最前面；√
  3. 插入到t和s之间；√
  4. 插入到最后面。× （永远有哨兵存在）

而且，由于我们使用的是next这种格式进行连接的，因此using也没有用了。
然后具体修改的代码如下：

void timer_settime(struct TIMER *timer, unsigned int timeout)
{
    int e;
    struct TIMER *t, *s;
    timer->timeout = timeout + timerctl.count;//从现在开始后多少秒以后算超时
    timer->flags = TIMER_FLAGS_USING;
    e = io_load_eflags();
    io_cli();
    t = timerctl.t0;
    if(timer->timeout <= t->timeout)//插入最前面
    {
        timerctl.t0 = timer;
        timer->next_timer = t;//接下来是t
        timerctl.next_time = timer->timeout;
        io_store_eflags(e);
        return;
    }
    //搜索注册位置
    for(;;)  //找到比当前计时器拟到达时刻还要晚的计时器，然后插入在此前面
    {
        s = t;
        t = t->next_timer;
        if(t == 0)
        {
            break;
        }
        if(timer->timeout <= t->timeout)
        {//插入到s和t中间
           s->next_timer = timer;//s的下一个是timer
           timer->next_timer = t;//timer的下一个是t
           io_store_eflags(e);
           return;
        }
    }
}
void inthandler20(int *esp)
{
    int i;
    struct TIMER *timer;
    io_out8(PIC0_OCW2, 0x60);//IRQ-0信号接收完后告知PIC
    timerctl.count++;
    if(timerctl.next_time > timerctl.count)
    {
        return; //还不到下一个时刻，因此返回
    }
    timer = timerctl.t0;//先把最前面的赋予给timer
	for (;;) {// timers的定时器都是活动中的因此不需要确认flags
        if(timer->timeout > timerctl.count )
        {
            break;
        }
        //超时
        timer->flags = TIMER_FLAGS_ALLOC;
        fifo32_put(timer->fifo, timer->data);
		timer = timer->next_timer;//将下一定时器地址赋予给timer
    }
    //新移位
    timerctl.t0 = timer;
    //timerctl.next的设定
	timerctl.next_time = timerctl.t0->timeout;
	return;
}

运行结果如下：
在这里插入图片描述
可以对比一下，明显又快了许多！！！！！可喜可贺啊

总结

以上就算所有的定时器操作，明天开始我们将开启提高屏幕的分辨率了！！！！

dfzy$_$
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
30天自制操作系统第1~15天实验日志.zip
02-17
30天自制操作系统第1~15天实验日志，包括实验内容，问题及解决方式，描述创新点
操作系统课程设计报告，基于30天自制操作系统
06-07
操作系统课程设计报告，基于30天自制操作系统，内容为简单demo的实现，可参考学习
自制操作系统日志——第十九天
qq_43696276的博客
09-12 173
今天，我们将制作我们的第一个应用程序。大家来一起加油吧！！
自制操作系统日志——第二十三天
qq_43696276的博客
09-12 224
今天呢，主要进行图形处理API相关的描绘。加油加油！
自制操作系统日志——第十七天
qq_43696276的博客
09-12 148
今天，我们首先继续稍微完善一下多任务的部分。然后，我们开始制作每一个操作系统都必须有的命令行窗口吧！！！从今天开始，我们将一步一步的完成我们的命令行窗口，并能够输入一些命令进行调用吧！ 嘿嘿嘿想想就有点激动了！！让我们现在就开始撸起袖子加油干吧。
自制操作系统日志——第十天
qq_43696276的博客
09-11 140
今天的主要任务就是继续优化内存管理部分，然后进一步的做一下叠加处理，主要就了解图层的设置，整个程序利用图层的整体过程。
30天自制操作系统综合大设计harib12g.zip
02-07
30天自制操作系统最后的实验验收，将近两千行的代码，两点在于开机动画的帧数多，密码，双击，时钟绘制的好看，直线的绘制，可以用拖动的方式绘制矩形，还可以通过输入的方式改变绘制的大小，以及窗口颜色来改变颜色
30天自制操作系统第2，3次验收.zip
02-17
30天自制操作系统第2次，第3次实验验收，还包括窗口关闭与显示，完善任务栏被吃掉
13 Linux实操篇-网络配置
qq_74289024的博客
04-23 1051
子网ip 与网关。
Linux多进程(五) 进程池 C++实现
Lyajpunov的博客
04-26 807
进程池是一种并发编程模式，用于管理和重用多个处理任务的进程。它通常用于需要频繁创建和销毁进程的情况，以避免因此产生的开销。减少进程创建销毁的开销：避免频繁创建和销毁进程所带来的系统资源开销。提高系统响应速度：由于进程已经初始化并且一直保持在内存中，可以立即分配执行任务，减少了任务等待时间。控制资源使用：通过限制进程池中的进程数量，可以控制系统资源的使用情况，避免资源过度消耗。
Linux——web服务配置
Xinan_____的博客
04-23 1135
GET：请求获取指定资源的表示形式。使用GET方法，客户端请求服务器发送某个资源。POST：向指定资源提交数据，用于处理表单提交、文件上传等操作。PUT：向指定资源位置上传其最新内容，用于更新资源。DELETE：请求服务器删除指定资源。HEAD：请求获取与实体相对应的头部信息，用于获取资源的元数据。OPTIONS：请求查询服务器支持的HTTP方法。TRACE：请求服务器回显收到的请求消息，用于测试或诊断。200 OK：请求成功。：永久重定向，请求的资源已经被分配了新的。
Linux：浏览器访问网站的基本流程（优先级从先到后）
fox_kang的博客
04-28 614
浏览器访问网站的基本流程（优先级从先到后） 首先查找浏览器是否存在该网站的访问缓存 其次查找本机的域名解析服务器 windows：C:\Windows\System32\drivers\etc\hosts Linux：/etc/hosts 使用外部的域名解析服务器解析（例如：114.114.114.114） 第一步：浏览器使用域名访问www.bilibili.com.网站 第二步：首先去访问根域名解析服务器查询，根服务器返回.com域名解析服务器地址==（这里的根域名解析服务器不会直接给出域名对应的
Linux 抽象命名空间（Abstract Namespace）简介
日拱一卒，玉汝于成
04-25 592
与传统的 UDS 不同，抽象命名空间并不在文件系统中创建实际文件，而是仅存在于内核内存中，其名称以 localabstract: 作为前缀。在这个例子中，我们创建了一个名为 my_abstract_namespace 的抽象命名空间，并将其绑定到了刚创建的 Unix 套接字上。要在 Linux 系统中生成一个抽象命名空间，通常需要使用编程语言的套接字 API 来创建一个 Unix 域套接字，并将其绑定到一个以 localabstract: 开头的特殊路径。
arm架构Linux5.0内核连接脚本文件vmlinux.lds.S分析
jianjian的博客
04-23 985
vmlinux.lds.S 是 Linux 内核中用于链接的脚本文件，用于定义内核对象文件的内存布局，即它告诉链接器如何将不同的内核代码段和数据段组合成一个最终的内核映像 vmlinux。编译内核源码生成内核文件的过程分两步，一个是“编译”，另一个是“链接”的过程，vmlinux.lds.S要做的就是告诉编译器如何链接编译好的各个内核.o文件，从而生成vmlinux文件。
linux的“＞”和“＞＞”
qq_45212655的博客
04-24 480
文件存在，新的输出将被添加到文件的内容之后；如果文件不存在，将会创建一个新文件。文件存在，它的内容将被新的输出覆盖；如果文件不存在，将会创建一个新文件。都是用于文件重定向的操作符，它们用于将命令的输出发送到文件中。用于创建一个新文件或覆盖现有文件的内容。用于将输出附加到现有文件的末尾，而不是覆盖它。
Linux中的YUM源仓库和NFS文件共享服务
最新发布
2402_83805984的博客
04-29 445
yum是一个基于RPM包（是Red-Hat Package Manager红帽软件包管理器的缩写）构建的软件更新机制，能够自动解决软件包之间的依赖关系=，解决了日常工作中的大量查找安装依赖包的时间。NFS是一种基于TCP/IP传输的网络文件系统协议，最初由sun公司开发，通过NFS协议。客户机可以向访问本地目录一样访问远程NFS服务器中的共享资源。NFS也是NAS存储设备必然支持的一种协议，但是因为没有用户认证机制，而且数据在网络上明文传输、安全性很差，所以一般只能在局域网中使用。
Linux--内核移植（二）移植流程及驱动修改
qq_47258284的博客
04-23 1059
一、官方开发板内核测试本文来总结一下如何将 NXP官方提供的Linux内核移植到正点原子的开发板上。一、官方开发板内核测试NXP提供的Linux源码肯定是可以在自己的开发板上运行下去的，所以我们肯定是以 I.MX6ULL EVK开发板为参考，然后将Linux内核移植到开发板上的。1.修改顶层Makefile修改顶层Makefile，直接在顶层Makefile文件里面定义ARCH和这两个的变量值为 arm和 arm-linux-gnueabihf-。
Linux系统编程--信号与管道
qq_53344001的博客
04-28 1019
open 函数在打开管道文件的时候，必须两方都执行 open，open 才能打开，只有一个进程执行 open，open 会发生阻塞，直到另外的一个进程也运行到 open 的位置，两方同时解除阻塞。内核：当我们的程序出现一些错误的时候，例如段错误等，内核会给我们的进程发送杀死当前进程的信号。这就是通信机制：信号、管道。14 -- SIGALRM -- 闹钟信号，杀死进程。设置闹钟，闹钟事件到，产生闹钟信号，闹钟信号默认杀死当前进程；如果上一次设置的有闹钟，返回上一个闹钟的剩余时间，否则返回 0；
30天自制操作系统gui设计包括那些部分
01-05
30天自制操作系统GUI设计包括以下几个部分： 1. 用户界面设计：首先需要确定操作系统的整体风格和布局，包括桌面背景、图标样式、菜单栏和任务栏的设计。这些设计将影响到整个操作系统的视觉效果和用户体验。 2. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值