分享一个重定向C库部分函数的方法，包含malloc、free、fopen等函数

WZH

在我们进行嵌入式开发时，难免要移植一些现有的成熟代码库，这些库大部分要借助C标准库中的输入输出接口、内存分配函数等。这也就产生了库函数重定向的问题。我们最常用重定向库函数为printf函数，重定向的方法为：

AC5

1. #ifndef __MICROLIB  //不勾选微库的话需要关闭半主从模式
   
2. #pragma import(__use_no_semihosting)
   
3. #endif
   
4. int fputc(int ch, FILE *f){
   
5.   //ch为要发送的字符
   
6.   return HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 100)==HAL_OK?ch:-1;
   
7. }

复制代码

AC6

1. #ifndef __MICROLIB //不勾选微库的话需要关闭半主从模式
   
2. __asm(".global __use_no_semihosting\n\t")
   
3. #endif
   
4. int fputc(int ch, FILE *f){
   
5. //ch为要发送的字符
   
6. return HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 100)==HAL_OK?ch:-1;
   
7. }

复制代码

有时我们需要重定向malloc、free等内存分配函数，不使用C库的内存分配，这在使用rtos时很常见，重定向malloc、free的方法为：
AC5

1. #pragma import(__use_no_heap_region)  //声明不使用C库的堆
   
2. 
   
3. void *malloc (size_t size){
   
4.         return OS_Malloc(size);
   
5. }
   
6. 
   
7. void free(void* p){
   
8.         OS_Free(p);
   
9. }
   
10. 
    
11. void *realloc(void* p,size_t want){
    
12.         return OS_Realloc(p,want);
    
13. }
    
14. 
    
15. void *calloc(size_t nmemb, size_t size){
    
16.         return OS_Calloc(nmemb,size);
    
17. }

复制代码

AC6

1. __asm(".global __use_no_heap_region\n\t"); //声明不使用C库的堆
   
2. void *malloc (size_t size){
   
3.         return OS_Malloc(size);
   
4. }
   
5. 
   
6. void free(void* p){
   
7.         OS_Free(p);
   
8. }
   
9. 
   
10. void *realloc(void* p,size_t want){
    
11.         return OS_Realloc(p,want);
    
12. }
    
13. 
    
14. void *calloc(size_t nmemb, size_t size){
    
15.         return OS_Calloc(nmemb,size);
    
16. }

复制代码

有的时候我们需要重定向C库的文件IO，如在移植LUA解释器时，源码中会调用C库的fopen、fread等函数，需要对这些IO重定向，这里以FATFS为例实现重定向。
最后给出AC5与AC6均适用的例子，包含重定向printf、重定向malloc、free、重定向io，这里需要注意的是，一定要将前面的fputc注释掉，因为在编译时fputc的优先级要大于_sys_write，这就导致printf、fwirte都会重定向到fputc中。

1. <blockquote>#include <rt_sys.h>

复制代码

WZH

1. #include <rt_sys.h>
   
2. #include <stdio.h>
   
3. 
   
4. #define SUPPORT_FILE_SYSTEM                0
   
5. #define SUPPORT_MALLOC                        1
   
6. 
   
7. #include "stm32h7xx_hal.h"
   
8. extern UART_HandleTypeDef huart1;
   
9. 
   
10. //约定返回值为1函数执行成功，0函数执行失败
    
11. #define MESSAGE_PRINT(BUF,LEN)  HAL_UART_Transmit(&huart1, (uint8_t*)BUF,LEN, 100)==HAL_OK
    
12. #define MESSAGE_SCANF(BUF,LEN) 0
    
13. #define OS_Malloc(SIZE)   NULL
    
14. #define OS_Free(P)
    
15. #define OS_Calloc(N,SIZE) NULL
    
16. #define OS_Realloc(P,SIZE) NULL
    
17. 
    
18. #if SUPPORT_FILE_SYSTEM
    
19.         #include "ff.h"
    
20. #endif
    
21. 
    
22. #if defined(__clang__)
    
23.         __asm(".global __use_no_semihosting\n\t");
    
24.         #if SUPPORT_MALLOC
    
25.                 __asm(".global __use_no_heap_region\n\t");
    
26.         #endif
    
27. #elif defined(__CC_ARM)
    
28.         #pragma import(__use_no_semihosting)
    
29.         #if SUPPORT_MALLOC
    
30.                 #pragma import(__use_no_heap_region)
    
31.         #endif
    
32. #endif
    
33. 
    
34. #if defined(__MICROLIB)
    
35.         #if defined(__clang__)
    
36.                 __asm(".global __use_full_stdio\n\t");
    
37.         #elif defined(__CC_ARM)
    
38.                 #pragma import(__use_full_stdio)
    
39.         #endif
    
40. #endif
    
41. 
    
42. #define STDIN        0
    
43. #define STDOUT        1
    
44. #define STDERR        2
    
45. #define IS_STD(fn)        ((fn)>=0&&(fn)<=2)
    
46. /*
    
47. * These names are used during library initialization as the
    
48. * file names opened for stdin, stdout, and stderr.
    
49. * As we define _sys_open() to always return the same file handle,
    
50. * these can be left as their default values.
    
51. */
    
52. const char __stdin_name[] = ":tt";
    
53. const char __stdout_name[] = ":tt";
    
54. const char __stderr_name[] = ":tt";
    
55. 
    
56. 
    
57. FILEHANDLE _sys_open(const char *pcFile, int openmode)
    
58. {
    
59. #if SUPPORT_FILE_SYSTEM
    
60.         BYTE mode;
    
61.         FIL *fp;
    
62.         FRESULT fr;
    
63. #endif
    
64.         if(pcFile==__stdin_name)
    
65.                 return STDIN;
    
66.         else if(pcFile==__stdout_name)
    
67.                 return STDOUT;
    
68.         else if(pcFile==__stderr_name)
    
69.                 return STDERR;
    
70. #if SUPPORT_FILE_SYSTEM
    
71.         fp=malloc(sizeof(FIL));
    
72.         if(fp==NULL){
    
73.                 printf("malloc fail!\r\n");
    
74.                 return -1;
    
75.         }
    
76.         /* http://elm-chan.org/fsw/ff/doc/open.html */
    
77.         if(openmode & OPEN_W){
    
78.                 mode = FA_CREATE_ALWAYS | FA_WRITE;
    
79.                 if (openmode & OPEN_PLUS)
    
80.                         mode |= FA_READ;
    
81.         }
    
82.         else if(openmode & OPEN_A){
    
83.                 mode = FA_OPEN_APPEND | FA_WRITE;
    
84.                 if (openmode & OPEN_PLUS)
    
85.                         mode |= FA_READ;
    
86.         }
    
87.         else{
    
88.                 mode = FA_READ;
    
89.                 if (openmode & OPEN_PLUS)
    
90.                         mode |= FA_WRITE;
    
91.         }
    
92. 
    
93.         fr = f_open(fp, pcFile, mode);
    
94.         if (fr == FR_OK)
    
95.                 return (FILEHANDLE)fp;
    
96. 
    
97.         free(fp);
    
98. #endif
    
99.         return -1;
    
100. }
     
101. 
     
102. int _sys_close(FILEHANDLE fh)
     
103. {
     
104. #if SUPPORT_FILE_SYSTEM
     
105.         FRESULT fr;
     
106. #endif
     
107.         if(IS_STD(fh))
     
108.                 return 0;
     
109. #if SUPPORT_FILE_SYSTEM
     
110.         fr = f_close((FIL *)fh);
     
111.         if (fr == FR_OK){
     
112.                 free((void *)fh);
     
113.                 return 0;
     
114.         }
     
115. #endif
     
116.         return -1;
     
117. }
     
118. 
     
119. int _sys_write(FILEHANDLE fh, const unsigned char *buf,\
     
120.         unsigned len, int mode)
     
121. {       
     
122. #if SUPPORT_FILE_SYSTEM
     
123.         FRESULT fr;
     
124.         UINT bw;
     
125. #endif
     
126.         if(fh==STDIN)
     
127.                 return -1;
     
128.        
     
129.         if(fh==STDOUT||fh==STDERR){
     
130.                 return MESSAGE_PRINT(buf,len)?0:-1;
     
131.         }
     
132. #if SUPPORT_FILE_SYSTEM       
     
133.         fr = f_write((FIL *)fh, buf, len, &bw);
     
134.         if (fr == FR_OK)
     
135.                 return len - bw;
     
136. #endif       
     
137.         return -1;
     
138. }
     
139. 
     
140. int _sys_read(FILEHANDLE fh, unsigned char *buf,\
     
141.         unsigned len, int mode)
     
142. {
     
143. #if SUPPORT_FILE_SYSTEM
     
144.         FRESULT fr;
     
145.         UINT br;
     
146. #endif
     
147.         if(fh==STDOUT||fh==STDERR){
     
148.                 return -1;
     
149.         }
     
150.         if(fh==STDIN){
     
151.                 return MESSAGE_SCANF(buf,len)?0:-1;
     
152.         }
     
153. #if SUPPORT_FILE_SYSTEM               
     
154.         fr = f_read((FIL *)fh, buf, len, &br);
     
155.         if (fr == FR_OK)
     
156.                 return len - br;
     
157. #endif
     
158.         return -1;
     
159. }
     
160. 
     
161. void _ttywrch(int ch)
     
162. {
     
163.         char c = ch;
     
164.         MESSAGE_PRINT(&c,1);
     
165. }
     
166. 
     
167. int _sys_istty(FILEHANDLE fh)
     
168. {
     
169.         return IS_STD(fh); /* buffered output */
     
170. }
     
171. 
     
172. int _sys_seek(FILEHANDLE fh, long pos)
     
173. {
     
174. #if SUPPORT_FILE_SYSTEM
     
175.         FRESULT fr;
     
176.         if(!IS_STD(fh)){
     
177.                 fr = f_lseek((FIL *)fh, pos);
     
178.                 if (fr == FR_OK)
     
179.                         return 0;
     
180.         }
     
181. #endif
     
182.         return -1;
     
183. }
     
184. 
     
185. long _sys_flen(FILEHANDLE fh)
     
186. {
     
187. #if SUPPORT_FILE_SYSTEM
     
188.         if (!IS_STD(fh))
     
189.                 return f_size((FIL *)fh);
     
190. #endif
     
191.         return -1;
     
192. }
     
193. int _sys_ensure(FILEHANDLE fh){
     
194. #if SUPPORT_FILE_SYSTEM
     
195.         if (!IS_STD(fh)){
     
196.                 if(f_sync((FIL*)fh)==FR_OK)
     
197.                         return 0;
     
198.         }
     
199. #endif
     
200.         return -1;
     
201. }
     
202. void _sys_exit(int code){
     
203.         printf("This Program unexpected exit! err:%d\r\n",code);
     
204.         while(1);
     
205. }
     
206. 
     
207. int remove(const char *pcPath){
     
208. #if SUPPORT_FILE_SYSTEM
     
209.         if(pcPath==__stdin_name||pcPath==__stdout_name||pcPath==__stderr_name)
     
210.                 return -1;
     
211.         if(f_unlink(pcPath)==FR_OK)
     
212.                 return 0;
     
213. #endif
     
214.         return -1;
     
215. }
     
216. 
     
217. //不清楚如何实现
     
218. int _sys_tmpnam(char * name, int sig, unsigned maxlen){
     
219.         return 0;
     
220. }
     
221. 
     
222. //重定向内存分配的相关库函数
     
223. #if SUPPORT_MALLOC
     
224. void *malloc (size_t size){
     
225.         return OS_Malloc(size);
     
226. }
     
227. 
     
228. void free(void* p){
     
229.         OS_Free(p);
     
230. }
     
231. 
     
232. void *realloc(void* p,size_t want){
     
233.         return OS_Realloc(p,want);
     
234. }
     
235. 
     
236. void *calloc(size_t nmemb, size_t size){
     
237.         return OS_Calloc(nmemb,size);
     
238. }
     
239. 
     
240. #endif
     

复制代码

zhang0352505

牛，受教了，多谢

eric2013

必须置cool，非常好

WZH

eric2013 发表于 2021-7-16 16:16
必须置cool，非常好

WZH

zhang0352505 发表于 2021-7-16 15:29
牛，受教了，多谢

WZH

另外补充资料来源，主要的参考资料为《Arm C and C++ Libraries and Floating-Point Support User Guide Version 6.16》，在MDK的安装目录下就有，以及网友们的一些经验。实测很稳定，在仅修改基础的头文件就可以完成LUA的基础移植。

fyyxxm

#ifndef __MICROLIB //不勾选微库的话需要关闭半主从模式
__asm(".global __use_no_semihosting\n\t")
#endif
int fputc(int ch, FILE *f){
//ch为要发送的字符
return HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 100)==HAL_OK?ch:-1;
}




#if defined(__MICROLIB)
        #if defined(__clang__)
                __asm(".global __use_full_stdio\n\t");
        #elif defined(__CC_ARM)
                #pragma import(__use_full_stdio)
        #endif
#endif


一个未定义，一个定义。两个都用？就用一个？

WZH

如果是简单使用printf的话，就用第一种方式，如果是需要重定向文件io的话就使用第三种方式

WZH

fyyxxm 发表于 2021-7-17 16:11
#ifndef __MICROLIB //不勾选微库的话需要关闭半主从模式
__asm(".global __use_no_semihosting\n\t")
#e ...

其实在使能微库的情况下，仅使用printf的话关不关半主从模式都一样，把那个ifndef去掉一样可以正常工作。因此这两种定义方式不矛盾。最后推荐使用我在一楼发的完整版代码。

ssimple

mark

abcde1224

楼主  这种malloc的方式稳定吗

morning_enr6U

WZH 发表于 2021-7-18 00:34
其实在使能微库的情况下，仅使用printf的话关不关半主从模式都一样，把那个ifndef去掉一样可以正常工作。 ...

这种情况下，用不用MicroLib，有什么区别吗？ 谢谢！

WZH

morning_enr6U 发表于 2021-12-20 13:15
这种情况下，用不用MicroLib，有什么区别吗？ 谢谢！

有区别，使用微库很多文件IO相关函数都需要更改，但会节省一些空间

morning_enr6U

WZH 发表于 2021-12-20 23:58
有区别，使用微库很多文件IO相关函数都需要更改，但会节省一些空间

感谢回复

那资源充足的情况下，不使用MicroLib，在功能上没有影响，对吧？

WZH

morning_enr6U 发表于 2021-12-21 08:39
感谢回复

那资源充足的情况下，不使用MicroLib，在功能上没有影响，对吧？

完全没影响，如果不用Microlib，一定要记住关闭半主从模式，那样才能重定向printf等函数，推荐使用我在帖子回复的方案

ihavedone

以前在 AC6 下实现过这个，现在 Cube MX + Free RTOS，只能用 AC5，结果冒出来这个错误。

问题是我怎么也找不到 sys_io.o 在哪里，我的工程也没有对应的 C 文件等。。。
真的是搞死人。

WZH

ihavedone 发表于 2021-12-21 17:42
以前在 AC6 下实现过这个，现在 Cube MX + Free RTOS，只能用 AC5，结果冒出来这个错误。

问题是我怎么 ...

把半主从模式关闭了么？

WZH

在源码添加这个命令试试
#pragma import(__use_no_semihosting)

WZH

abcde1224 发表于 2021-12-20 11:09
楼主  这种malloc的方式稳定吗

非常稳定，如果不放心，可以先在源码中添加这个代码：
__asm(".global __use_no_heap_region\n\t"); //声明不使用C库的堆
然后调用malloc函数，一般就会提示编译错误。

zhumx

版主，像fmount，fformat，等这样的函数是怎样重定向的？

庄永

很实用的知识，学到了。

mumuge

这样是一个字节一个字节地发吗？我想使用串口DMA一次性printf出去该如何重定向呢

dacongzi

cool

WZH

zhumx 发表于 2022-4-2 15:01
版主，像fmount，fformat，等这样的函数是怎样重定向的？

这个不是标准C库的内容，没有相关的重定向函数

WZH

mumuge 发表于 2022-4-6 09:24
这样是一个字节一个字节地发吗？我想使用串口DMA一次性printf出去该如何重定向呢

如果重定向的fputc，那么printf是一个字节一个字节发的，如果重定向的_sys_write，那么这个发送是缓冲发送的，内部有个64字节的缓冲，在缓冲满的时候或者输出\n字符时刷新缓冲，可以主动调用fflush函数刷新输出。
如果使用DMA重定向的话，建议重定向_sys_write，并在函数内部填充DMA发送缓冲区等待DMA发送完毕，结合系统使用消息邮箱+后台任务可以将其设计成非阻塞的发送函数

lililili

mark

      

mojinpan

请问有人测试过内存分配相关函数的重定向吗?我这边测试字节就挂掉,都起不来了

熊大

mask