[系统架构]一种裸机代码/系统架构-基于“客户端-服务器”的系统设计方法

原创 已于 2025-08-15 02:56:59 修改 · 735 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #linux #单片机

于 2025-08-15 02:55:55 首次发布

一、动机

  1. 模块化设计 ，四个典型的降低系统复杂度的有效方案：模块化、抽象、层以及层次结构。显然模块化设计是其中之一，并且也很常见。
  2. 模块的自治性，希望一个模块的运行尽可能少地依赖其他模块，甚至做到完全不依赖。模块具有一定的容错性，在一定程度上，当它依赖的资源失效时，模块应当有合理的处置方案，并尽到停止服务以及通知的义务。

二、使用“客户端-服务器”模型强制模块化

该段落引用自《Principle Of Computer System Design An Introduction》, Jerome H. Saltzer ,M. Frans Kaashoek.
操作系统的一个重要任务是实现“客户端-服务器”组织结构，在这种组织结构中，模块之间仅通过发送消息进行交互，这种组织有三个好处。
1）消息是程序员请求模块提供服务的唯一途径，这将使得程序员更难以违反模块化的约定。
2）消息是错误在模块之间传播的唯一途径，如果客户端/服务器二者之一任意一个失效，只要它们有各自的消息检查机制，那么就能够限制错误从一个模块传输到另一个模块。
3）消息是攻击者侵入模块的唯一途径，因此，如果模块检查输入消息，那么就能够规避大部分攻击。

三、arm cc工具链支持将资源指定到特定的代码段

观察下面的两个代码片段，考虑使用module_register_taskFunc(“task1”,task1StepFunction)生成一个module_task_item_t结构体类型的变量，它会被存放到名为task.item.1的字段中，并且驻留于ROM空间（因为是用const修饰的），arm cc工具链会将task.item.0，task.item.1，task.item.2三个字段自动按顺序排列，那么在运行module_task函数时，我们新建的task1StepFunction函数会被运行。

这个特性意味着：我们在工程中新增或删除一个文件时，无需修改工程中的主框架（如main函数的内容，module_task函数的内容）就可以完成功能的增删。事实上，这个套路在很多地方都可以见到，比如linux内核，uboot中都可以见到，并且笔者的思路也源于此。

注：下面的以阿拉伯数字为代码段定顺序的方案目前可以在arm cc上正确得到结果，但是运用在gcc中时需要进行改动，笔者目前也不知道为什么，谨在此指出以强调不同情况具有差异，不适合完全照搬。

static void nop_process(void){}

//第一个任务项目，段入口
static const module_task_item_t task_table_start __attribute__((section("task.item.0"))) = {"",nop_process};
//最后一个任务项目，段结尾
static const module_task_item_t task_table_end   __attribute__((section("task.item.2"))) = {"",nop_process};

void module_task(void){
	const module_task_item_t* pTaskFunc;
	for(pTaskFunc = &task_table_start + 1; pTaskFunc < &task_table_end; pTaskFunc++){
		if(pTaskFunc->taskHandler != NULL)
			pTaskFunc->taskHandler();
	}
}

#ifndef _MODULE_FRAME_H_
#define _MODULE_FRAME_H_

/*任务处理项*/
typedef struct {
	const char* name;
	void (*taskHandler)(void);
}module_task_item_t;

#define __module_task(name,func)	\
	__attribute__((used)) const module_task_item_t task_module_##func##__LINE__ \
	__attribute__((section("task.item.1"))) = {name,func}

//注册模块任务函数
#define module_register_taskFunc(name,func) __module_task(name,func)
extern void module_task(void);

#endif

四、拓展方法的适用范围

本质上，存入内存中的是数据。结构体中的内容可以是函数指针，它同样也可以是变量指针！来看下面的例子，考虑构建一个受信任的存储服务。

“受信任的存储服务”

1）什么是受信任的服务？笔者认为这和做人是一样的，可以信任的人做事情，在他界定的服务与对未知事物掌控度的范围内，能做就会告诉你能做，不能做（比如违反安全协议，超出能力）就是不能做，正常提供服务的过程中如果遇到错误应该及时报错，客户可以据此来决定下一步该怎么走。当然，人有主观能动性，这是远远优于机器的地方，对于机器来说，必须要仔细界定服务的边界。

2）第一点描述的内容中隐含了一个条件：一个提供受信任的服务的模块必须是自主的。客户端只能通过发消息请求服务（读服务，写服务等等）的方式来获取数据读写服务，否则如果只是提供对内存的读写过程函数，那就无所谓什么受不受信任的说法了。

事实上，linux系统中通过system call(系统调用)来获取内核服务，freeRTOS中使用信号量、消息队列等方式来请求其他任务提供的服务。它们在使用上看起来只是调用了一个函数，但事实上这是远程过程调用（remote process call）的实现，目的在于降低应用程序的复杂度，让请求服务的行为看起来和调用一个常规函数是一样的，这有利于不同水平的开发人员异步维护同一个系统。

3）下面的代码中的数据存储服务接收来自客户端的数据读请求以及数据写请求，存储服务进行合法性检查，紧接着处理请求，最后向客户端发送响应，这些响应可以是读成功响应，可以是写成功响应，当然也可以是非法地址响应以及内存错误响应。

存储服务c文件。

/*********************************************************************
 * INCLUDES
 */
#include "trusted_storage_service.h"
#include <string.h>
#include "module_frame.h"
#include "stm32f10x_flash.h"

/*********************************************************************
 * LOCAL
 */
//机器特性
#define FLASH_BLOCK_SIZE	1024
#define FLASH_BLOCK_NUM		32
#define FLASH_WORD_LEN		(4)
#define FLASH_START_ADDR	((uint32_t)0x8000000)
#define FLASH_END_ADDR		((uint32_t)(0x8000000 + FLASH_BLOCK_NUM * FLASH_BLOCK_SIZE))
//人为定义（同样要根据机器特性来确定）
#define FLASH_PAGE_SIZE		128		//128字节
#define FLASH_PAGE_NUM		256		//256页

#define FLASH_REDO_TIMES	3		//当内存失效时，重复操作次数

const storageService_client_port_t storage_client_table_start __attribute__((section("storage.client.0"))) = {"",0,0,0,NULL,NULL,NULL,NULL,NULL};
const storageService_client_port_t storage_client_table_end   __attribute__((section("storage.client.2"))) = {"",0,0,0,NULL,NULL,NULL,NULL,NULL};

static uint8_t flashData_writeCache[FLASH_BLOCK_SIZE];	//flash数据写缓冲，驻留在ram中
static uint8_t flashData_readCache[FLASH_BLOCK_SIZE];	//flash数据读缓冲，驻留在ram中

static void trustedStorageService(void){
	const storageService_client_port_t* pClientPort = NULL;
	
	uint32_t operateAddr = 0, commonTempVariable = 0;
	uint16_t remainOperateBytes = 0, flashBlockUsableBytes = 0, operateBytes = 0; //剩余待操作的字节数，当前块可用字节数，正在操作的字节数
	uint8_t  flashBlockCoordinate = 0;	//当前操纵的块坐标
	uint16_t flashByteCoordinate = 0;	//当前操纵的块内字节坐标
	uint16_t index = 0, operateTimesCounter = 0;
	uint8_t  responseMsgType = 0;	//0：操作成功，1：无效地址，2：存储器故障
			
	for(pClientPort = &storage_client_table_start + 1; pClientPort < &storage_client_table_end; pClientPort++){
		//提取请求
//客户端写请求
		if(!memcmp(pClientPort->pRequestMsg,"write",5)){
			//无效的地址:超出用户私有存储空间范围的，起始地址不是字(4字节)对齐的。
			//无效的写入字节数:写入字节数不是字(4字节)对齐的
			if((*(pClientPort->pStartAddr) < pClientPort->storageStartAddr) || 
			   ((*(pClientPort->pStartAddr) + *(pClientPort->pBytes)) > pClientPort->storageEndAddr + 1) ||
			   (*(pClientPort->pStartAddr) % FLASH_WORD_LEN != 0) || (*(pClientPort->pBytes) % FLASH_WORD_LEN != 0)){
				//响应无效的地址与写入字节数输入（安全裕度原则与鲁棒性原则共存）			
				responseMsgType = 1;
			}else{
				//step1: 初始化操作辅助信息
				operateTimesCounter = 0;	//执行前复位
				responseMsgType = 0;		//执行前复位
				remainOperateBytes = *(pClientPort->pBytes);
				operateAddr = *(pClientPort->pStartAddr);
				flashBlockCoordinate = (operateAddr - FLASH_START_ADDR) / FLASH_BLOCK_SIZE;
				flashByteCoordinate  = (operateAddr - FLASH_START_ADDR) % FLASH_BLOCK_SIZE;
				flashBlockUsableBytes = FLASH_BLOCK_SIZE - flashByteCoordinate;
				while(remainOperateBytes){				
					//step2: 读取块并校验读取数据
					for(operateTimesCounter = 0; operateTimesCounter < FLASH_REDO_TIMES; operateTimesCounter++){
						for (index = 0; index < FLASH_BLOCK_SIZE / FLASH_WORD_LEN; index++){
							commonTempVariable = *(uint32_t*)(FLASH_START_ADDR + flashBlockCoordinate * FLASH_BLOCK_SIZE + index * 4);
							flashData_readCache[index * FLASH_WORD_LEN + 0] = commonTempVariable >>  0;
							flashData_readCache[index * FLASH_WORD_LEN + 1] = commonTempVariable >>  8;
							flashData_readCache[index * FLASH_WORD_LEN + 2] = commonTempVariable >> 16;
							flashData_readCache[index * FLASH_WORD_LEN + 3] = commonTempVariable >> 24;
						}
						if(0 == memcmp(flashData_readCache,(uint8_t*)(FLASH_START_ADDR + flashBlockCoordinate * FLASH_BLOCK_SIZE),FLASH_BLOCK_SIZE)){
							break;	//数据校验通过，跳出当前for循环
						}
					}
					if(operateTimesCounter >= FLASH_REDO_TIMES){
						responseMsgType = 2;	//存储器故障，直接退出
						break;
					}
					//step3: 更新数据
					memcpy(flashData_writeCache,flashData_readCache,FLASH_BLOCK_SIZE);
					operateBytes = remainOperateBytes;
					if(operateBytes > flashBlockUsableBytes){
						operateBytes = flashBlockUsableBytes;					
					}
					memcpy(&flashData_writeCache[flashByteCoordinate],
						   &(pClientPort->clientBuf)[*(pClientPort->pBytes)-remainOperateBytes],operateBytes);
					//step4: 写回flash并校验写入数据
						//应用程序与BootLoader区域的最后一道安全屏障
					if((flashBlockCoordinate <= FLASH_FORBIDDEN_STOP_BLOCK_1) ||
					   (flashBlockCoordinate >= FLASH_FORBIDDEN_START_BLOCK_2 && flashBlockCoordinate <= FLASH_FORBIDDEN_STOP_BLOCK_2)){
						//非法入侵BootLoader与应用程序区域
						responseMsgType = 1;
						break;		//跳出while循环				   
					}else if(0 != memcmp(flashData_writeCache,flashData_readCache,FLASH_BLOCK_SIZE)){	//即将写入的数据与读出数据不同才写入
						//至少执行一次，至多执行3次，如果flash发生块损坏不能一直在这里停着
						for(operateTimesCounter = 0; operateTimesCounter < FLASH_REDO_TIMES; operateTimesCounter++){
							__disable_irq();
							FLASH_Unlock();
							FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
							FLASH_ErasePage(FLASH_START_ADDR + flashBlockCoordinate * FLASH_BLOCK_SIZE);
							FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);	
							for (index = 0; index < FLASH_BLOCK_SIZE / FLASH_WORD_LEN; index++){
								commonTempVariable = 0U;
								commonTempVariable |= (uint32_t)flashData_writeCache[index * FLASH_WORD_LEN + 0] <<  0;
								commonTempVariable |= (uint32_t)flashData_writeCache[index * FLASH_WORD_LEN + 1] <<  8;
								commonTempVariable |= (uint32_t)flashData_writeCache[index * FLASH_WORD_LEN + 2] << 16;
								commonTempVariable |= (uint32_t)flashData_writeCache[index * FLASH_WORD_LEN + 3] << 24;				
								FLASH_ProgramWord(FLASH_START_ADDR + flashBlockCoordinate * FLASH_BLOCK_SIZE + index * FLASH_WORD_LEN, commonTempVariable);
								FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
							}				 
							FLASH_Lock();
							__enable_irq();
							//读出
							for (index = 0; index < FLASH_BLOCK_SIZE / FLASH_WORD_LEN; index++){
								commonTempVariable = *(uint32_t*)(FLASH_START_ADDR + flashBlockCoordinate * FLASH_BLOCK_SIZE + index * 4);
								flashData_readCache[index * FLASH_WORD_LEN + 0] = commonTempVariable >>  0;
								flashData_readCache[index * FLASH_WORD_LEN + 1] = commonTempVariable >>  8;
								flashData_readCache[index * FLASH_WORD_LEN + 2] = commonTempVariable >> 16;
								flashData_readCache[index * FLASH_WORD_LEN + 3] = commonTempVariable >> 24;
							}
							if(0 == memcmp(flashData_writeCache,flashData_readCache,FLASH_BLOCK_SIZE)){
								break;	//数据校验通过，跳出当前for循环
							}
						}
					}
					//调整下一个待操作块坐标与字节坐标
					if(operateTimesCounter >= FLASH_REDO_TIMES){
						responseMsgType = 2;	//存储器故障，直接退出
						break;
					}else{
						operateAddr += operateBytes;
						flashBlockCoordinate = (operateAddr - FLASH_START_ADDR) / FLASH_BLOCK_SIZE;
						flashByteCoordinate  = (operateAddr - FLASH_START_ADDR) % FLASH_BLOCK_SIZE;
						flashBlockUsableBytes = FLASH_BLOCK_SIZE - flashByteCoordinate;
						remainOperateBytes -= operateBytes;
					}
				}
			}
			//发送响应
			switch(responseMsgType){
				case 0:
					memcpy((void*)(pClientPort->pResponseMsg),"w_operation_ok",14);
					break;
				case 1:
					memcpy((void*)(pClientPort->pResponseMsg),"w_invalid_addr",14);
					break;
				case 2:
					memcpy((void*)(pClientPort->pResponseMsg),"w_mem_break",11);
					break;
				default:
					break;
			}			
			memset((void*)(pClientPort->pRequestMsg),0,5);
		}
//客户端读请求
		else if(!memcmp(pClientPort->pRequestMsg,"read",4)){
			//无效的地址:超出用户私有存储空间范围的，起始地址不是字(4字节)对齐的。
			//无效的写入字节数:写入字节数不是字(4字节)对齐的
			if((*(pClientPort->pStartAddr) < pClientPort->storageStartAddr) || 
			   ((*(pClientPort->pStartAddr) + *(pClientPort->pBytes)) > (pClientPort->storageEndAddr + 1)) ||
			   (*(pClientPort->pStartAddr) % FLASH_WORD_LEN != 0) || (*(pClientPort->pBytes) % FLASH_WORD_LEN != 0)){
				//响应无效的地址与写入字节数输入（安全裕度原则与鲁棒性原则共存）			
				responseMsgType = 1;
			}else{
				//step1: 初始化操作辅助信息
				operateTimesCounter = 0;	//执行前复位
				responseMsgType = 0;		//执行前复位
				remainOperateBytes = *(pClientPort->pBytes);
				operateAddr = *(pClientPort->pStartAddr);
				flashBlockCoordinate = (operateAddr - FLASH_START_ADDR) / FLASH_BLOCK_SIZE;
				flashByteCoordinate  = (operateAddr - FLASH_START_ADDR) % FLASH_BLOCK_SIZE;
				flashBlockUsableBytes = FLASH_BLOCK_SIZE - flashByteCoordinate;
				while(remainOperateBytes){				
					//step2: 读取块并校验读取数据
					if((flashBlockCoordinate <= FLASH_FORBIDDEN_STOP_BLOCK_1) ||
					   (flashBlockCoordinate >= FLASH_FORBIDDEN_START_BLOCK_2 && flashBlockCoordinate <= FLASH_FORBIDDEN_STOP_BLOCK_2)){
						//非法入侵BootLoader与应用程序区域
						responseMsgType = 1;
						break;		//跳出while循环				   
					}
					
					for(operateTimesCounter = 0; operateTimesCounter < FLASH_REDO_TIMES; operateTimesCounter++){
						for (index = 0; index < FLASH_BLOCK_SIZE / FLASH_WORD_LEN; index++){
							commonTempVariable = *(uint32_t*)(FLASH_START_ADDR + flashBlockCoordinate * FLASH_BLOCK_SIZE + index * 4);
							flashData_readCache[index * FLASH_WORD_LEN + 0] = commonTempVariable >>  0;
							flashData_readCache[index * FLASH_WORD_LEN + 1] = commonTempVariable >>  8;
							flashData_readCache[index * FLASH_WORD_LEN + 2] = commonTempVariable >> 16;
							flashData_readCache[index * FLASH_WORD_LEN + 3] = commonTempVariable >> 24;
						}
						if(0 == memcmp(flashData_readCache,(uint8_t*)(FLASH_START_ADDR + flashBlockCoordinate * FLASH_BLOCK_SIZE),FLASH_BLOCK_SIZE)){
							break;	//数据校验通过，跳出当前for循环
						}
					}
					if(operateTimesCounter >= FLASH_REDO_TIMES){
						responseMsgType = 2;	//存储器故障
						break;	//跳出while循环
					}
					//将数据写入用户缓冲
					operateBytes = remainOperateBytes;
					if(operateBytes > flashBlockUsableBytes){
						operateBytes = flashBlockUsableBytes;					
					}
					memcpy((uint8_t*)&(pClientPort->clientBuf)[*(pClientPort->pBytes)-remainOperateBytes],
						   &flashData_readCache[flashByteCoordinate],operateBytes);
					//调整下一个待操作块坐标与字节坐标
					operateAddr += operateBytes;
					flashBlockCoordinate = (operateAddr - FLASH_START_ADDR) / FLASH_BLOCK_SIZE;
					flashByteCoordinate  = (operateAddr - FLASH_START_ADDR) % FLASH_BLOCK_SIZE;
					flashBlockUsableBytes = FLASH_BLOCK_SIZE - flashByteCoordinate;
					remainOperateBytes -= operateBytes;
				}
			}
			//发送响应
			switch(responseMsgType){
				case 0:
					memcpy((void*)(pClientPort->pResponseMsg),"r_operation_ok",14);
					break;
				case 1:
					memcpy((void*)(pClientPort->pResponseMsg),"r_invalid_addr",14);
					break;
				case 2:
					memcpy((void*)(pClientPort->pResponseMsg),"r_mem_break",11);
					break;
				default:
					break;
			}
			memset((void*)(pClientPort->pRequestMsg),0,4);
		}		
	}
}module_register_taskFunc("storage_service",trustedStorageService);

存储服务头文件片段。

#ifndef _TRUSTED_STORAGE_SERVICE_H_
#define _TRUSTED_STORAGE_SERVICE_H_

#include <stdint.h>

/************************************************************************
 * CONSTANT-MACROS AND ENUMERATIONS
 */
/*
-----------------------------------------------------------------

	0x08000000 -----------------------------------
			   |		6kB bootload			 |
    0x08001800 -----------------------------------
			   |	    2KB update msg		     |
	0x08002000 -----------------------------------
			   |        22kB app area			 |
	0x08007800 -----------------------------------
			   |        2KB  NV data area        | <-
			   -----------------------------------

-----------------------------------------------------------------
*/
//禁止用户操作的区域
#define FLASH_FORBIDDEN_START_AREA_1	(uint32_t*)0x08000000		//BootLoader程序区域
#define FLASH_FORBIDDEN_STOP_AREA_1		(uint32_t*)0x080017FF

#define FLASH_FORBIDDEN_START_BLOCK_1	0	//上面的6KB区域产生6个块索引
#define FLASH_FORBIDDEN_STOP_BLOCK_1	5

#define FLASH_FORBIDDEN_START_AREA_2	(uint32_t*)0x08002000		//应用程序区域
#define FLASH_FORBIDDEN_STOP_AREA_2		(uint32_t*)0x080077FF

#define FLASH_FORBIDDEN_START_BLOCK_2	8
#define FLASH_FORBIDDEN_STOP_BLOCK_2	29

//存储器服务对象应当提供符合下面结构描述的端口
typedef struct {
	const char* clientName;						//客户名称	
	
	const uint32_t storageStartAddr;			//客户独占的存储器起始地址
	const uint32_t storageEndAddr;				//客户独占的存储器结束地址
	const uint16_t storagePageNums;				//客户独占的存储器页数
	
	const unsigned char* clientBuf;				//指向客户负载数据缓冲：要写入的内容，要装载读取数据的容器，校验码
	const uint32_t*      pStartAddr;			//客户请求操作数据的起始地址指针
	const uint16_t*      pBytes;				//客户请求操作的字节数指针
	const unsigned char* pRequestMsg;			//更新存储器请求指针: write,read
	const unsigned char* pResponseMsg;			//更新存储器响应指针：(w_,r_)operation_ok,invalid_addr,mem_break
}storageService_client_port_t;

//注册存储服务对象，客户名称请固定到15字节
#define storageService_register_client(clientName,privateStartAddr,privateEndAddr,privatePageNum, \
									   clientBuf,pOptionStartAddr,pOptionBytes,pRequestMsg,pResponseMsg) \
		__attribute__((used)) const storageService_client_port_t storage_client_##privateStartAddr##__LINE__ \
		__attribute__((section("storage.client.1"))) = {clientName,privateStartAddr,privateEndAddr,privatePageNum, \
		clientBuf,pOptionStartAddr,pOptionBytes,pRequestMsg,pResponseMsg}

#endif

客户端代码段。

//客户端代码段
#define NET_STORAGE_START_ADDR	0x08007800
#define NET_STORAGE_END_ADDR	0x0800797F
#define NET_STORAGE_PAGES		3	//128字节/页

#define NET_STORAGE_CACHE_SIZE	400

uint8_t  netStorageLoadBuf[NET_STORAGE_CACHE_SIZE];
uint32_t netStorageOptionStartAddr;
uint16_t netStorageOptionBytes;
uint8_t  netStorageRequestMsg[6];	//write,read,check
uint8_t  netStorageResponseMsg[15];	//option_ok,invalid_addr,mem_break

storageService_register_client("net____business",NET_STORAGE_START_ADDR,NET_STORAGE_END_ADDR,
							   NET_STORAGE_PAGES,
							   netStorageLoadBuf,&netStorageOptionStartAddr,&netStorageOptionBytes,
							   netStorageRequestMsg,netStorageResponseMsg);
void netManagementInit(void){
//初始化期间向存储服务发起读mac地址请求
	netStorageOptionStartAddr = NET_STORAGE_START_ADDR;
	netStorageOptionBytes = NET_STORAGE_PAGES * 128;
	memset(netStorageResponseMsg,0,15);		
	memcpy(netStorageRequestMsg,"read",4);
}module_server_register_initFunc("net_manager",netManagementInit);

void netManagementTask(void){
//无线参数存储事务-读响应
	if(!memcmp(netStorageResponseMsg,"r_operation_ok",14)){
		//to do
		memset(netStorageResponseMsg,0,14);
	}
}module_register_taskFunc("net_manager",netManagementTask);

4）利弊。

  1. 笔者在裸机实现中需要将请求过程显式地表达出来，因此相对于RPC实现必然是有不足的，但是对于程序员自己维护整个工程而言，是有利的。
  2. 上面的程序是裸机程序，以轮询的方式运行，因此客户端与服务器是异步运行的。在操作系统中，无论是system call内核陷入，还是信号量与消息队列的任务立即同步，其实时性是有保障的。特别是如果在轮询过程中，对按键检测的消抖不释放cpu的干等延时操作会导致系统实时性变差，因此需要仔细设计系统的组织方式并严格规避干等延时操作。但是相对而言，这样的组织方式足够简单清晰明了，程序员在组织系统的过程中会有意识地考量系统自主、自治以及系统边界的内容，对于提升系统稳定性是很有帮助的。

五、写在最后

上面的内容是笔者在实践应用中学习积累的经验之谈，受限于本人水平，必然会有错误以及不当之处，所以在分享个人经验的同时，也欢迎广大读者勘误讨论，发表自己的意见看法，共同交流，共同进步。

PP桑
关注
深入理解ROS2架构与运行机制：从系统设计到Python开发实战
bother3000的博客
07-20 983
ROS2采用分层架构设计，包含应用层、客户端库层、DDS抽象层、实现层和操作系统层，支持跨平台部署。其核心基于DDS中间件，提供去中心化通信、QoS策略控制和多种安全机制。ROS2支持四大通信模式（Topic/Service/Action/Parameter），并针对Python开发提供完善的节点生命周期管理。工具链包含rqt、ros2bag等调试工具，支持物联网和微控制器集成。最佳实践建议遵循节点单一职责原则，合理配置QoS策略，并在生产环境启用安全机制。
Go-Blb是一种分布式对象存储系统设计用于集群计算环境中的裸机
08-13
Go-Blb是一种专为集群计算环境中的裸机设计的分布式对象存储系统，它利用Go语言的并发特性和高效性能，构建了一个可扩展、高可用的存储解决方案。在本文中，我们将深入探讨Go-Blb的设计原理、核心功能以及如何在实际...
RT-Thread组件化系统架构设计
weixin_42561464的博客
11-16 789
本文深入剖析RT-Thread的组件化系统架构，涵盖统一内核对象模型、实时调度机制、设备驱动抽象、Kconfig配置与自动初始化机制，展示如何通过模块化设计实现高效、可扩展的嵌入式系统开发，适用于资源受限到复杂物联网场景。
软考-系统架构师-嵌入式系统（二）
持续学习ing
01-04 709
本文系统阐述了嵌入式技术全景，涵盖硬件选型、系统架构、数据管理与开发策略。硬件层区分了MPU（高性能）、MCU（单片化）与DSP，强调SoC通过软硬协同与IP核复用实现系统集成。软件层聚焦操作系统的实时性（确定性）与架构对比，重点解析鸿蒙OS凭借微内核、分布式软总线及内核抽象层实现跨终端协同。数据管理依据场景分为内存式（实时）、文件式（SQLite）与网络式（瘦客户端）。开发层面详解了“宿主机-目标机”的交叉开发模式，并指出通过“中断代查询”等软硬结合策略实现极致低功耗设计。
【系统架构设计】嵌入式系统设计（2）
weixin_48618536的博客
08-30 2347
螺旋模型比瀑布模型更加符合实际。ps：由小到大。
《系统架构设计师教程（第2版）》第2章-计算机系统基础知识-02-计算软件
架构+开发+运维
12-04 2213
《架构设计师教程（第2版）》清华版新教程笔记
HNU-2024操作系统实验-Lab1-环境配置
2403_85944944的博客
06-24 5106
从2024年开始，HNU信息院计科和智能专业统一使用李老师基于UniProton编写的新实验，一共有八个实验，如果仅是按照指导书的内容将实验跑通还是比较容易的（第一个实验除外），而对于想要在将来走系统方向的同学，或者遇上比较苛刻的助教，需要将整个实验的代码完全看懂，那就是一件任务量很大的事情了。一、实验目的1.安装交叉工具链（aarch64）以及安装QEMU模拟器2.创建裸机（Bare Metal）程序3.构件工程4.完成调试支持5.建立自动化脚本二、实验过程。
6、设计可扩展的事件驱动系统：消息导向架构解析
nnn11的博客
07-12 98
本文详细解析了可扩展的事件驱动系统中的消息导向架构，涵盖了消息处理的基础概念、主流消息代理（如 NATS 和 Apache Kafka）的核心特性与架构组件、消息代理的对比分析，以及消息导向架构在实际场景中的应用和实践示例。文章还探讨了消息导向架构的优势、挑战及未来发展趋势，为开发者构建高性能、可靠的分布式系统提供了全面的参考。
20、分布式系统与物联网架构中的网络通信技术解析
k5l6m的博客
12-05 12
本文深入解析了分布式系统与物联网架构中的核心网络通信技术，涵盖路由配置、套接字初始化与通信机制、动态路由协议（如OLSR和AODV）的选择与应用，以及基于wolfSSL的传输层安全实现。重点探讨了在裸机环境下的事件驱动模型、回调机制、网状网络构建策略及TLS加密通信的集成方法，为构建高效、安全的物联网通信系统提供了全面的技术指导。
【软考系统架构设计师】2009年下系统架构师综合知识历年真题
千月星跡
06-21 2908
【软考系统架构设计师】2009年下系统架构师综合知识历年真题
基于M5311的NB-IoT远程灯控系统设计与实现
压缩包内仅包含一个同名ZIP文件，表明该压缩包可能为嵌套结构或命名重复，但核心信息仍聚焦于基于NB-IoT通信技术、采用M5311模块并通过MQTT协议实现远程灯控的物联网系统设计。 首先，从标题和描述中可以提取出多个...
基于SpringBoot的LED-TCP通信系统设计与实现
“led-tcp-mastespringboot”这一项目名称结合其描述“springboot”以及相关标签（如SpringBoot、TCP、LED、通信系统、嵌入式、网络编程、服务器、数据传输、物联网、控制系统），揭示了一个基于Spring Boot框架构建...
C语言从句柄到对象 (一) —— 全局变量的噩梦与“多实例”的救赎
devicegate的博客
12-30 844
本文探讨了嵌入式开发中句柄(Handle)的概念与应用。通过电机控制案例，分析了传统单例模式在扩展性上的局限，并展示了如何通过句柄实现代码复用：将电机状态封装为结构体，通过指针(句柄)传递实例数据，使同一套逻辑可操作多个实例。文章比较了单例模式与句柄模式的适用场景，建议底层驱动库默认采用句柄模式以提高扩展性。最后指出当前实现仍存在数据暴露风险，预告下期将介绍不透明指针技术实现更安全的封装。全文揭示了句柄作为C语言实现模块化和面向对象设计的关键作用。
Nmap 完整教学与 Linux 指令详解
2401_84359179的博客
01-03 1632
总结：Nmap 是网络安全领域的"瑞士军刀"，掌握 `-sS`、`-sV`、`-O`、`-A`、`-p`、`-T`、 `--script` 这 7 大核心参数，即可应对 90% 的扫描场景。1.权限 ：SYN 扫描 (`-sS`)、OS 检测 (`-O`)、UDP 扫描 (`-sU`) 需要 root 权限。3. 防火墙：现代 IDS/IPS 能检测 Nmap 扫描特征，需配合 `-T2`、`-f`、`-D` 等规避。初学者 ：从 `-sT`、`-sV`、`-p` 开始，逐步学习高级选项。
基于 Linux 内核模块的字符设备互斥访问实验
weixin_57340941的博客
12-30 540
这个信号量实验是。
Linux 防火墙配置详解：iptables 与 firewalld 的实战指南
A5互联
12-30 1186
在企业级 Linux 运维场景中，防火墙不仅是简单的“开关”，而是关系到网络安全性、业务可用性与性能边界的重要组件。本文以真实项目经验为基础，结合具体硬件配置、产品参数、代码示例和性能评估，全面讲解 `iptables` 与 `firewalld` 的架构差异、实战配置与优化方法，帮助你从一线配置走向深入的性能调优与安全设计。
Linux CFS 调度器深度解析
X
12-30 804
数学模型驱动: 用 vruntime 精确量化公平性简单性: 核心算法简洁优雅, 易于理解和维护自适应性: 自动适应不同负载和工作模式可扩展性: 通过组调度支持复杂场景表5: CFS 调度器的核心优势总结维度传统调度器CFS改进效果公平性基于优先级的时间片按权重的比例公平更精确的公平分配交互性需要启发式识别自然获得良好响应交互进程响应更快吞吐量固定时间片可能浪费动态调整, 减少切换整体吞吐量提升可配置性多个复杂参数主要调整 nice 值用户接口更简单代码维护复杂启发式逻辑。
18. 操作系统-Linux-信创
princemilo的博客
12-30 991
在国家信创战略全面推进的大背景下，国产操作系统正加速替代国外系统，广泛应用于政企办公、关键基础设施、云计算、数据中心等核心领域。
Linux: network: ipv6: proxy_ndp
最新发布
mzhan017的博客
01-04 160
这意味着，如果一个主机 A 询问主机 B 的 MAC 地址，而主机 B 不在主机 A 的直接链路上，但有一个启用了 proxy_ndp 的中间设备 C 知道主机 B 的 MAC 地址，那么设备 C 就会代表主机 B 回复主机 A 的请求。桥接 (Bridging)：在某些复杂的桥接或虚拟化环境中，如果一个设备（如路由器或主机）需要为连接到其上的其他设备（如虚拟机或物理服务器）代理 NDP 消息，以确保它们能够被网络中的其他节点发现。将其值设置为 1 启用，设置为 0 禁用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值