&emsp;&emsp;百万汉字注解 >> 精读鸿蒙源码,中文注解分析, 深挖地基工程,大脑永久记忆,四大码仓每日同步更新< gitee | github | csdn | coding > 百篇博客分析 >> 故事说内核,问答式导读,生活式比喻,表格…

                                                                                                                                                                                    百万汉字注解 >> 精读鸿蒙源码,中文注解分析, 深挖地基工程,大脑永久记忆,四大码仓每日同步更新< gitee | github | csdn | coding >

百篇博客分析 >> 故事说内核,问答式导读,生活式比喻,表格化说明,图形化展示,主流站点定期更新中< oschina | csdn | harmony >

三个进程

鸿蒙有三个特殊的进程,创建顺序如下:

2号进程,

1
KProcess

,为内核态根进程.启动过程中创建.
0号进程,
1
KIdle

为内核态第二个进程,它是通过
1
KProcess

fork 而来的.这有点难理解.
1号进程,
1
init

,为用户态根进程.由任务
1
SystemInit

创建.

Test

发现没有在图中看不到0号进程,在看完本篇之后请想想为什么?

家族式管理

进程(process)是家族式管理,总体分为两大家族,用户态家族和内核态家族.
用户态的进程是平民阶层,屌丝矮矬穷,干着各行各业的活,权利有限,人数众多,活动范围有限(用户空间).中南海肯定不能随便进出.这个阶层有个共同的老祖宗g_userInitProcess (1号进程).

1
2
3
4
5
6
7
  g_userInitProcess = 1; /* 1: The root process ID of the user-mode process is fixed at 1 *///用户态的根进程
//获取用户态进程的根进程,所有用户进程都是g_processCBArray[g_userInitProcess] fork来的
LITE_OS_SEC_TEXT UINT32 OsGetUserInitProcessID(VOID)
{
    return g_userInitProcess;
}

内核态的进程是贵族阶层,管理平民阶层的,维持平民生活秩序的,拥有超级权限,能访问整个空间和所有资源,人数不多.这个阶层老祖宗是 g_kernelInitProcess(2号进程).

1
2
3
4
5
6
7
  g_kernelInitProcess = 2; /* 2: The root process ID of the kernel-mode process is fixed at 2 *///内核态的根进程
//获取内核态进程的根进程,所有内核进程都是g_processCBArray[g_kernelInitProcess] fork来的,包括g_processCBArray[g_kernelIdleProcess]进程
LITE_OS_SEC_TEXT UINT32 OsGetKernelInitProcessID(VOID)
{
    return g_kernelInitProcess;
}

两位老祖宗都不是通过fork来的,而是内核强制规定进程ID号,强制写死基因创建的.
这两个阶层可以相互流动吗,有没有可能通过高考改变命运? 答案是: 绝对冇可能!!! 龙生龙,凤生凤,老鼠生儿会打洞.从老祖宗创建的那一刻起就被刻在基因里了,抹不掉了. 因为后续所有的进程都是由这两位老同志克隆(clone)来的,没得商量的继承这份基因.

1
LosProcessCB

有专门的标签来
1
processMode

区分这两个阶层.整个鸿蒙内核源码并没有提供改变命运机会的
1
set

函数.
1
2
3
4
5
6
7
8
9
10
11
  #define OS_KERNEL_MODE 0x0U	//内核态
#define OS_USER_MODE   0x1U	//用户态
STATIC INLINE BOOL OsProcessIsUserMode(const LosProcessCB *processCB)//用户模式进程
{
    return (processCB->processMode == OS_USER_MODE);
}
typedef struct ProcessCB {
    // ...
    UINT16               processMode;                  /**< Kernel Mode:0; User Mode:1; */	//0位内核态,1为用户态进程
} LosProcessCB;

2号进程 KProcess

2号进程为内核态的老祖宗,是内核创建的首个进程,源码过程如下,省略了不相干的代码.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
  bl     main  @带LR的子程序跳转, LR = pc - 4 ,执行C层main函数
/******************************************************************************
内核入口函数,由汇编调用,见于reset_vector_up.S 和 reset_vector_mp.S
up指单核CPU, mp指多核CPU bl        main
******************************************************************************/
LITE_OS_SEC_TEXT_INIT INT32 main(VOID)//由主CPU执行,默认0号CPU 为主CPU 
{
    // ... 省略
    uwRet = OsMain();// 内核各模块初始化
}
LITE_OS_SEC_TEXT_INIT INT32 OsMain(VOID)
{
    // ... 
    ret = OsKernelInitProcess();// 创建内核态根进程
    // ...
    ret = OsSystemInit(); //中间创建了用户态根进程
}
//初始化 2号进程,即内核态进程的老祖宗
LITE_OS_SEC_TEXT_INIT UINT32 OsKernelInitProcess(VOID)
{
    LosProcessCB *processCB = NULL;
    UINT32 ret;

    ret = OsProcessInit();// 初始化进程模块全部变量,创建各循环双向链表
    if (ret != LOS_OK) {
        return ret;
    }

    processCB = OS_PCB_FROM_PID(g_kernelInitProcess);// 以PID方式得到一个进程
    ret = OsProcessCreateInit(processCB, OS_KERNEL_MODE, "KProcess", 0);// 初始化进程,最高优先级0,鸿蒙进程一共有32个优先级(0-31) 其中0-9级为内核进程,用户进程可配置的优先级有22个(10-31)
    if (ret != LOS_OK) {
        return ret;
    }

    processCB->processStatus &= ~OS_PROCESS_STATUS_INIT;// 进程初始化位 置1
    g_processGroup = processCB->group;//全局进程组指向了KProcess所在的进程组
    LOS_ListInit(&g_processGroup->groupList);// 进程组链表初始化
    OsCurrProcessSet(processCB);// 设置为当前进程
    return OsCreateIdleProcess();// 创建一个空闲状态的进程
}

解读

main函数在系列篇中会单独讲,请留意自行翻看,它是在开机之初在SVC模式下创建的.
内核态老祖宗的名字叫

1
KProcess

,优先级为最高 0 级,
1
KProcess

进程是长期活跃的,很多重要的任务都会跑在其之下.例如:

1
Swt_Task
1
oom_task
1
system_wq
1
tcpip_thread
1
SendToSer
1
SendToTelnet
1
eth_irq_task
1
TouchEventHandler
1
USB_GIANT_Task

此处不细讲这些任务,在其他篇幅有介绍,但光看名字也能猜个八九,请自行翻看.

紧接着

1
KProcess

以
1
CLONE_FILES

的方式 fork了一个 名为
1
KIdle

的子进程(0号进程).
内核态的所有进程都来自2号进程这位老同志,子子孙孙,代代相传,形成一颗家族树,和人类的传承所不同的是,它们往往是白发人送黑发人,子孙进程往往都是短命鬼,老祖宗最能活,子孙都死绝了它还在,有些收尸的工作要交给它干.

0 号进程 KIdle

0号进程是内核创建的第二个进程,在

1
OsKernelInitProcess

的末尾将
1
KProcess

设为当前进程后,紧接着就
1
fork

了0号进程.为什么一定要先设置当前进程,因为fork需要一个父进程,而此时系统处于启动阶段,并没有当前进程. 是的,您没有看错.进程是操作系统为方便管理资源而衍生出来的概念,系统并不是非要进程,任务才能运行的. 开机阶段就是啥都没有,默认跑在svc模式下,默认起始地址
1
reset_vector

都是由硬件上电后规定的. 进程,线程都是跑起来后慢慢赋予的意义.
1
OsCurrProcessSet

是从软件层面赋予了此为当前进程的这个概念.
1
KProcess

是内核设置的第一个当前进程.有了它,就可以fork, fork, fork !

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
  //创建一个名叫"KIdle"的0号进程,给CPU空闲的时候使用
STATIC UINT32 OsCreateIdleProcess(VOID)
{
    UINT32 ret;
    CHAR *idleName = "Idle";
    LosProcessCB *idleProcess = NULL;
    Percpu *perCpu = OsPercpuGet();
    UINT32 *idleTaskID = &perCpu->idleTaskID;//得到CPU的idle task

    ret = OsCreateResourceFreeTask();// 创建一个资源回收任务,优先级为5 用于回收进程退出时的各种资源
    if (ret != LOS_OK) {
        return ret;
    }
	//创建一个名叫"KIdle"的进程,并创建一个idle task,CPU空闲的时候就待在 idle task中等待被唤醒
    ret = LOS_Fork(CLONE_FILES, "KIdle", (TSK_ENTRY_FUNC)OsIdleTask, LOSCFG_BASE_CORE_TSK_IDLE_STACK_SIZE);
    if (ret < 0) {//内核进程的fork并不会一次调用,返回两次,此子进程执行的开始位置是参数OsIdleTask
        return LOS_NOK;
    }
    g_kernelIdleProcess = (UINT32)ret;//返回 0号进程

    idleProcess = OS_PCB_FROM_PID(g_kernelIdleProcess);//通过ID拿到进程实体
    *idleTaskID = idleProcess->threadGroupID;//绑定CPU的IdleTask,或者说改变CPU现有的idle任务
    OS_TCB_FROM_TID(*idleTaskID)->taskStatus |= OS_TASK_FLAG_SYSTEM_TASK;//设定Idle task 为一个系统任务
#if (LOSCFG_KERNEL_SMP == YES)
    OS_TCB_FROM_TID(*idleTaskID)->cpuAffiMask = CPUID_TO_AFFI_MASK(ArchCurrCpuid());//多核CPU的任务指定,防止乱串了,注意多核才会有并行处理
#endif
    (VOID)memset_s(OS_TCB_FROM_TID(*idleTaskID)->taskName, OS_TCB_NAME_LEN, 0, OS_TCB_NAME_LEN);//task 名字先清0
    (VOID)memcpy_s(OS_TCB_FROM_TID(*idleTaskID)->taskName, OS_TCB_NAME_LEN, idleName, strlen(idleName));//task 名字叫 idle
    return LOS_OK;
}

解读

看过fork篇的可能发现了一个参数,

1
KIdle

被创建的方式和通过系统调用创建的方式不一样,一个用的是
1
CLONE_FILES

,一个是
1
CLONE_SIGHAND

具体的创建方式如下:
1
2
3
4
5
6
7
8
9
  #define CLONE_VM       0x00000100	//子进程与父进程运行于相同的内存空间
#define CLONE_FS       0x00000200	//子进程与父进程共享相同的文件系统，包括root、当前目录、umask
#define CLONE_FILES    0x00000400	//子进程与父进程共享相同的文件描述符（file descriptor）表
#define CLONE_SIGHAND  0x00000800	//子进程与父进程共享相同的信号处理（signal handler）表
#define CLONE_PTRACE   0x00002000	//若父进程被trace，子进程也被trace
#define CLONE_VFORK    0x00004000	//父进程被挂起，直至子进程释放虚拟内存资源
#define CLONE_PARENT   0x00008000	//创建的子进程的父进程是调用者的父进程，新进程与创建它���进程成了“兄弟”而不是“父子”
#define CLONE_THREAD   0x00010000	//Linux 2.4中增加以支持POSIX线程标准，子进程与父进程共享相同的线程群

1
KIdle

创建了一个名为

1
Idle

的任务,任务的入口函数为
1
OsIdleTask

,这是个空闲任务,啥也不干的.专门用来给cpu休息的,cpu空闲时就待在这个任务里等活干.
1
2
3
4
5
6
7
8
9
10
11
12
13
  LITE_OS_SEC_TEXT WEAK VOID OsIdleTask(VOID)
{
    while (1) {//只有一个死循环
#ifdef LOSCFG_KERNEL_TICKLESS //低功耗模式开关, idle task 中关闭tick
        if (OsTickIrqFlagGet()) {
            OsTickIrqFlagSet(0);
            OsTicklessStart();
        }
#endif
        Wfi();//WFI指令:arm core 立即进入low-power standby state，进入休眠模式,等待中断.
    }
}

fork 内核态进程和fork用户态进程有个地方会不一样,就是SP寄存器的值.fork用户态的进程一次调用两次返回(父子进程各一次),返回的位置一样(是因为拷贝了父进程陷入内核时的上下文).所以可以通过返回值来判断是父还是子返回.这个在fork篇中有详细的描述.请自行翻看. 但fork内核态进程虽也有两次返回,但是返回的位置却不一样,子进程的返回位置是由内核指定的,例如:

1
Idle

任务的入口函数为
1
OsIdleTask

.详见代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//任务初始化时拷贝任务信息
STATIC VOID OsInitCopyTaskParam(LosProcessCB *childProcessCB, const CHAR *name, UINTPTR entry, UINT32 size,
                                TSK_INIT_PARAM_S *childPara)
{
    LosTaskCB *mainThread = NULL;
    UINT32 intSave;

    SCHEDULER_LOCK(intSave);
    mainThread = OsCurrTaskGet();//获取当前task,注意变量名从这里也可以看出 thread 和 task 是一个概念,只是内核常说task,上层应用说thread ,概念的映射.

    if (OsProcessIsUserMode(childProcessCB)) {//用户态进程
        childPara->pfnTaskEntry = mainThread->taskEntry;//拷贝当前任务入口地址
        childPara->uwStackSize = mainThread->stackSize;	//栈空间大小
        childPara->userParam.userArea = mainThread->userArea;		//用户态栈区栈顶位置
        childPara->userParam.userMapBase = mainThread->userMapBase;	//用户态栈底
        childPara->userParam.userMapSize = mainThread->userMapSize;	//用户态栈大小
    } else {//注意内核态进程创建任务的入口由外界指定,例如 OsCreateIdleProcess 指定了OsIdleTask
        childPara->pfnTaskEntry = (TSK_ENTRY_FUNC)entry;//参数(sp)为内核态入口地址
        childPara->uwStackSize = size;//参数(size)为内核态栈大小
    }
    childPara->pcName = (CHAR *)name;					//拷贝进��名字
    childPara->policy = mainThread->policy;				//拷贝调度模式
    childPara->usTaskPrio = mainThread->priority;		//拷贝优先级
    childPara->processID = childProcessCB->processID;	//拷贝进程ID
    if (mainThread->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {
        childPara->uwResved = OS_TASK_FLAG_PTHREAD_JOIN;
    } else if (mainThread->taskStatus & OS_TASK_FLAG_DETACHED) {
        childPara->uwResved = OS_TASK_FLAG_DETACHED;
    }

    SCHEDULER_UNLOCK(intSave);
}

结论是创建0号进程中的

1
OsCreateIdleProcess

调用
1
LOS_Fork

后只会有一次返回.而且返回值为0,因为
1
g_freeProcess

中0号进程还没有被分配.详见代码,注意看最后的注释:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//进程模块初始化,被编译放在代码段 .init 中
LITE_OS_SEC_TEXT_INIT UINT32 OsProcessInit(VOID)
{
    UINT32 index;
    UINT32 size;

    g_processMaxNum = LOSCFG_BASE_CORE_PROCESS_LIMIT;//默认支持64个进程
    size = g_processMaxNum * sizeof(LosProcessCB);//算出总大小

    g_processCBArray = (LosProcessCB *)LOS_MemAlloc(m_aucSysMem1, size);// 进程池，占用内核堆,内存池分配 
    if (g_processCBArray == NULL) {
        return LOS_NOK;
    }
    (VOID)memset_s(g_processCBArray, size, 0, size);//安全方式重置清0

    LOS_ListInit(&g_freeProcess);//进程空闲链表初始化，创建一个进程时从g_freeProcess中申请一个进程描述符使用
    LOS_ListInit(&g_processRecyleList);//进程回收链表初始化,回收完成后进入g_freeProcess等待再次被申请使用

    for (index = 0; index < g_processMaxNum; index++) {//进程池循环创建
        g_processCBArray[index].processID = index;//进程ID[0-g_processMaxNum-1]赋值
        g_processCBArray[index].processStatus = OS_PROCESS_FLAG_UNUSED;// 默认都是白纸一张,贴上未使用标签
        LOS_ListTailInsert(&g_freeProcess, &g_processCBArray[index].pendList);//注意g_freeProcess挂的是pendList节点,所以使用要通过OS_PCB_FROM_PENDLIST找到进程实体.
    }

    g_userInitProcess = 1; /* 1: The root process ID of the user-mode process is fixed at 1 *///用户态的根进程
    LOS_ListDelete(&g_processCBArray[g_userInitProcess].pendList);// 将1号进程从空闲链表上摘出去

    g_kernelInitProcess = 2; /* 2: The root process ID of the kernel-mode process is fixed at 2 *///内核态的根进程
    LOS_ListDelete(&g_processCBArray[g_kernelInitProcess].pendList);// 将2号进程从空闲链表上摘出去

    //注意:这波骚操作之后,g_freeProcess链表上还有,0,3,4,...g_processMaxNum-1号进程.创建进程是从g_freeProcess上申请
    //即下次申请到的将是0号进程,而 OsCreateIdleProcess 将占有0号进程.

    return LOS_OK;
}

1号进程 init

1号进程为用户态的老祖宗.创建过程如下, 省略了不相干的代码.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
  LITE_OS_SEC_TEXT_INIT INT32 OsMain(VOID)
{
    // ... 
    ret = OsKernelInitProcess();// 创建内核态根进程
    // ...
    ret = OsSystemInit(); //中间创建了用户态根进程
}
UINT32 OsSystemInit(VOID)
{
    //..
    ret = OsSystemInitTaskCreate();//创建了一个系统任务,
}

STATIC UINT32 OsSystemInitTaskCreate(VOID)
{
    UINT32 taskID;
    TSK_INIT_PARAM_S sysTask;

    (VOID)memset_s(&sysTask, sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
    sysTask.pfnTaskEntry = (TSK_ENTRY_FUNC)SystemInit;//任务的入口函数，这个函数实现由外部提供
    sysTask.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;//16K
    sysTask.pcName = "SystemInit";//任务的名称
    sysTask.usTaskPrio = LOSCFG_BASE_CORE_TSK_DEFAULT_PRIO;// 内核默认优先级为10 
    sysTask.uwResved = LOS_TASK_STATUS_DETACHED;//任务分离模式
#if (LOSCFG_KERNEL_SMP == YES)
    sysTask.usCpuAffiMask = CPUID_TO_AFFI_MASK(ArchCurrCpuid());//cpu 亲和性设置,记录执行过任务的CPU,尽量确保由同一个CPU完成任务周期
#endif
    return LOS_TaskCreate(&taskID, &sysTask);//创建任务并加入就绪队列，并立即参与调度
}
//SystemInit的实现由由外部提供 比如..\vendor\hi3516dv300\module_init\src\system_init.c
void SystemInit(void)
{
    // ...
    if (OsUserInitProcess()) {//创建用户态进程的老祖宗
        PRINT_ERR("Create user init process faialed!\n");
        return;
    }
}
//用户态根进程的创建过程
LITE_OS_SEC_TEXT_INIT UINT32 OsUserInitProcess(VOID)
{
    INT32 ret;
    UINT32 size;
    TSK_INIT_PARAM_S param = { 0 };
    VOID *stack = NULL;
    VOID *userText = NULL;
    CHAR *userInitTextStart = (CHAR *)&__user_init_entry;//代码区开始位置 ,对应 LITE_USER_SEC_ENTRY
    CHAR *userInitBssStart = (CHAR *)&__user_init_bss;// 未初始化数据区（BSS）。在运行时改变其值 对应 LITE_USER_SEC_BSS
    CHAR *userInitEnd = (CHAR *)&__user_init_end;// 结束地址
    UINT32 initBssSize = userInitEnd - userInitBssStart;
    UINT32 initSize = userInitEnd - userInitTextStart;

    LosProcessCB *processCB = OS_PCB_FROM_PID(g_userInitProcess);//"Init进程的优先级是 28"
    ret = OsProcessCreateInit(processCB, OS_USER_MODE, "Init", OS_PROCESS_USERINIT_PRIORITY);// 初始化用户进程,它将是所有应用程序的父进程
    if (ret != LOS_OK) {
        return ret;
    }

    userText = LOS_PhysPagesAllocContiguous(initSize >> PAGE_SHIFT);// 分配连续的物理页
    if (userText == NULL) {
        ret = LOS_NOK;
        goto ERROR;
    }

    (VOID)memcpy_s(userText, initSize, (VOID *)&__user_init_load_addr, initSize);// 安全copy 经加载器load的结果 __user_init_load_addr -> userText
    ret = LOS_VaddrToPaddrMmap(processCB->vmSpace, (VADDR_T)(UINTPTR)userInitTextStart, LOS_PaddrQuery(userText),
                               initSize, VM_MAP_REGION_FLAG_PERM_READ | VM_MAP_REGION_FLAG_PERM_WRITE |
                               VM_MAP_REGION_FLAG_PERM_EXECUTE | VM_MAP_REGION_FLAG_PERM_USER);// 虚拟地址与物理地址的映射
    if (ret < 0) {
        goto ERROR;
    }

    (VOID)memset_s((VOID *)((UINTPTR)userText + userInitBssStart - userInitTextStart), initBssSize, 0, initBssSize);// 除了代码段，其余都清0

    stack = OsUserInitStackAlloc(g_userInitProcess, &size);//分配任务在用户态下的运行栈,大小为1M
    if (stack == NULL) {
        PRINTK("user init process malloc user stack failed!\n");
        ret = LOS_NOK;
        goto ERROR;
    }

    param.pfnTaskEntry = (TSK_ENTRY_FUNC)userInitTextStart;// 从代码区开始执行，也就是应用程序main 函数的位置
    param.userParam.userSP = (UINTPTR)stack + size;// 用户态栈底
    param.userParam.userMapBase = (UINTPTR)stack;// 用户态栈顶
    param.userParam.userMapSize = size;// 用户态栈大小
    param.uwResved = OS_TASK_FLAG_PTHREAD_JOIN;// 可结合的（joinable）能够被其他线程收回其资源和杀死
    ret = OsUserInitProcessStart(g_userInitProcess, &param);// 创建一个任务，来运行main函数
    if (ret != LOS_OK) {
        (VOID)OsUnMMap(processCB->vmSpace, param.userParam.userMapBase, param.userParam.userMapSize);
        goto ERROR;
    }

    return LOS_OK;

ERROR:
    (VOID)LOS_PhysPagesFreeContiguous(userText, initSize >> PAGE_SHIFT);//释放物理内存块
    OsDeInitPCB(processCB);//删除PCB块
    return ret;
}

解读

从代码中可以看出用户态的老祖宗创建过程有点意思,首先它的源头和内核态老祖宗一样都在

1
OsMain

.
通过创建一个分离模式,优先级为10的系统任务
1
SystemInit

,来完成.任务的入口函数
1
SystemInit()

的实现由平台集成商来指定. 本篇采用了
1
hi3516dv300

的实现.也就是说用户态祖宗的创建是在
1
sysTask.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;//16K

栈中���成的.这个任务归属于内核进程
1
KProcess

.
用户态老祖宗的名字叫
1
Init

,优先级为28级.
用户态的每个进程有独立的虚拟进程空间
1
vmSpace

,拥有独立的内存映射表(L1,L2表),申请的内存需要重新映射,映射过程在内存系列篇中有详细的说明.

1
init

创建了一个任务,任务的入口地址为

1
__user_init_entry

,由编译器指定.
用户态进程是指应有程序运行的进程,通过动态加载ELF文件的方式启动.具体加载流程系列篇有讲解,不细说.用户态进程运行在用户空间,但通过系统调用可陷入内核空间.具体看这张图: Test

鸿蒙源码百篇博客 往期回顾

v46.xx (特殊进程篇) | 龙生龙,凤生凤,老鼠生儿会打洞 < csdn | harmony >
v45.xx (fork篇) | fork是如何做到调用一次,返回两次的 ? < csdn | harmony >
v44.xx (中断管理篇) | 硬中断的实现<>观察者模式 < csdn | harmony >
v43.xx (中断概念篇) | 外人眼中权势滔天的当红海公公 < csdn | harmony >
v42.xx (中断切换篇) | 中断切换到底在切换什么? < csdn | harmony >
v41.xx (任务切换篇) | 汇编逐行注解分析任务上下文 < csdn | harmony >
v40.xx (汇编汇总篇) | 所有的汇编代码都在这里 < csdn | harmony >
v39.xx (异常接管篇) | 社会很单纯,复杂的是人 < csdn | harmony >
v38.xx (寄存器篇) | ARM所有寄存器一网打尽,不再神秘 < csdn | harmony >
v37.xx (系统调用篇) | 全盘解剖系统调用实现过程 < csdn | harmony >
v36.xx (工作模式篇) | CPU是韦小宝,有哪七个老婆? < csdn | harmony >
v35.xx (时间管理篇) | Tick是操作系统的基本时间单位 < csdn | harmony >
v34.xx (原子操作篇) | 是谁在为原子操作保驾护航? < csdn | harmony >
v33.xx (消息队列篇) | 进程间如何异步解耦传递大数据 ? < csdn | harmony >
v32.xx (CPU篇) | 内核是如何描述CPU的? < csdn | harmony >
v31.xx (定时器篇) | 内核最高优先级任务是谁? < csdn | harmony >
v30.xx (事件控制篇) | 任务间多对多的同步方案 < csdn | harmony >
v29.xx (信号量篇) | 信号量解决任务同步问题 < csdn | harmony >
v28.xx (进程通讯篇) | 进程间通讯有哪九大方式? < csdn | harmony >
v27.xx (互斥锁篇) | 互斥锁比自旋锁可丰满许多 < csdn | harmony >
v26.xx (自旋锁篇) | 真的好想为自旋锁立贞节牌坊! < csdn | harmony >
v25.xx (并发并行篇) | 怎么记住并发并行的区别? < csdn | harmony >
v24.xx (进程概念篇) | 进程在管理哪些资源? < csdn | harmony >
v23.xx (汇编传参篇) | 汇编如何传递复杂的参数? < csdn | harmony >
v22.xx (汇编基础篇) | CPU在哪里打卡上班? < csdn | harmony >
v21.xx (线程概念篇) | 是谁在不断的折腾CPU? < csdn | harmony >
v20.xx (用栈方式篇) | 栈是构建底层运行的基础 < csdn | harmony >
v19.xx (位图管理篇) | 为何进程和线程优先级都是32个? < csdn | harmony >
v18.xx (源码结构篇) | 内核500问你能答对多少? < csdn | harmony >
v17.xx (物理内存篇) | 这样记伙伴算法永远不会忘 < csdn | harmony >
v16.xx (内存规则篇) | 内存管理到底在管什么? < csdn | harmony >
v15.xx (内存映射篇) | 什么是内存最重要的实现基础 ? < csdn | harmony >
v14.xx (内存汇编篇) | 什么是虚拟内存的实现基础? < csdn | harmony >
v13.xx (源码注释篇) | 热爱是所有的理由和答案 < csdn | harmony >
v12.xx (内存管理篇) | 虚拟内存全景图是怎样的? < csdn | harmony >
v11.xx (内存分配篇) | 内存有哪些分配方式? < csdn | harmony >
v10.xx (内存主奴篇) | 紫禁城的主子和奴才如何相处? < csdn | harmony >
v09.xx (调度故事篇) | 用故事说内核调度 < csdn | harmony >
v08.xx (总目录) | 百万汉字注解 百篇博客分析 < csdn | harmony >
v07.xx (调度机制篇) | 任务是如何被调度执行的? < csdn | harmony >
v06.xx (调度队列篇) | 就绪队列对调度的作用 < csdn | harmony >
v05.xx (任务管理篇) | 谁在让CPU忙忙碌碌? < csdn | harmony >
v04.xx (任务调度篇) | 任务是内核调度的单元 < csdn | harmony >
v03.xx (时钟任务篇) | 触发调度最大的动力来自哪里? < csdn | harmony >
v02.xx (进程管理篇) | 进程是内核资源管理单元 < csdn | harmony >
v01.xx (双向链表篇) | 谁是内核最重要结构体? < csdn | harmony >

参与贡献

访问注解仓库地址
Fork 本仓库 >> 新建 Feat_xxx 分支 >> 提交代码注解 >> 新建 Pull Request
新建 Issue

喜欢请「点赞+关注+收藏」

关注「鸿蒙内核源码分析」公众号，百万汉字注解 + 百篇博客分析 => 深挖鸿蒙内核源码
各大站点搜 「鸿蒙内核源码分析」 .欢迎转载,请注明出处. oschina | csdn | harmony | 简书 | 掘金

本文标题： 推荐系列-鸿蒙内核源码分析(特殊进程篇) - 龙生龙,凤生凤,老鼠生儿会打洞 - 百篇博客分析HarmonyOS源码 - v46.02

本文作者： OSChina

发布时间： 2021年04月15日 09:53

最后更新： 2023年06月29日 07:10

原始链接： https://haoxiang.eu.org/5a6c63dd/

版权声明： 本文著作权归作者所有，均采用CC BY-NC-SA 4.0许可协议，转载请注明出处！

赏
× 喜欢就赞赏一下呗！
打赏二维码