长沙网站建设公司盐城网站建设

现在探讨几个核心概念：进程、PCB（进程控制块）、应用程序、窗口嵌入以及它们之间的逻辑和物理关系，还有内核机制。我将逐一详细解释。

进程与PCB的物理逻辑关系

应用程序如何通过PCB组织进程

进程与窗口嵌入的逻辑关系

这些关系的内核机制

实例说明

1. 进程与PCB的物理逻辑关系
   逻辑关系：
   进程是程序的一次执行实例，是操作系统进行资源分配和调度的基本单位。

PCB（进程控制块）是操作系统为了管理进程而设置的一个数据结构，用于描述进程的基本情况和活动过程，是进程存在的唯一标志。

逻辑上，每个进程都有一个对应的PCB。操作系统通过PCB来感知进程的存在，并根据PCB中的信息对进程进行控制和管理。

物理关系：
在物理内存中，操作系统会为每个PCB分配一块内存空间（通常在内核空间）。这些PCB通常以链表或数组的形式组织起来，方便操作系统进行遍历和查找。

例如，在Linux内核中，PCB对应的是task_struct结构体，所有进程的task_struct通过链表连接（实际上是一个双向循环链表，但现代内核中已更复杂，例如使用红黑树等）。

2. 应用程序如何通过PCB组织进程
   应用程序本身是一个静态的概念，它存储在磁盘上。当我们运行一个应用程序时，操作系统会创建一个进程，并为其分配一个PCB。应用程序的代码和数据被加载到进程的地址空间中。

一个应用程序可以对应多个进程（例如，多个浏览器窗口），每个进程有自己独立的PCB。同样，一个进程也可以对应多个应用程序（虽然不常见，但在某些复杂系统中可能存在）。

操作系统通过PCB来组织进程，例如：

进程状态：在PCB中记录进程当前状态（就绪、运行、阻塞等），从而进行调度。

程序计数器：记录进程下一条要执行的指令的地址。

内存管理信息：记录进程的页表、段表等，用于地址转换。

文件描述符表：记录进程打开的文件。

其他资源信息：如打开的设备、信号处理函数等。

通过PCB，操作系统可以管理应用程序运行时的所有信息。

3. 进程与窗口嵌入的逻辑关系
   在图形用户界面（GUI）系统中，窗口通常与进程相关联。一个进程可以创建一个或多个窗口，每个窗口通常对应一个线程（UI线程）。窗口嵌入是指将一个进程创建的窗口嵌入到另一个进程的窗口中。

逻辑关系：

每个窗口通常属于一个特定的进程（更准确地说，属于创建该窗口的线程）。

窗口嵌入涉及两个进程：宿主进程（其窗口包含另一个窗口）和被嵌入进程（其窗口被嵌入）。

窗口嵌入的本质是修改窗口的父子关系，即设置被嵌入窗口的父窗口为宿主进程中的某个窗口。

这样，从用户的角度看，两个窗口似乎属于同一个应用程序，但实际上它们可能属于不同的进程。

4. 这些关系的内核机制
   进程与PCB的内核机制：
   内核中维护着所有进程的PCB，并通过调度器根据PCB中的状态信息来切换进程。当创建一个新进程时，内核会分配一个PCB并初始化；当进程终止时，内核会回收PCB。

窗口嵌入的内核机制：
窗口嵌入通常由窗口管理器（Window Manager）和图形子系统（如Windows的Win32子系统，Linux的X Window或Wayland）处理。内核可能不直接处理窗口嵌入，但提供进程间通信（IPC）和窗口句柄管理机制。

在Windows中，窗口嵌入通过SetParentAPI实现，该函数会修改窗口的父子关系，并将子窗口的显示区域限制在父窗口的客户区内。这涉及到用户模式下的窗口管理器和内核模式下的窗口驱动程序（如win32k.sys）的协作。

5. 实例说明
   让我们以Windows操作系统为例，详细说明一个应用程序（如记事本）的进程创建、PCB（在Windows中称为EPROCESS）以及窗口嵌入的过程。

实例：记事本进程的创建和窗口嵌入
进程创建：
当我们双击记事本程序（notepad.exe）时，Windows资源管理器会调用CreateProcess函数。该函数会：

在内核中创建一个新的进程对象（EPROCESS）和线程对象（ETHREAD）。

为进程分配地址空间，加载notepad.exe的代码和数据。

创建进程的主线程，并开始执行。

PCB（EPROCESS）：
Windows内核中的EPROCESS结构体包含了进程的所有关键信息，例如：

进程ID（PID）

父进程ID

进程环境块（PEB）的地址

内存管理信息（页表、工作集等）

句柄表（指向进程打开的对象）

进程状态等。

内核通过一个全局的进程链表来管理所有进程的EPROCESS结构。

窗口创建：
记事本进程的主线程会创建一个窗口，这是通过调用CreateWindowEx等API实现的。窗口创建过程中，窗口管理器会分配一个窗口对象（在Windows内核中，窗口对象由win32k.sys管理），并返回一个句柄（HWND）。这个窗口对象与创建它的线程（进而与进程）关联。

窗口嵌入：
假设我们想将记事本窗口嵌入到另一个应用程序（我们称为宿主应用程序）的窗口中。宿主应用程序会调用SetParent函数，传入记事本窗口的句柄和宿主窗口中某个子窗口的句柄（或宿主窗口本身）作为父窗口。

SetParent函数会修改记事本窗口的父窗口，使其成为宿主窗口的子窗口。这样，记事本窗口的显示就会限制在宿主窗口的客户区内，并且随着宿主窗口移动而移动。

内核机制：

当SetParent被调用时，用户模式的窗口管理器（user32.dll）会通过系统调用（如NtUserSetParent）将请求发送到内核模式的窗口驱动程序（win32k.sys）。

win32k.sys会更新窗口对象的父窗口字段，并重新计算窗口的位置和可见区域。

由于窗口属于不同的进程，这里还涉及到进程间通信（IPC）和跨进程的窗口消息传递。Windows的窗口消息机制允许跨进程发送消息，但需要特殊的处理（例如，使用SendMessage或PostMessage）。

注意事项：

窗口嵌入后，被嵌入的窗口（记事本）仍然运行在自己的进程中，宿主进程无法直接访问记事本进程的内存或资源，除非通过IPC机制。

窗口嵌入可能会带来安全问题，因为被嵌入的窗口可能接收来自宿主窗口的输入消息，也可能尝试执行一些操作（如绘制）在宿主窗口的上下文中。

通过这个例子，我们可以看到进程、PCB（EPROCESS）、窗口和窗口嵌入之间的关系，以及操作系统内核和窗口管理系统是如何协作来实现这些功能的。

总结
进程是动态执行的实体，PCB是操作系统用于管理进程的数据结构。

应用程序通过进程执行，进程通过PCB组织。

窗口嵌入允许不同进程的窗口在视觉上合并，但其底层仍然是独立的进程，通过窗口管理器和内核协作实现。

理解这些关系对于开发复杂的多进程应用程序（如集成其他应用程序的界面）或进行系统级编程非常重要。

进程、PCB与窗口嵌入的深度内核解析

我将从操作系统内核的视角，深入探讨进程、PCB、应用程序和窗口嵌入之间的物理逻辑关系、组织机制和内核实现原理。

一、进程与PCB的物理逻辑关系

1. 物理内存中的PCB组织

Linux内核中的task_struct物理布局：

// Linux 5.x内核的task_struct部分定义structtask_struct{// 1. 状态和标识（约64字节）volatilelongstate;// 进程状态void*stack;// 内核栈指针unsignedintflags;// 进程标志intprio;// 静态优先级intstatic_prio;// 静态优先级intnormal_prio;// 正常优先级unsignedintpolicy;// 调度策略pid_tpid;// 进程IDpid_ttgid;// 线程组ID// 2. 进程关系（约64字节）structtask_struct__rcu*parent;// 父进程structlist_headchildren;// 子进程链表structlist_headsibling;// 兄弟进程链表structtask_struct*group_leader;// 线程组领导// 3. 内存管理（约256字节）structmm_struct*mm;// 内存描述符structmm_struct*active_mm;// 活动内存描述符// 4. 文件系统（约128字节）structfs_struct*fs;// 文件系统信息structfiles_struct*files;// 打开文件表// 5. 信号处理（约128字节）structsignal_struct*signal;// 信号处理structsighand_struct*sighand;// 信号处理函数sigset_tblocked;// 阻塞信号集sigset_treal_blocked;// 6. 调度相关（约96字节）structsched_entityse;// 调度实体structsched_rt_entityrt;// 实时调度实体structsched_dl_entitydl;// 截止时间调度实体// 7. 时间统计（约64字节）u64 utime;// 用户态运行时间u64 stime;// 内核态运行时间unsignedlongnvcsw;// 自愿上下文切换计数unsignedlongnivcsw;// 非自愿上下文切换计数// 8. 其他（约128字节）structthread_structthread;// 架构特定线程信息structcss_set__rcu*cgroups;// cgroup设置structlist_headtasks;// 全局进程链表节点structlist_headptrace_entry;// ptrace链表节点// 总大小：约1000-2000字节，取决于内核配置}__randomize_layout;

物理内存中的PCB组织方式：

内核地址空间高地址 ┌─────────────────────────────────┐ │ 内核代码和数据 │ ├─────────────────────────────────┤ │ task_struct数组（slab分配） │ │ ┌─────────────────────┐ │ │ │ task_struct[0] │ │ ← 每个CPU核心的per-CPU变量 │ │ - pid=1 (init) │ │ │ │ - state=RUNNING │ │ │ └─────────────────────┘ │ │ ┌─────────────────────┐ │ │ │ task_struct[1] │ │ │ │ - pid=100 (bash) │ │ │ │ - state=INTERRUPTIBLE │ │ └─────────────────────┘ │ │ ┌─────────────────────┐ │ │ │ task_struct[2] │ │ │ │ - pid=200 (chrome) │ │ │ │ - state=RUNNING │ │ │ └─────────────────────┘ │ │ ... │ ├─────────────────────────────────┤ │ 内核栈（每个进程8KB） │ │ ┌─────────────────────┐ │ │ │ 进程1内核栈 │ ← thread_info在栈底 │ │ │ ┌───────────────┐ │ │ │ │ │thread_info │ │ │ │ │ │task*指针指向 │ │ │ │ │ │task_struct │ │ │ │ │ └───────────────┘ │ │ │ │ 栈增长方向 ↑ │ │ │ └─────────────────────┘ │ │ ┌─────────────────────┐ │ │ │ 进程2内核栈 │ │ │ └─────────────────────┘ │ │ ... │ ├─────────────────────────────────┤ │ 进程描述符缓存 │ │ （task_struct_cache slab） │ ├─────────────────────────────────┤ │ 进程链表头 │ │ init_task (pid=0) │ │ ┌─────────────────────┐ │ │ │ tasks链表头 │ │ │ │ prev→下一个PCB │ │ │ │ next→下一个PCB │ │ │ └─────────────────────┘ │ ├─────────────────────────────────┤ │ 就绪队列（rq） │ │ struct rq per_cpu变量 │ └─────────────────────────────────┘ 内核地址空间低地址

PCB物理内存分配机制：

// Linux内核源码：kernel/fork.c// 进程创建时的PCB分配staticstructtask_struct*dup_task_struct(structtask_struct*orig,intnode){structtask_struct*tsk;structthread_info*ti;// 1. 从task_struct_cache slab缓存中分配PCB内存tsk=alloc_task_struct_node(node);if(!tsk)returnNULL;// 2. 分配内核栈（通常8KB或16KB）ti=alloc_thread_info_node(tsk,node);if(!ti)gotofree_tsk;// 3. 设置thread_info与task_struct的关联// thread_info位于内核栈底部ti->task=tsk;tsk->stack=ti;// 4. 复制父进程的task_struct内容err=arch_dup_task_struct(tsk,orig);if(err)gotofree_ti;// 5. 设置栈顶指针（架构相关）setup_thread_stack(tsk,orig);returntsk;free_ti:free_thread_info(ti);free_tsk:free_task_struct(tsk);returnNULL;}// PCB在内核slab缓存中的分配structkmem_cache*task_struct_cachep;void__initfork_init(void){// 创建task_struct专用的slab缓存task_struct_cachep=kmem_cache_create("task_struct",sizeof(structtask_struct),ARCH_MIN_TASKALIGN,SLAB_PANIC|SLAB_ACCOUNT,NULL);}

2. PCB与进程的物理映射关系

内核中进程查找机制：

// 通过PID查找PCB的机制structtask_struct*find_task_by_pid_ns(pid_tnr,structpid_namespace*ns){structpid*pid;// 1. 通过PID哈希表查找pid结构pid=find_pid_ns(nr,ns);if(!pid)returnNULL;// 2. 从pid结构获取task_structreturnpid_task(pid,PIDTYPE_PID);}// PID到PCB的映射数据结构structpid{atomic_tcount;// 引用计数unsignedintlevel;// 命名空间层级structhlist_nodetasks[PIDTYPE_MAX];// 任务链表structrcu_headrcu;structupidnumbers[1];// 不同命名空间中的PID};structupid{intnr;// 当前命名空间的PIDstructpid_namespace*ns;// 所属命名空间structhlist_nodepid_chain;// PID哈希表节点};// PID哈希表（全局）staticstructhlist_head*pid_hash;

进程树物理组织：

// 内核中的进程树维护void__initproc_caches_init(void){// 初始化各种进程相关的缓存sighand_cachep=kmem_cache_create("sighand_cache",sizeof(structsighand_struct),0,SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_ACCOUNT,sighand_ctor);signal_cachep=kmem_cache_create("signal_cache",sizeof(structsignal_struct),0,SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_ACCOUNT,NULL);}// 进程创建时设置父子关系long_do_fork(unsignedlongclone_flags,unsignedlongstack_start,unsignedlongstack_size,int__user*parent_tidptr,int__user*child_tidptr,unsignedlongtls){structtask_struct*p;inttrace=0;longnr;// 创建新的PCBp=copy_process(clone_flags,stack_start,stack_size,parent_tidptr,child_tidptr,tls,trace);if(IS_ERR(p))returnPTR_ERR(p);// 获取新进程的PIDpid=get_task_pid(p,PIDTYPE_PID);nr=pid_vnr(pid);// 如果是CLONE_PARENT，设置相同的父进程if(clone_flags&CLONE_PARENT_SETTID)put_user(nr,parent_tidptr);// 唤醒新进程wake_up_new_task(p);returnnr;}

二、应用程序如何通过PCB组织进程

1. 应用程序加载与进程创建的完整流程

用户空间 内核空间 ┌─────────────────┐ ┌─────────────────────┐ │ 应用程序 │ │ 内核 │ │ (executable) │ │ │ └────────┬────────┘ └──────────┬──────────┘ │ execve()系统调用 │ ├─────────────────────────────────────► │ │ │ 1. 查找可执行文件 │ │ nameidata │ │ │ │ 2. 检查权限和能力 │ │ security_bprm_check│ │ │ │ 3. 设置二进制格式 │ │ search_binary_handler│ │ │ │ 4. 加载程序到内存 │ │ load_elf_binary │ │ │ │ 5. 设置参数和环境变量 │ │ setup_arg_pages │ │ │ │ 6. 开始执行 │ │ start_thread │ │◄─────────────────────────────────────┤ │ │ ┌────────▼────────┐ ┌───────────▼──────────┐ │ 新进程运行 │ │ 更新PCB │ │ main()函数 │ │ - 内存映射 │ │ │ │ - 文件描述符 │ │ │ │ - 信号处理 │ └─────────────────┘ └─────────────────────┘

2. 应用程序内存空间在PCB中的组织

// mm_struct内存描述符结构structmm_struct{structvm_area_struct*mmap;// 虚拟内存区域链表structrb_rootmm_rb;// 虚拟内存区域红黑树u32 vmacache_seqnum;// VM缓存序列号unsignedlongmmap_base;// mmap起始地址unsignedlongtask_size;// 任务虚拟内存大小unsignedlongstart_code,end_code;// 代码段起止unsignedlongstart_data,end_data;// 数据段起止unsignedlongstart_brk,brk;// 堆起止unsignedlongstart_stack;// 栈起始unsignedlongarg_start,arg_end;// 命令行参数unsignedlongenv_start,env_end;// 环境变量// 页表管理pgd_t*pgd;// 页全局目录atomic_tmm_users;// 使用计数atomic_tmm_count;// 引用计数intmap_count;// VMA数量structlist_headmmlist;// 所有mm_struct链表spinlock_tpage_table_lock;// 页表锁// 反向映射structrmap_wait_anon_vma*anon_vma_chain;structrmap_wait_anon_vma*anon_vma;// 内存策略structmempolicy*mempolicy;// 内存统计unsignedlongtotal_vm;// 总虚拟内存unsignedlonglocked_vm;// 锁定内存unsignedlongpinned_vm;// 固定内存unsignedlongdata_vm;// 数据段内存unsignedlongexec_vm;// 可执行内存unsignedlongstack_vm;// 栈内存};// 应用程序加载时设置内存映射staticintload_elf_binary(structlinux_binprm*bprm){structfile*interpreter=NULL;structelf_phdr*elf_ppnt,*elf_phdata;structelf_phdr*interp_elf_phdata=NULL;unsignedlongerror;unsignedlongelf_bss,elf_brk;intretval,i;// 1. 解析ELF头部loc->elf_ex=*((structelfhdr*)bprm->buf);// 2. 读取程序头表elf_phdata=load_elf_phdrs(&loc->elf_ex,bprm->file);// 3. 遍历程序段for(i=0;i<loc->elf_ex.e_phnum;i++){elf_ppnt=elf_phdata+i;if(elf_ppnt->p_type==PT_LOAD){// 加载段到内存error=elf_map(bprm->file,load_bias+vaddr,elf_ppnt,elf_prot,elf_flags,0);// 更新内存统计if(!error){unsignedlongsize=elf_ppnt->p_memsz;unsignedlongend=vaddr+size;if(end>elf_brk)elf_brk=end;if((elf_ppnt->p_flags&PF_X)&&end>elf_bss)elf_bss=end;}}}// 4. 设置堆和栈current->mm->start_brk=current->mm->brk=elf_brk;current->mm->end_code=end_code;current->mm->start_code=start_code;current->mm->start_data=start_data;current->mm->end_data=end_data;// 5. 设置参数和环境变量retval=setup_arg_pages(bprm,randomize_stack_top(STACK_TOP),executable_stack);// 6. 设置程序入口点start_thread(regs,elf_entry,bprm->p);return0;}

3. 应用程序资源在PCB中的组织

// files_struct文件描述符表structfiles_struct{atomic_tcount;// 引用计数structfdtable__rcu*fdt;// 文件描述符表structfdtablefdtab;// 内联文件描述符表spinlock_tfile_lock;// 文件锁unsignedintnext_fd;// 下一个可用的fdunsignedlongclose_on_exec_init[1];// exec时关闭的文件unsignedlongopen_fds_init[1];// 打开文件位图structfile__rcu*fd_array[NR_OPEN_DEFAULT];// 文件指针数组};// 应用程序打开文件时更新PCBlongdo_sys_open(intdfd,constchar__user*filename,intflags,umode_tmode){structopen_flagsop;intfd=build_open_flags(flags,mode,&op);structfile*file;char*tmp=getname(filename);if(IS_ERR(tmp))returnPTR_ERR(tmp);// 分配文件描述符fd=get_unused_fd_flags(flags);if(fd>=0){// 打开文件file=do_filp_open(dfd,tmp,&op);if(IS_ERR(file)){put_unused_fd(fd);fd=PTR_ERR(file);}else{// 将文件与fd关联fsnotify_open(file);fd_install(fd,file);// 更新PCB中的files_structstructfiles_struct*files=current->files;__set_open_fd(fd,files);}}putname(tmp);returnfd;}// 信号处理结构在PCB中的组织structsignal_struct{atomic_tsigcnt;// 信号计数atomic_tlive;// 活动线程数intnr_threads;// 线程数structlist_headthread_head;// 线程链表wait_queue_head_twait_chldexit;// 等待子进程退出structtask_struct*curr_target;// 当前目标进程structsigpendingshared_pending;// 共享待处理信号// 信号处理函数structsigactionaction[_NSIG];// 信号动作sigset_tblocked;// 阻塞信号集sigset_treal_blocked;// 资源限制structrlimitrlim[RLIM_NLIMITS];// 资源限制unsignedlongflags;// 进程组和会话pid_tpgrp;// 进程组IDpid_tsession;// 会话ID};

三、进程与窗口嵌入的逻辑关系

1. 窗口系统架构与进程关系

┌─────────────────────────────────────────────────────┐ │ 用户空间窗口系统 │ ├─────────────────────────────────────────────────────┤ │ 应用程序A 应用程序B │ │ ┌─────────────┐ ┌─────────────┐ │ │ │ 窗口1 │ │ 窗口2 │ │ │ │ HWND=1001 │ │ HWND=1002 │ │ │ └──────┬──────┘ └──────┬──────┘ │ │ │ │ │ │ │ 窗口消息 │ 窗口消息 │ │ │ (WM_PAINT, WM_MOUSEMOVE)│ │ │ ▼ ▼ │ │ ┌─────────────────────────────────────────┐ │ │ │ 窗口管理器（如X11/Wayland） │ │ │ │ 管理窗口位置、Z序、焦点、合成等 │ │ │ └─────────────────────────────────────────┘ │ ├─────────────────────────────────────────────────────┤ │ 内核空间 │ ├─────────────────────────────────────────────────────┤ │ 进程A task_struct 进程B task_struct │ │ ┌─────────────┐ ┌─────────────┐ │ │ │ mm_struct │ │ mm_struct │ │ │ │ files_struct│ │ files_struct│ │ │ │ signal_struct │ signal_struct │ │ └──────┬──────┘ └──────┬──────┘ │ │ │ │ │ │ │ 系统调用接口 │ 系统调用接口 │ │ ▼ ▼ │ │ ┌─────────────────────────────────────────┐ │ │ │ 显示驱动程序 │ │ │ │ DirectFB/DRI/DRM/KMS │ │ │ └─────────────────────────────────────────┘ │ │ │ │ │ ▼ │ │ ┌─────────────────────────────────────────┐ │ │ │ 显卡硬件 │ │ │ └─────────────────────────────────────────┘ │ └─────────────────────────────────────────────────────┘

2. 窗口句柄（HWND）与进程的内核映射

Windows内核中的窗口对象：

// Windows内核中的窗口对象（win32k.sys）typedefstruct_WINDOW_OBJECT{HANDLE hWnd;// 窗口句柄PVOID pWnd;// 指向WND结构的指针// 窗口属性DWORD dwStyle;// 窗口样式DWORD dwExStyle;// 扩展样式RECT rcWindow;// 窗口矩形RECT rcClient;// 客户区矩形// 窗口关系struct_WINDOW_OBJECT*parent;// 父窗口struct_WINDOW_OBJECT*owner;// 所有者窗口struct_WINDOW_OBJECT*child;// 第一个子窗口struct_WINDOW_OBJECT*sibling;// 下一个兄弟窗口// 进程关联PEPROCESS Process;// 所属进程的EPROCESSPETHREAD Thread;// 创建窗口的线程// 窗口类PCLSOBJ pcls;// 窗口类对象// 消息队列PQMSG pqmsg;// 消息队列// 安全描述符PSECURITY_DESCRIPTOR pSecurityDescriptor;// 其他属性ULONG_PTR dwUserData;// 用户数据ATOM atomClass;// 窗口类原子UINT cbWndExtra;// 额外窗口数据大小}WINDOW_OBJECT,*PWINDOW_OBJECT;// 窗口句柄表（Handle Table）typedefstruct_HANDLE_TABLE{ULONG_PTR TableCode;// 句柄表编码PEPROCESS QuotaProcess;// 配额进程PEPROCESS UniqueProcessId;// 进程IDEX_PUSH_LOCK HandleLock;// 句柄表锁// 句柄表项struct_HANDLE_TABLE_ENTRY*HandleTable;}HANDLE_TABLE,*PHANDLE_TABLE;

窗口嵌入的内核机制：

// Windows中SetParent的系统调用实现NTSTATUSNtUserSetParent(HWND hWndChild,HWND hWndNewParent){PWINDOW_OBJECT pWndChild,pWndNewParent;PEPROCESS CurrentProcess;// 1. 获取当前进程CurrentProcess=PsGetCurrentProcess();// 2. 验证窗口句柄并获取窗口对象pWndChild=ValidateHwnd(hWndChild);if(!pWndChild)returnSTATUS_INVALID_HANDLE;// 3. 检查权限：窗口必须属于当前进程或具有足够权限if(pWndChild->Process!=CurrentProcess){if(!SeSinglePrivilegeCheck(SeDebugPrivilege,CurrentProcess)){returnSTATUS_ACCESS_DENIED;}}// 4. 获取新父窗口对象（如果指定）if(hWndNewParent){pWndNewParent=ValidateHwnd(hWndNewParent);if(!pWndNewParent)returnSTATUS_INVALID_HANDLE;// 检查循环父子关系if(TestCyclicParent(pWndChild,pWndNewParent)){returnSTATUS_INVALID_PARAMETER;}}else{pWndNewParent=NULL;}// 5. 获取窗口对象锁LockWindowObject(pWndChild);// 6. 更新窗口父子关系if(pWndChild->parent!=pWndNewParent){// 从原父窗口的子链表中移除if(pWndChild->parent){RemoveFromChildList(pWndChild->parent,pWndChild);}// 设置新父窗口pWndChild->parent=pWndNewParent;// 添加到新父窗口的子链表if(pWndNewParent){AddToChildList(pWndNewParent,pWndChild);// 更新窗口样式：变为子窗口pWndChild->dwStyle|=WS_CHILD;pWndChild->dwStyle&=~WS_POPUP;// 重新计算窗口位置（相对坐标）ConvertToParentCoordinates(pWndChild,pWndNewParent);}else{// 没有父窗口，恢复为顶级窗口pWndChild->dwStyle&=~WS_CHILD;pWndChild->dwStyle|=WS_POPUP;}// 7. 触发窗口重新绘制和位置调整SendMessage(hWndChild,WM_PARENTCHANGED,0,0);SetWindowPos(hWndChild,NULL,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_FRAMECHANGED);}// 8. 释放锁UnlockWindowObject(pWndChild);returnSTATUS_SUCCESS;}// 消息转发的内核机制NTSTATUSNtUserSendMessage(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam){PWINDOW_OBJECT pWnd;PETHREAD TargetThread;PMSGQUEUE TargetQueue;// 1. 验证窗口句柄pWnd=ValidateHwnd(hWnd);if(!pWnd)returnSTATUS_INVALID_HANDLE;// 2. 获取目标窗口的线程TargetThread=pWnd->Thread;// 3. 获取目标线程的消息队列TargetQueue=GetThreadMessageQueue(TargetThread);// 4. 检查是否跨进程发送消息if(TargetThread!=PsGetCurrentThread()){// 跨进程消息发送需要特殊处理// a. 验证参数是否可以跨进程访问if(!ValidateMessageParameters(Msg,wParam,lParam,TRUE)){returnSTATUS_ACCESS_VIOLATION;}// b. 复制消息数据到目标进程地址空间PMSG pMsgCopy=CopyMessageToTargetProcess(TargetThread->Process,Msg,wParam,lParam);if(!pMsgCopy){returnSTATUS_NO_MEMORY;}// c. 将消息放入目标线程的消息队列InsertMessage(TargetQueue,pMsgCopy);// d. 唤醒目标线程（如果需要）if(TargetThread->State==Waiting){WakeThread(TargetThread);}}else{// 同一进程内发送消息PMSG pMsg=AllocateMessage(Msg,wParam,lParam);InsertMessage(TargetQueue,pMsg);}returnSTATUS_SUCCESS;}

3. X Window系统（Linux）的窗口嵌入机制

// X Server中的窗口数据结构typedefstruct_Window{XID id;// 窗口IDDrawable drawable;// 可绘制对象// 窗口属性intx,y;// 位置unsignedintwidth,height;// 尺寸unsignedintborder_width;// 边框宽度// 窗口关系struct_Window*parent;// 父窗口struct_Window*firstChild;// 第一个子窗口struct_Window*lastChild;// 最后一个子窗口struct_Window*nextSibling;// 下一个兄弟窗口struct_Window*prevSibling;// 上一个兄弟窗口// 客户端关联ClientPtr client;// 客户端（进程）// 窗口类Mask eventMask;// 事件掩码// 可视性Bool viewable;// 是否可见Bool mapped;// 是否已映射// 其他属性Colormap colormap;// 颜色映射Cursor cursor;// 光标}WindowRec,*WindowPtr;// XReparentWindow请求处理intProcReparentWindow(ClientPtr client){WindowPtr pWin,pNewParent;REQUEST(xReparentWindowReq);// 1. 查找窗口对象pWin=LookupWindow(stuff->window,client);if(!pWin){client->errorValue=stuff->window;returnBadWindow;}// 2. 查找新父窗口if(stuff->parent){pNewParent=LookupWindow(stuff->parent,client);if(!pNewParent){client->errorValue=stuff->parent;returnBadWindow;}// 检查循环父子关系if(IsDescendant(pNewParent,pWin)){returnBadMatch;}}else{pNewParent=client->defaultRootWindow;}// 3. 验证权限if(!CheckAccess(pWin,client,DixReparentAccess)||!CheckAccess(pNewParent,client,DixAddAccess)){returnBadAccess;}// 4. 执行重设父窗口操作returnReparentWindow(pWin,pNewParent,stuff->x,stuff->y,TRUE);}// 实际的重设父窗口函数intReparentWindow(WindowPtr pWin,WindowPtr pNewParent,intx,inty,Bool sendEvent){WindowPtr pOldParent=pWin->parent;// 1. 从原父窗口的子链表中移除if(pOldParent){if(pWin==pOldParent->firstChild){pOldParent->firstChild=pWin->nextSibling;}if(pWin==pOldParent->lastChild){pOldParent->lastChild=pWin->prevSibling;}if(pWin->prevSibling){pWin->prevSibling->nextSibling=pWin->nextSibling;}if(pWin->nextSibling){pWin->nextSibling->prevSibling=pWin->prevSibling;}}// 2. 添加到新父窗口的子链表pWin->parent=pNewParent;if(pNewParent){if(!pNewParent->firstChild){pNewParent->firstChild=pNewParent->lastChild=pWin;pWin->prevSibling=pWin->nextSibling=NULL;}else{pWin->prevSibling=pNewParent->lastChild;pWin->nextSibling=NULL;pNewParent->lastChild->nextSibling=pWin;pNewParent->lastChild=pWin;}// 3. 更新窗口位置（转换为新父窗口的坐标系）pWin->x=x;pWin->y=y;// 4. 重新计算绝对坐标ComputeAbsoluteCoordinates(pWin);}// 5. 发送重设父窗口事件if(sendEvent){SendReparentNotify(pWin,pOldParent,pNewParent,x,y);}// 6. 重新计算可视区域RegionPtr pOldVisible=pWin->valdata->before.borderVisible;RegionPtr pNewVisible=NotViewable(pWin)?NullRegion:BorderVisible(pWin);if(REGION_NOT_EQUAL(pOldVisible,pNewVisible)){WindowExposures(pWin,pOldVisible,pNewVisible);}returnSuccess;}

四、完整实例：跨进程窗口嵌入与消息路由

1. 完整的Windows跨进程窗口嵌入示例

// CrossProcessWindowEmbedder.cpp#include<windows.h>#include<iostream>#include<string>#include<thread>#include<atomic>#include<memory>// 共享内存结构#pragmapack(push,1)structSharedMemoryData{DWORD hostProcessId;DWORD embeddedProcessId;HWND hostWindow;HWND embeddedWindow;boolready;charwindowTitle[256];};#pragmapack(pop)classCrossProcessEmbedder{private:HANDLE hMapFile;SharedMemoryData*pSharedData;HWND hHostWindow;HWND hEmbeddedWindow;DWORD dwEmbeddedProcessId;std::atomic<bool>running{false};// 消息钩子HHOOK hMouseHook;HHOOK hKeyboardHook;// 消息转发线程std::thread messageThread;public:CrossProcessEmbedder():hMapFile(NULL),pSharedData(NULL),hHostWindow(NULL),hEmbeddedWindow(NULL),hMouseHook(NULL),hKeyboardHook(NULL){}~CrossProcessEmbedder(){cleanup();}// 宿主进程：创建共享内存和窗口boolInitializeAsHost(conststd::wstring&windowTitle){// 1. 创建共享内存hMapFile=CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,sizeof(SharedMemoryData),L"Global\CrossProcessEmbedder");if(!hMapFile){std::cerr<<"CreateFileMapping failed: "<<GetLastError()<<std::endl;returnfalse;}// 2. 映射共享内存pSharedData=(SharedMemoryData*)MapViewOfFile(hMapFile,FILE_MAP_ALL_ACCESS,0,0,sizeof(SharedMemoryData));if(!pSharedData){std::cerr<<"MapViewOfFile failed: "<<GetLastError()<<std::endl;CloseHandle(hMapFile);returnfalse;}// 3. 初始化共享数据memset(pSharedData,0,sizeof(SharedMemoryData));pSharedData->hostProcessId=GetCurrentProcessId();pSharedData->ready=false;wcscpy_s((wchar_t*)pSharedData->windowTitle,sizeof(pSharedData->windowTitle)/sizeof(wchar_t),windowTitle.c_str());// 4. 创建宿主窗口if(!CreateHostWindow(windowTitle)){UnmapViewOfFile(pSharedData);CloseHandle(hMapFile);returnfalse;}// 5. 设置全局钩子（用于捕获嵌入窗口的输入）InstallHooks();// 6. 启动消息转发线程running=true;messageThread=std::thread(&CrossProcessEmbedder::MessagePumpThread,this);returntrue;}// 被嵌入进程：连接到共享内存boolInitializeAsEmbedded(){// 1. 打开已存在的共享内存hMapFile=OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,L"Global\CrossProcessEmbedder");if(!hMapFile){std::cerr<<"OpenFileMapping failed: "<<GetLastError()<<std::endl;returnfalse;}// 2. 映射共享内存pSharedData=(SharedMemoryData*)MapViewOfFile(hMapFile,FILE_MAP_ALL_ACCESS,0,0,sizeof(SharedMemoryData));if(!pSharedData){std::cerr<<"MapViewOfFile failed: "<<GetLastError()<<std::endl;CloseHandle(hMapFile);returnfalse;}// 3. 等待宿主进程准备好while(!pSharedData->ready){Sleep(100);}// 4. 查找自己的主窗口hEmbeddedWindow=FindWindow(NULL,(LPCWSTR)pSharedData->windowTitle);if(!hEmbeddedWindow){std::cerr<<"Cannot find embedded window"<<std::endl;UnmapViewOfFile(pSharedData);CloseHandle(hMapFile);returnfalse;}// 5. 将窗口嵌入到宿主窗口中returnEmbedWindow();}private:// 创建宿主窗口boolCreateHostWindow(conststd::wstring&title){WNDCLASSEX wc={};wc.cbSize=sizeof(WNDCLASSEX);
                        
                        

                            

                                

                                    
                                        
                                        
                                        
                                            点赞 (479)
                                        
                                    
                                    
                                        
                                        
                                        
                                            分享
                                        
                                    
                                    
                                        
                                        
                                        
                                            收藏
                                        
                                    
                                
                                

                                    
                                        
                                        
                                        
                                            返回列表