Lab4 【哈工大_操作系统】进程运行轨迹的跟踪与统计

已于 2024-10-06 22:17:15 修改
阅读量614 收藏 9
点赞数 13
分类专栏： 哈工大_操作系统 文章标签： 操作系统
于 2024-10-06 22:14:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53159274/article/details/142732749
版权

本节将更新哈工大《操作系统》课程第四个 Lab 实验 进程运行轨迹的跟踪与统计。按照实验书要求，介绍了非常详细的实验操作流程，并提供了超级无敌详细的代码注释。

实验目的：

  • 掌握 Linux 下的多进程编程技术；
  • 通过对进程运行轨迹的跟踪来形象化进程的概念；
  • 在进程运行轨迹跟踪的基础上进行相应的数据统计，从而能对进程调度算法进行实际的量化评价，更进一步加深对调度和调度算法的理解，获得能在实际操作系统上对调度算法进行实验数据对比的直接经验。

实验任务：

进程在其生命期中的运行轨迹实际上就表现为进程状态的多次切换，如进程创建以后会成为就绪态；当该进程被调度以后会切换到运行态；在运行的过程中如果启动了一个文件读写操作，操作系统会将该进程切换到阻塞态（等待态）从而让出 CPU；当文件读写完毕以后，操作系统会在将其切换成就绪态，等待进程调度算法来调度该进程执行……
1、基于模板 process.c 编写多进程的样本程序，实现如下功能： + 所有子进程都并行运行，每个子进程的实际运行时间一般不超过 30 秒； + 父进程向标准输出打印所有子进程的 id，并在所有子进程都退出后才退出；
2、在 Linux0.11 上实现进程运行轨迹的跟踪。 + 基本任务是在内核中维护一个日志文件 /var/process.log，把从操作系统启动到系统关机过程中所有进程的运行轨迹都记录在这一 log 文件中。
3、在修改过的 0.11 上运行样本程序，通过分析 log 文件，统计该程序建立的所有进程的等待时间、完成时间（周转时间）和运行时间，然后计算平均等待时间，平均完成时间和吞吐量。可以自己编写统计程序，也可以使用 python 脚本程序—— stat_log.py（在 /home/teacher/ 目录下） ——进行统计。
4、修改 0.11 进程调度的时间片，然后再运行同样的样本程序，统计同样的时间数据，和原有的情况对比，体会不同时间片带来的差异。

一、编写样本程序

编写 process.c 样本程序，实现函数模拟占用 CPU 和 I/O 时间

定义占用 CPU 和 I/O 时间函数：

/*
 * 此函数按照参数占用 CPU 和 I/O 时间
 * last            :     函数实际占用CPU和I/O的总时间，不含在就绪队列中的时间，>=0是必须的
 * cpu_time        :     一次连续占用CPU的时间，>=0是必须的
 * io_time        :     一次I/O消耗的时间，>=0是必须的
 * 如果 last > cpu_time + io_time，则往复多次占用CPU和I/O
 * 所有时间的单位为秒
 */
void cpuio_bound(int last, int cpu_time, int io_time)
{
    // tms 结构体记录 用户代码 和 内核代码 运行时间
    struct tms start_time, current_time;
    // 长整型，记录时钟滴答数
    clock_t utime, stime;
    int sleep_time;

    while (last > 0)
    {
        /* CPU Burst */
        times(&start_time);
        /* 其实只有t.tms_utime才是真正的CPU时间。但我们是在模拟一个
         * 只在用户状态运行的CPU大户，就像“for(;;);”。所以把t.tms_stime
         * 加上很合理。*/
        do
        {
            times(&current_time);
            utime = current_time.tms_utime - start_time.tms_utime;    // 进程执行用户代码时间
            stime = current_time.tms_stime - start_time.tms_stime;    // 进程执行内核代码时间
        } while ( ( (utime + stime) / HZ )  < cpu_time );            // 得到时钟滴答次数，乘10ms得到真正的时间
        last -= cpu_time;                                            // 运行CPU后剩余时间

        if (last <= 0 )
            break;

        /* IO Burst */
        /* 用sleep(1)模拟1秒钟的I/O操作 */
        sleep_time=0;
        while (sleep_time < io_time)
        {
            sleep(1);                            // 模拟 I/O操作 占用进程时间
            sleep_time++;
        }
        last -= sleep_time;                        // 运行 CPU + I/O 剩余时间
    }
}

创建多进程并调用占用时间函数

#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include <sys/times.h>
#include <sys/types.h>

#define HZ    100

void cpuio_bound(int last, int cpu_time, int io_time);
/*
1.  所有子进程都并行运行,每个子进程的实际运行时间一般不超过30秒;
2.  父进程向标准输出打印所有子进程的id,并在所有子进程都退出后才退出;
*/
int main(int argc, char * argv[])
{
    pid_t n_proc[10]; /*10个子进程 PID*/
    int i;
    for(i=0;i<10;i++)
    {
        n_proc[i] = fork();        // 父进程-返回子进程ID； 子进程-返回0
        /*子进程*/
        if(n_proc[i] == 0)
        {
            cpuio_bound(20,2*i,20-2*i);     /*每个子进程都占用20s*/
            return 0;                         /*执行完cpuio_bound 以后，结束该子进程*/
        }
        /*fork 失败*/
        else if(n_proc[i] < 0 )
        {
            printf("Failed to fork child process %d!\n",i+1);
            return -1;
        }
        /*父进程继续fork， 此处为父进程 */
        pid_t father = getpid();        // 获得进程标志符
        printf("Now is the father's pid: %d\n", father);
    }
    /*打印所有子进程PID*/
    for(i=0;i<10;i++)
        printf("Child PID: %d\n",n_proc[i]);
    /*等待所有子进程完成*/
    wait(&i);  /*Linux 0.11 上 gcc要求必须有一个参数, gcc3.4+则不需要*/ 
    return 0;
}

编译 process.c 样本程序

gcc -o myprocess process.c

二、维护日志文件

把从操作系统启动到系统关机过程中所有的进程运行轨迹都记录在log文件中

1、内核启动时就打开 process.log 文件

init/main.c 文件中添加如下代码：

//……
move_to_user_mode();

/***************添加开始***************/
setup((void *) &drive_info);
(void) open("/dev/tty0",O_RDWR,0);    
(void) dup(0);        
(void) dup(0);        
(void) open("/var/process.log",O_CREAT|O_TRUNC|O_WRONLY,0666);
/***************添加结束***************/

if (!fork()) {        /* we count on this going ok */
    init();
}
//……

其中 init() 函数建立了文件描述符 0、1 、2和/dev/tty0的关联，它们分别就是 stdin、stdout 和 stderr。这三者的值是系统标准。仿照将把 log 文件的描述符关联到 3。此后 fork() 将会继承这些文件描述符

2、编写向 log 文件写函数 fprintk

在内核状态下无法直接使用write()函数向log文件输出，因此需要自己编写函数。参考了 printk() 和 sys_write() 而写成，向 kernel/printk.c 文件中添加如下函数：

#include "linux/sched.h"
#include "sys/stat.h"

static char logbuf[1024];
int fprintk(int fd, const char *fmt, ...)
{
    va_list args;
    int count;
    struct file * file;
    struct m_inode * inode;

    va_start(args, fmt);
    count=vsprintf(logbuf, fmt, args);
    va_end(args);
/* 如果输出到stdout或stderr，直接调用sys_write即可 */
    if (fd < 3)
    {
        __asm__("push %%fs\n\t"
            "push %%ds\n\t"
            "pop %%fs\n\t"
            "pushl %0\n\t"
        /* 注意对于Windows环境来说，是_logbuf,下同 */
            "pushl $logbuf\n\t" 
            "pushl %1\n\t"
        /* 注意对于Windows环境来说，是_sys_write,下同 */
            "call sys_write\n\t" 
            "addl $8,%%esp\n\t"
            "popl %0\n\t"
            "pop %%fs"
            ::"r" (count),"r" (fd):"ax","cx","dx");
    }
    else    
/* 假定>=3的描述符都与文件关联。事实上，还存在很多其它情况，这里并没有考虑。*/
    {
    /* 从进程0的文件描述符表中得到文件句柄 */
        if (!(file=task[0]->filp[fd]))    
            return 0;
        inode=file->f_inode;

        __asm__("push %%fs\n\t"
            "push %%ds\n\t"
            "pop %%fs\n\t"
            "pushl %0\n\t"
            "pushl $logbuf\n\t"
            "pushl %1\n\t"
            "pushl %2\n\t"
            "call file_write\n\t"
            "addl $12,%%esp\n\t"
            "popl %0\n\t"
            "pop %%fs"
            ::"r" (count),"r" (file),"r" (inode):"ax","cx","dx");
    }
    return count;
}

使用示例：

// 向stdout打印正在运行的进程的ID
fprintk(1, "The ID of running process is %ld", current->pid); 

// 向log文件输出跟踪进程运行轨迹
fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'R', jiffies); 
// 进程id、进程状态、滴答数（开机以来经历多少个10ms）

3、向状态切换点添加输出log文件代码

需要对 /kernel 文件夹下的 fork.c, sched.c, exit.c 有所了解。linux 0.11中进程状态有三种：就绪（运行）、等待、退出。

  1. 新建进程时
    fork() -> sys_fork()-> kernel/system_call.s -> copy_process()，在 kernel/fork.c 文件中添加输出语句
int copy_process(int nr,……)
{
//    ……
// 设置 start_time 为 jiffies
    p->start_time = jiffies;
//  新建进程，向log文件输出，'N'-新建
    fprintk(3, "%ld\t%c\t%ld\n", p->pid, 'N', jiffies); 
//       ……
    p->state = TASK_RUNNING;    
//  设置进程状态为就绪，向log文件输出，'J'-就绪
    fprintk(3, "%ld\t%c\t%ld\n", p->pid, 'J', jiffies); 
    
    return last_pid;
}
  1. 进入睡眠态

修改 kenrel/sched.c 中的 sys_pause() 和 sleep_on() 和 interruptible_sleep_on()

int sys_pause(void)
{
	current->state = TASK_INTERRUPTIBLE;
    // 输出log文件
    if(current->pid != 0)
    	fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'W', jiffies);
	schedule();
	return 0;
}

void sleep_on(struct task_struct **p)
{
    struct task_struct *tmp;
//    ……
    tmp = *p;
// 仔细阅读，实际上是将 current 插入“等待队列”头部，tmp 是原来的头部
    *p = current;  
// 切换到睡眠态
    current->state = TASK_UNINTERRUPTIBLE; 

	// 输出log文件
    fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'W', jiffies); 

    schedule();  
	// 唤醒队列中的上一个（tmp）睡眠进程。
    if (tmp){
        tmp->state=0;
    	//  输出log文件
    	fprintk(3, "%ld\t%c\t%ld\n", tmp->pid, 'J', jiffies); }
}

void interruptible_sleep_on(struct task_struct **p)
{
    struct task_struct *tmp;
       …
    tmp=*p;
    *p=current;
repeat:    current->state = TASK_INTERRUPTIBLE;

    	   //  输出log文件
    		fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'W', jiffies); 
    schedule();

    if (*p && *p != current) { 
        (**p).state=0;
        //  输出log文件
    	fprintk(3, "%ld\t%c\t%ld\n", (*p)->pid, 'J', jiffies); 
        goto repeat;
    }
    *p=NULL;
    
    if (tmp){
        tmp->state=0;
    	//  输出log文件
    	fprintk(3, "%ld\t%c\t%ld\n", tmp->pid, 'J', jiffies); }
}

修改 exit.c 中的 sys_waitpid()

int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options)
{
//    ……
	if (flag) {
		if (options & WNOHANG)
			return 0;
		current->state=TASK_INTERRUPTIBLE;
        //  0号进程是守护进程，cpu空闲的时候一直在waiting，输出它的话是不会通过脚本检查的哦
        if(current->pid != 0)
        	fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'W', jiffies); 
		schedule();
//    ……
}
  1. 调度算法

调度程序在分配CPU时会修改进程状态，同样需要记录，修改 kernel/sched.c 中的 schedule()：

void schedule(void)
{
//    ……
            if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) &&
            (*p)->state==TASK_INTERRUPTIBLE) {
                (*p)->state=TASK_RUNNING;
                /*可中断睡眠 => 就绪*/
                fprintk(3,"%d\tJ\t%d\n",(*p)->pid,jiffies);
            }
                
        }

//    ……
    // 如果当前进程和 next 进程不一样，则输出log文件
    if(current->pid != task[next] ->pid)
    {
        // 当前进程由 运行 -> 就绪
        if(current->state == TASK_RUNNING)
            fprintk(3,"%d\tJ\t%d\n",current->pid,jiffies);
        // next进程由 就绪 -> 运行
        fprintk(3,"%d\tR\t%d\n",task[next]->pid,jiffies);
    }

    switch_to(next);
}
  1. 唤醒

修改 kernel/sched.c 中的 wake_ip()：

void wake_up(struct task_struct **p)
{
    if (p && *p) {
        (**p).state=0;
        // 唤醒 最后进入等待序列的 进程
        fprintk(3,"%d\tJ\t%d\n",(*p)->pid,jiffies);
        *p=NULL;
    }
}
  1. 进程退出

进程结束了运行或在半途中终止了运行，那么内核就需要释放该进程所占用的系统资源，在 kernel/exit.c 文件中添加输出log文件指令：

int do_exit(long code)
{
//    ……
	current->state = TASK_ZOMBIE;
	
    // 退出一个进程，输出log文件
    fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'E', jiffies); 
    
	current->exit_code = code;
	tell_father(current->father);
	schedule();
	return (-1);	/* just to suppress warnings */
}

总结：实现log进程全面跟踪，Linux0.11包括六种状态转移，

  • 就绪 到 运行 ：schedule()
  • 运行 到 就绪 ：schedule()
  • 运行 到 睡眠 ： sleep_on() 、interruptible_sleep_on()、sys_pause() 、sys_waitpid()
  • 睡眠 到 就绪 ：wake_up()
  • 新建
  • 退出

注意：系统无事可做的时候，进程 0 会不停地调用 sys_pause()，以激活调度算法。此时它的状态可以是等待态，等待有其它可运行的进程；也可以叫运行态，它是唯一一个在 CPU 上运行的进程，只不过运行的效果是等待。所以输出log文件时经常要判断当前进程pid是否为零，防止sys_pause() 不断输出log文件

编程输出log文件：

cd ~/my_space/OS_HIT/oslab_Lab3/linux-0.11
make     // 编译
cd ..
./run

// 在 Bochs 中查看 log 文件
more /var/process.log
sync   // 退出 bochs 时，刷新 cache，确保文件确实写入了磁盘。

// 将 process.log 取出到 Ubuntu
sudo ./mount-hdc
cd hdc/var
mv process.log ../..
// 此时即可在Ubuntu中查看log文件了

三、统计时间与调度算法修改

使用 python 代码计算数据统计，计算平均周转时间、平均等待时间和吞吐率

sudo apt-get install python
chmod +x stat_log.py
./stat_log.py process.log 0 1 2 3 4 5 -g | more

按照实验任务书，接下来需要修改时间片大小再进行统计。具体修改 include/linux/sched.h 文件中的 INIT_TASK 宏定义第三个值，即修改15为期望的时间片大小，再运行 stat_log.py 分析

#define INIT_TASK \
/* state etc */    { 0,15,15, \
/* signals */    0,{{},},0, \

依次将时间偏设为1，5，10，15，20，25，50，100，150后，经统计分析log文件可以发现：
1）在一定的范围内，平均等待时间，平均完成时间的变化随着时间片的增大而减小。这是因为在时间片小的情况下，cpu将时间耗费在调度切换上，所以平均等待时间增加。
2）超过一定的范围之后，这些参数将不再有明显的变化，这是因为在这种情况下，RR轮转调度就变成了FCFS先来先服务了。随着时间片的修改，吞吐量始终没有明显的变化，这是因为在单位时间内，系统所能完成的进程数量是不会变的。

_小猪沉塘
关注
专栏目录
哈工大操作系统实验课——进程运行轨迹的跟踪与统计（lab 4）
Ripplesding的博客
08-05 2148
I 实验题目 本次实验包括如下内容： 基于模板 process.c 编写多进程的样本程序，实现如下功能： + 所有子进程都并行运行，每个子进程的实际运行时间一般不超过 30 秒； + 父进程向标准输出打印所有子进程的 id，并在所有子进程都退出后才退出； 在 Linux0.11 上实现进程运行轨迹的跟踪。 + 基本任务是在内核中维护一个日志文件 /var/process.log，把从操作系统启动到系统关机过程中所有进程的运行轨迹都记录在这一 log 文件中。 在修改过的 0.11 上运行样本程序，通过分析
哈工大计算机系统Lab4 报告+源代码
08-25
报告.pdf、lab4_source_code.zip、README.txt 这篇内容主要涉及的是哈工大计算机系统课程实验第四部分（Lab4）的学习资源，包括实验报告和源代码。哈工大（HIT）作为中国知名的高等学府，其计算机科学与技术专业在...
哈工大操作系统实验3-进程运行轨迹的跟踪与统计
weixin_44992441的博客
03-19 571
wait是父进程调用的，表面上功能是使父进程阻塞自己，直到子讲程调用exit结束运行，然后获得子进程的返回值，本质上是内核在幕后将子进程的返回值传递给父进程并会唤醒父进程，然后将子进程的pcb 回收。只要调用了waiit系统调用，若没有子进程，wait会返回-1，若有子进程，该进程会被阻塞，当其某个子进程退出了，会将子进程退出的值返回给父进程，并将父进程唤醒。总结来说，使用了fork（）函数，程序末尾出现wait()函数是为了防止僵尸进程的出现，进而防止僵尸进程过多导致进程加载失败。
哈工大 操作系统 lab3 进程运行轨迹的跟踪与统计解答
NULL
12-19 885
实验内容 进程从创建(Linux下调用fork())到结束的整个过程就是进程的生命期，进程在其生命期中的运行轨迹实际上就表现为进程状态的多次切换，如进程创建以后会成为就绪态；当该进程被调度以后会切换到运行态；在运行的过程中如果启动了一个文件读写操作，操作系统会将该进程切换到阻塞态(等待态)从而让出CPU；当文件读写完毕以后，操作系统会在将其切换成就绪态，等待进程调度算法来调度该进程执行…… 本次...
哈工大操作系统实验---lab3:进程运行轨迹的跟踪与统计
东瓜blog
04-28 2124
实验目的: 掌握Linux下的多进程编程技术 通过对进程运行轨迹的跟踪来形象化进程的概念 在进程运行轨迹跟踪的基础上进行相应的数据统计，从而能对进程调度算进行实际的量化评价，更进一步加深对调度和调度算法的理解，获得能在实际操作系统上对调度算法进行实验数据对比的直接经验。 实验内容: 基于模板“process.c”编写多进程的样本程序，实现如下功能： 所有子进程都并行运行，每个子进程的实际运...
哈工大操作系统配套实验Lab4（进程运行轨迹的跟踪与统计）
weixin_45672701的博客
10-11 337
单进程与多进程编程的最大区别就是要考虑切换之间的开销，因为单进程没有优先级调度之说，它就是在一个接着一个顺序执行，遇到IO会进行等待，而多进程是将原本单进程IO等待时间用来执行其他进程，这就导致我们要考虑如何调度才能使得多个进程尽可能的多使用CPU，而减少等待时间。时间片的初始值是进程0的priority，是在linux-0.11/include/linux/sched.h的宏 INIT_TASK中定义的，如下：我们只需要修改宏中的第三个值即可，该值即时间片的初始值。将时间片增大，进程之间的切换会较少。
操作系统实验3：进程运行轨迹的跟踪与统计
qq_70244454的博客
10-26 2178
进程
哈工大-操作系统-HitOSlab-李治军-实验3-进程运行的轨迹跟踪与统计
garbage_man的博客
07-25 4955
参考文献： 1.Linux中wait()函数 2.linux中fork()函数详解 3.Linux中的stdout和stderr 4.linux文件描述符限制及使用详解
进程运行的轨迹跟踪与统计
m0_51474171的博客
01-15 2103
0.实验内容 基于模板 process.c 编写多进程的样本程序，实现如下功能： + 所有子进程都并行运行，每个子进程的实际运行时间一般不超过 30 秒； + 父进程向标准输出打印所有子进程的 id，并在所有子进程都退出后才退出； 在 Linux0.11 上实现进程运行轨迹的跟踪。 + 基本任务是在内核中维护一个日志文件 /var/process.log，把从操作系统启动到系统关机过程中所有进程的运行轨迹都记录在这一 log 文件中。 在修改过的 0.11 上运行样本程序，通过分析 log 文件，统计该程
哈工大操作系统之进程与线程（Lab3 进程运行轨迹的跟踪与统计 超详细全流程分析)
Love 6's Private Blog
05-27 1262
文章目录链接printk.c初版 链接 操作系统中进程的实现 PCB结构（Task_struct) 讲解 UNIX系统中struct tms 分析《转载》 Linux多任务编程（六）—编写多进程程序及其代码 printk.c // 向stdout打印正在运行的进程的ID fprintk(1, "The ID of running process is %ld", current->pid); // 向log文件输出跟踪进程运行轨迹 fprintk(3, "%ld\t%c\t%ld\n"
LAB4 进程运行轨迹的跟踪与统计
diaobao3822的博客
06-02 632
进程运行轨迹的跟踪与统计 1. 课程说明 难度系数：★★★☆☆ 本实验是 操作系统之进程与线程 - 网易云课堂 的配套实验，推荐大家进行实验之前先学习相关课程： L8 CPU 管理的直观想法 L9 多进程图像 Tips：点击上方文字中的超链接或者输入 https://mooc.study.163.com/course/1000002008#/info 进入理论课程的学习。 如果网易云上的课程无法查看，也可以看 Bilibili 上的 操作系统哈尔滨工业大学李治军老师。 2. 实验目的 掌握 Lin
jos.rar_JOS lab_lab2_lab2 操作系统_操作系统 lab2_操作系统lab2
09-19
4. **系统调用**：系统调用是用户程序与操作系统交互的接口。在Lab2中，学生将学会如何通过中断机制来实现系统调用，比如创建新进程、读写文件等基本操作。 5. **I/O操作**：输入/输出是操作系统与硬件通信的关键。...
jincheng.rar_operating system lab_操作系统进程调度
09-22
在操作系统中，进程调度是一项至关重要的任务，它决定了哪个进程可以在CPU上执行以及执行多长时间。本实验报告主要围绕“操作系统进程调度”这一主题展开，通过实际的代码实现，帮助我们深入理解这一概念。 在操作...
OS_lab3_内存管理与调度策略_操作系统实验_优化_
10-02
在"OS_lab3_内存管理与调度策略_操作系统实验_优化_"这个主题中，我们将深入探讨内存管理的基本策略，包括段页式管理，以及如何设计和优化内存调度算法，并理解如何评估操作系统的内存性能。 1. **内存管理策略**：...
鸿蒙开发（NEXT/API 12）【申请接入Wear Engine服务】 穿戴服务
鸿蒙的技术博客
09-30 828
申请Wear Engine服务前（开发者需实名认证为个人开发者或者企业开发者，认证前，请先了解二者的[权益区别] ），确认开发环境并完成创建项目、创建HarmonyOS应用等基本准备工作，再继续进行以下开发活动。
Linux 性能优化之CPU 多级缓存
山河已无恙
09-30 891
博文内容为 Linux CPU 多级缓存认知内容涉及：什么是CPU多级缓存认知，CPU 硬件缓存信息，缓存流程写入策略，映射算法认知CPU 缓存分析，使用 valgring 和 Perf 分析CPU 缓存命中情况编码方面 CPU 缓存优化，数据指令缓存，多核缓存命中率优化方式理解不足小伙伴帮忙指正 😃,生活加油哦99%的焦虑都来自于虚度时间和没有好好做事，所以唯一的解决办法就是行动起来，认真做完事情，战胜焦虑，战胜那些心里空荡荡的时刻，而不是选择逃避。
Linux 再入门整理：详解 /etc/fstab 文件
最新发布
一只奋斗的猪
10-01 1193
`/etc/fstab` 文件是 Linux 系统中用于定义和管理文件系统的挂载信息的配置文件。它的作用是告诉系统在启动时，应该如何自动挂载各种文件系统。挂载是 Linux 操作系统中一种将存储设备与目录树关联的操作。通过挂载，存储设备中的文件可以通过目录访问。
使用Python实现在 Linux 和 Windows 之间的双向文件传输
2301_80892630的博客
09-29 713
在 Linux 和 Windows 之间可以用python程序实现双向文件传输，通过创建一个简单的文件传输程序来实现。该程序将使用套接字socket通信，允许任意一端发送或接收文件。这是在我的那篇实现python两个进程之间相互通信的基础上拓展的（不过只看这一篇文章也行），那篇文章传输的数据是字符串类型，今天我来实现文件的传输。
Linux嵌入式有发展吗，以及对uboot，kernel，rootfs的领悟
rjszcb的博客
09-30 807
上一份工作是2022,11—2023，11年底，汽车公司，底层修修改改，编译镜像，修改后，客户给东西，重新编译给他，客制化配置启动参数，环境，支持应用部门，不懂怎么使用某些驱动。uboot到底是干嘛的，想想，emmc的镜像文件是怎么被读到ddr的，emmc为啥可以被分区，烧录镜像，tftp网络命令为啥可以运行，启动设备时，为啥lcd可以看到图像，kernel还没启动，怎么出图像的。不管做应用开发，驱动开发也好，知道，系统原理，驱动框架，进程管理调度，内核竞争，信号，中断，锁，这些就够了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

_小猪沉塘

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

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

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

打赏作者

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

抵扣说明：

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

余额充值