nuwa创建新进程源码分析

nuwa.cpp的作用，fork 对线程进行相关冻结设置复制等。线程级别的设置等。。。。

https://developer.mozilla.org/en-US/docs/Archive/B2G_OS/Security/B2G_IPC_internals

https://blog.youkuaiyun.com/hunter___/article/details/82912266

 

具体介绍如下内容：

通道的建立，通道的连接（b2g (parent )如何连接到通道，nuwa如何连接到通道），fork，进程的孵化，

b2g中主线程和ioloop线程之间进行了通道连接？

Nuwa中也一样，它的主线程与ioloop线程也进行连接？

 gecko/mozglue/build/Nuwa.h

。。。 extern "C" { /**  * The following 3 methods are used to synchronously spawn the Nuwa process.  * The typical usage is:  *  *   The IPC thread                                The main thread  *   1. Receives the request.  *   2. NuwaSpawnPrepare().  *   3. Request main thread to  *      spawn. --------------------------------------+  *   4. NuwaSpawnWait().                             V  *                                                 5. NuwaSpawn() to clone all  *                                                    the threads in the Nuwa  *                                                    process (including main  *                                                    & IPC threads).  *                                                 6. NuwaSpawn() finishes and  *            +-------------------------------------- signals NuwaSpawnWait().  *            V  *   7. NuwaSpawnWait() returns.  */ /**  * Prepare for spawning a new process. The calling thread (typically the IPC  * thread) will block further requests to spawn a new process.  */ MFBT_API void NuwaSpawnPrepare(); /**  * Called on the thread that receives the request. Used to wait until  * NuwaSpawn() finishes and maintain the stack of the calling thread.  */ MFBT_API void NuwaSpawnWait(); /**  * Spawn a new content process, called in the Nuwa process. This has to run on  * the main thread.  *  * @return The process ID of the new process.  */ MFBT_API pid_t NuwaSpawn(); /**  * The following methods are for marking threads created in the Nuwa process so  * they can be frozen and then recreated in the spawned process. All threads  * except the main thread must be marked by one of the following 4 methods;  * otherwise, we have a thread that is created but unknown to us. The Nuwa  * process will never become ready and this needs to be fixed.  */ /**  * Mark the current thread as supporting Nuwa. The thread will implicitly freeze  * by calling a blocking method such as pthread_mutex_lock() or epoll_wait().  *  * @param recreate The custom function that will be called in the spawned  *                 process, after the thread is recreated. Can be nullptr if no  *                 custom function to be called after the thread is recreated.  *                 Note that this function is called duing thread recreation  *                 while other threads are frozen. It must not perform any  *                 action (e.g. acquiring a mutex) that might depend on another  *                 thread that is still blocked.  * @param arg The argument passed to the custom function. Can be nullptr.  */ MFBT_API void NuwaMarkCurrentThread(void (*recreate)(void *), void *arg); /**  * Mark the current thread as not supporting Nuwa. The calling thread will not  * be automatically cloned from the Nuwa process to spawned process. If this  * thread needs to be created in the spawned process, use NuwaAddConstructor()  * or NuwaAddFinalConstructor() to do it.  */ MFBT_API void NuwaSkipCurrentThread(); /**  * Force the current thread to freeze explicitly at the current point.  */ MFBT_API void NuwaFreezeCurrentThread(); /**  * Helper functions for the NuwaCheckpointCurrentThread() macro.  */ MFBT_API jmp_buf* NuwaCheckpointCurrentThread1(); MFBT_API bool NuwaCheckpointCurrentThread2(int setjmpCond); /**  * Set the point to recover after thread recreation. The calling thread is not  * blocked. This is used for the thread that cannot freeze (i.e. the IPC  * thread).  */ #define NuwaCheckpointCurrentThread() \   NuwaCheckpointCurrentThread2(setjmp(*NuwaCheckpointCurrentThread1())) /**  * The following methods are called in the initialization stage of the Nuwa  * process.  */ /**  * Prepare for making the Nuwa process.  */ MFBT_API void PrepareNuwaProcess(); /**  * Make the current process a Nuwa process. Start to freeze the threads.  */ MFBT_API void MakeNuwaProcess(); /**  * Register a method to be invoked after a new process is spawned. The method  * will be invoked on the main thread *before* recreating the other threads.  * The registered method must not perform any action (e.g. acquiring a mutex)  * that might depend on another thread that has not yet been recreated.  *  * @param construct The method to be invoked.  * @param arg The argument passed to the method.  */ MFBT_API void NuwaAddConstructor(void (*construct)(void *), void *arg); /**  * Register a method to be invoked after a new process is spawned and threads  * are recreated. The method will be invoked on the main thread *after*  * the other threads are recreated and fully functional.  *  * @param construct The method to be invoked.  * @param arg The argument passed to the method.  */ MFBT_API void NuwaAddFinalConstructor(void (*construct)(void *), void *arg); /**  * Register a method to be invoked after the current thread is recreated in the  * spawned process. Note that this function is called while other threads are  * frozen. It must not perform any action (e.g. acquiring a mutex) that might  * depend on another thread that is still blocked.  *  * @param construct The method to be invoked.  * @param arg The argument passed to the method.  */ MFBT_API void NuwaAddThreadConstructor(void (*construct)(void *), void *arg); /**  * The methods to query the Nuwa-related states.  */ /**  * @return If the current process is the Nuwa process.  */ MFBT_API bool IsNuwaProcess(); /**  * @return If the Nuwa process is ready for spawning new processes.  */ MFBT_API bool IsNuwaReady(); #if defined(DEBUG) || defined(ENABLE_TESTS) /**  * Asserts that aThread is not frozen.  */ MFBT_API void NuwaAssertNotFrozen(unsigned int aThread,                                   const char* aThreadName); #else #define NuwaAssertNotFrozen(aThread, aThreadName) do {} while(0); #endif }; #endif /* __NUWA_H_ */

 

 

gecko/dom/ipc/

gecko/dom/ipc/ .cpp .h .ipdl 总体来讲就是dom 中的进程间通信（Ipc）模块

NuwaParent.cpp

 

dom/ipc/PreallocatedProcessManager.cpp:68:  void NuwaFork()决定何时需要创建新进程，在NuwaChild中被调，往上继续可以追溯到APP请求？

 

PContentParent.h 在b2g main thread 中，SendNuwaFork() 发送fork新进程的消息,

 

PContentChild.h 在nuwa main thread中,会RecvNuwaFork(),并开始去做真正的fork工作。fork完之后会发消息给b2g让它sendAddNewProcess  。

ioloop 线程专门用于接收进程间的消息。ioloop线程与main thread 建立通道。

socketpair+messageloop+ipdl机制

 

Nuwa从b2gloader这一线

gecko/b2g/app/B2GLoader.cpp:307, Fuc:RunProcesses-->

ipc/glue/ProcessUtils_linux.cpp:692, Fuc:XRE_ProcLoaderServiceRun-->

gecko/toolkit/xre/nsAppRunner.cpp:4595, Fuc:XRE_InitCommandLine-->

gecko/ipc/glue/ProcessUtils_linux.cpp:626, Fuc:ProcLoaderServiceRun  call -- process = new ContentProcess(aPeerPid:180)--->

gecko/ipc/glue/ProcessChild.cpp:56, Fuc:ProcessChild--->

gecko/dom/ipc/ContentChild.cpp:637, Fuc:ContentChild-->

 

 

 

ContentChild和ContentParent都及大，总体作用是什么，

class ContentProcess : public mozilla::ipc::ProcessChild

 

 

 

如下关系，

contentprocess

contentparent

contentchild

 

nsI这块到底是谁在用？

nsIContentChild

nsIcontentparent

 

nuwaparent

nuwachild

 

牢记nuwa在ProcLoaderServiceRun上面运行，

../ipc/glue/ProcessUtils_linux.cpp:22:#include "mozilla/ipc/PProcLoaderChild.h"

../ipc/glue/ProcessUtils_linux.cpp:21:#include "mozilla/ipc/PProcLoaderParent.h" Load的细节，不管了。

ProcessUtils_linux.cpp用于处理接收进程间的load 请求等

 

nuwa与plugin-container的关系，开始时plugin是必须的，后加入Nuwa以加快速度。所以，目前正常状态，plugin-container只在第一次fork出进程时被nuwa使用,nuwa成熟之后，所有工作就不劳烦plungin，而是全权由nuwa来，nuwa的目的就在于提升速度横插进来的模块。setprocessasnuwa也就可以理解了。

明白了，第一步是b2g请求plugin-container Load nuwa ,此时此进程还不是nuwa进程，只是成长中的nuwa process,本质是plugin-container过渡态进程，直到plugin-container Load 完nuwa，并将此Plungin 进程设置为Nuwa进程。ok，现在nuwa出来了。后面所有进程的创建都丢给nuwa吧。于是后面系统起来之后，分别启动了3个进程，先后应该如下：homescreen,keyboard,preallocated

没错。