这段代码中的malloc会不会造成内存泄露？如果会怎么解决？

steveneast

1. 
   
2. /*        prompting shell version 1
   
3. *                Prompts for the command and its arguments.
   
4. *                Builds the argument vector for the call to execvp.
   
5. *                Uses execvp(), and never returns.
   
6. */
   
7. 
   
8. #include        <stdio.h>
   
9. #include        <signal.h>
   
10. #include        <string.h>
    
11. 
    
12. #define        MAXARGS                20                                /* cmdline args        */
    
13. #define        ARGLEN                100                                /* token length        */
    
14. 
    
15. int main()
    
16. {
    
17.         char        *arglist[MAXARGS+1];                /* an array of ptrs        */
    
18.         int        numargs;                        /* index into array        */
    
19.         char        argbuf[ARGLEN];                        /* read stuff here        */
    
20.         char        *makestring();                        /* malloc etc                */
    
21. 
    
22.         numargs = 0;
    
23.         while ( numargs < MAXARGS )
    
24.         {                                       
    
25.                 printf("Arg[%d]? ", numargs);
    
26.                 if ( fgets(argbuf, ARGLEN, stdin) && *argbuf != '\n' )
    
27.                         arglist[numargs++] = makestring(argbuf);
    
28.                 else
    
29.                 {
    
30.                         if ( numargs > 0 ){                /* any args?        */
    
31.                                 arglist[numargs]=NULL;        /* close list        */
    
32.                                 execute( arglist );        /* do it        */
    
33.                                 numargs = 0;                /* and reset        */
    
34.                         }
    
35.                 }
    
36.         }
    
37.         return 0;
    
38. }
    
39. 
    
40. int execute( char *arglist[] )
    
41. /*
    
42. *        use execvp to do it
    
43. */
    
44. {
    
45.         execvp(arglist[0], arglist);                /* do it */
    
46.         perror("execvp failed");
    
47.         exit(1);
    
48. }
    
49. 
    
50. char * makestring( char *buf )
    
51. /*
    
52. * trim off newline and create storage for the string
    
53. */
    
54. {
    
55.         char        *cp, *malloc();
    
56. 
    
57.         buf[strlen(buf)-1] = '\0';                /* trim newline        */
    
58.         cp = malloc( strlen(buf)+1 );                /* get memory        */
    
59.                 /*  这里向内存申请分配了内存，可是整个程序都没有 free 的调用，不知道会不会造成内存泄露？ */
    
60.         if ( cp == NULL ){                        /* or die        */
    
61.                 fprintf(stderr,"no memory\n");
    
62.                 exit(1);
    
63.         }
    
64.         strcpy(cp, buf);                /* copy chars        */
    
65.         return cp;                        /* return ptr        */
    
66. }
    

复制代码

scutan

不会，因为exec系列的函数会使用新的程序替换掉之前进程中的堆空间。所以不会造成内存泄漏。

雨过白鹭洲

听上去很有道理

scutan

原帖由 雨过白鹭洲 于 2008-12-8 23:12 发表
听上去很有道理

APUE2上面的

The process ID does not change across an exec, because a new process is not created; exec merely replaces the current processits text, data, heap, and stack segmentswith a brand new program from disk.

不过我觉得有空还是可以测试一下，比如说先malloc一个很大的内存，然后再exec，再看该程序是否占用了那么多的内存。

samon_fu

查man手册：

execve() does not return on success, and the text, data, bss, and stack
       of the calling process are overwritten by that of the  program  loaded.
       The  program  invoked  inherits the calling process's PID, and any open
       file descriptors that are not set to close on exec.  Signals pending on
       the  calling  process are cleared.  Any signals set to be caught by the
       calling process are reset to their default behaviour.  The SIGCHLD sig-
       nal (when set to SIG_IGN) may or may not be reset to SIG_DFL.

没看到heap。

但是，通过在exec前加sleep语句试了下，在执行exec前，内存是used了，exec执行对应命令后，如 /bin/ls， 那么内存会回来。

所以认为没问题。

alexhappy

原帖由 scutan 于 2008-12-8 23:05 发表
不会，因为exec系列的函数会使用新的程序替换掉之前进程中的堆空间。所以不会造成内存泄漏。

那么以前的栈内存到哪里去了？被回收了么？

futuregod

简单修改了一下。

1. /*        prompting shell version 1
   
2. *        *                Prompts for the command and its arguments.
   
3. *        *                Builds the argument vector for the call to execvp.
   
4. *        *                Uses execvp(), and never returns.
   
5. *        */
   
6. 
   
7. #include        <stdio.h>
   
8. #include        <signal.h>
   
9. #include        <unistd.h>
   
10. #include        <stdlib.h>
    
11. #include        <string.h>
    
12. 
    
13. #define        MAXARGS                2                                /* cmdline args        */
    
14. #define        ARGLEN                100                                /* token length        */
    
15. 
    
16. 
    
17. int execute( char *arglist[] );
    
18. 
    
19. int main()
    
20. {
    
21.     char        *arglist[MAXARGS+1];                /* an array of ptrs        */
    
22.     int        numargs;                        /* index into array        */
    
23.     char        argbuf[ARGLEN];                        /* read stuff here        */
    
24.     char        *makestring();                        /* malloc etc                */
    
25. 
    
26.     numargs = 0;
    
27.     while ( numargs < MAXARGS )
    
28.     {
    
29.         printf("Arg[%d]? ", numargs);
    
30.         if ( fgets(argbuf, ARGLEN, stdin) && *argbuf != '\n' )
    
31.             arglist[numargs++] = makestring(argbuf);
    
32.         else
    
33.         {
    
34.             if ( numargs > 0 ){                /* any args?        */
    
35.                 arglist[numargs]=NULL;        /* close list        */
    
36.                 execute( arglist );        /* do it        */
    
37.                 numargs = 0;                /* and reset        */
    
38.             }
    
39.         }
    
40.     }
    
41.     return 0;
    
42. }
    
43. 
    
44. int execute( char *arglist[] )
    
45.     /*
    
46.      * *        use execvp to do it
    
47.      * */
    
48. {
    
49.             execvp(arglist[0], arglist);                /* do it */
    
50.                     perror("execvp failed");
    
51.                             exit(1);
    
52. }
    
53. 
    
54. char * makestring( char *buf )
    
55.     /*
    
56.      * * trim off newline and create storage for the string
    
57.      * */
    
58. {
    
59.     char        *cp;
    
60. 
    
61.     buf[strlen(buf)-1] = '\0';                /* trim newline        */
    
62.     cp = malloc( strlen(buf)+1 );                /* get memory        */
    
63.     if ( cp == NULL ){                        /* or die        */
    
64.         fprintf(stderr,"no memory\n");
    
65.         exit(1);
    
66.     }
    
67.     strcpy(cp, buf);                /* copy chars        */
    
68.     return cp;                        /* return ptr        */
    
69. }
    

复制代码

1. 
   
2. [jimmy@local memory]$ valgrind --tool=memcheck -v --leak-check=yes ./test_shell
   
3. ==7138== Memcheck, a memory error detector for x86-linux.
   
4. ==7138== Copyright (C) 2002-2004, and GNU GPL'd, by Julian Seward et al.
   
5. ==7138== Using valgrind-2.2.0, a program supervision framework for x86-linux.
   
6. ==7138== Copyright (C) 2000-2004, and GNU GPL'd, by Julian Seward et al.
   
7. ==7138== Valgrind library directory: /usr/lib/valgrind
   
8. ==7138== Command line
   
9. ==7138==    ./test_shell
   
10. ==7138== Startup, with flags:
    
11. ==7138==    --tool=memcheck
    
12. ==7138==    -v
    
13. ==7138==    --leak-check=yes
    
14. ==7138== Contents of /proc/version:
    
15. ==7138==   Linux version 2.6.9-22.EL ([email]bhcompile@porky.build.redhat.com[/email]) (gcc version 3.4.4 20050721 (Red Hat 3.4.4-2)) #1 Mon Sep 19 18:20:28 EDT 2005
    
16. ==7138== Reading syms from /home/jimmy/learn/memory/test_shell (0x8048000)
    
17. ==7138==    object doesn't have any debug info
    
18. ==7138== Reading syms from /lib/ld-2.3.4.so (0x1B8E4000)
    
19. ==7138==    object doesn't have any debug info
    
20. ==7138== Reading syms from /usr/lib/valgrind/stage2 (0xB0000000)
    
21. ==7138== Reading syms from /lib/ld-2.3.4.so (0xB1000000)
    
22. ==7138==    object doesn't have any debug info
    
23. ==7138== Reading syms from /usr/lib/valgrind/vgskin_memcheck.so (0xB7C96000)
    
24. ==7138== Reading syms from /lib/tls/libc-2.3.4.so (0xB7EBF000)
    
25. ==7138==    object doesn't have any debug info
    
26. ==7138== Reading syms from /lib/libdl-2.3.4.so (0xB7FEA000)
    
27. ==7138==    object doesn't have any debug info
    
28. ==7138== Reading suppressions file: /usr/lib/valgrind/default.supp
    
29. ==7138== REDIRECT soname:libc.so.6(__GI___errno_location) to soname:libpthread.so.0(__errno_location)
    
30. ==7138== REDIRECT soname:libc.so.6(__errno_location) to soname:libpthread.so.0(__errno_location)
    
31. ==7138== REDIRECT soname:libc.so.6(__GI___h_errno_location) to soname:libpthread.so.0(__h_errno_location)
    
32. ==7138== REDIRECT soname:libc.so.6(__h_errno_location) to soname:libpthread.so.0(__h_errno_location)
    
33. ==7138== REDIRECT soname:libc.so.6(__GI___res_state) to soname:libpthread.so.0(__res_state)
    
34. ==7138== REDIRECT soname:libc.so.6(__res_state) to soname:libpthread.so.0(__res_state)
    
35. ==7138== REDIRECT soname:libc.so.6(stpcpy) to *vgpreload_memcheck.so*(stpcpy)
    
36. ==7138== REDIRECT soname:libc.so.6(strnlen) to *vgpreload_memcheck.so*(strnlen)
    
37. ==7138== REDIRECT soname:ld-linux.so.2(stpcpy) to *vgpreload_memcheck.so*(stpcpy)
    
38. ==7138== REDIRECT soname:ld-linux.so.2(strchr) to *vgpreload_memcheck.so*(strchr)
    
39. ==7138==
    
40. ==7138== Reading syms from /usr/lib/valgrind/vg_inject.so (0x1B8FC000)
    
41. ==7138== Reading syms from /usr/lib/valgrind/vgpreload_memcheck.so (0x1B901000)
    
42. ==7138== TRANSLATE: 0x1B8F5F00 redirected to 0x1B904100
    
43. ==7138== Reading syms from /lib/tls/libc-2.3.4.so (0x875000)
    
44. ==7138==    object doesn't have any debug info
    
45. ==7138== TRANSLATE: 0x1B8E47A0 redirected to 0x52BFF040
    
46. Arg[0]? hello
    
47. ==7138== TRANSLATE: 0x8D8F00 redirected to 0x1B9048F8
    
48. Arg[1]? hello
    
49. ==7138== TRANSLATE: 0x8D6E30 redirected to 0x1B904E24
    
50. ==7138==
    
51. ==7138== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 12 from 1)
    
52. --7138--
    
53. --7138-- supp:   12 dl_relocate_object/dl_main
    
54. ==7138== malloc/free: in use at exit: 12 bytes in 2 blocks.
    
55. ==7138== malloc/free: 2 allocs, 0 frees, 12 bytes allocated.
    
56. ==7138==
    
57. ==7138== searching for pointers to 2 not-freed blocks.
    
58. ==7138== checked 1373240 bytes.
    
59. ==7138==
    
60. ==7138== [color=Red]12 bytes in 2 blocks are definitely lost in loss record 1 of 1[/color]
    
61. ==7138==    at 0x1B904984: malloc (vg_replace_malloc.c:131)
    
62. ==7138==    by 0x8048675: makestring (in /home/jimmy/learn/memory/test_shell)
    
63. ==7138==    by 0x80485D3: main (in /home/jimmy/learn/memory/test_shell)
    
64. ==7138==
    
65. ==7138== LEAK SUMMARY:
    
66. ==7138==    definitely lost: 12 bytes in 2 blocks.
    
67. ==7138==    possibly lost:   0 bytes in 0 blocks.
    
68. ==7138==    still reachable: 0 bytes in 0 blocks.
    
69. ==7138==         suppressed: 0 bytes in 0 blocks.
    
70. ==7138== Reachable blocks (those to which a pointer was found) are not shown.
    
71. ==7138== To see them, rerun with: --show-reachable=yes
    
72. --7138--     TT/TC: 0 tc sectors discarded.
    
73. --7138--            2209 tt_fast misses.
    
74. --7138-- translate: new     2067 (36681 -> 485142; ratio 132:10)
    
75. --7138--            discard 2 (59 -> 840; ratio 142:10).
    
76. --7138-- chainings: 1306 chainings, 3 unchainings.
    
77. --7138--  dispatch: 0 jumps (bb entries); of them 4627 (462700%) unchained.
    
78. --7138--            24/2274 major/minor sched events.
    
79. --7138-- reg-alloc: 474 t-req-spill, 90449+3948 orig+spill uis,
    
80. --7138--            11433 total-reg-rank
    
81. --7138--    sanity: 22 cheap, 1 expensive checks.
    
82. --7138--    ccalls: 7810 C calls, 54% saves+restores avoided (25038 bytes)
    
83. --7138--            10348 args, avg 0.87 setup instrs each (2658 bytes)
    
84. --7138--            0% clear the stack (23325 bytes)
    
85. --7138--            3535 retvals, 30% of reg-reg movs avoided (2056 bytes)
    

复制代码

[ 本帖最后由 futuregod 于 2008-12-9 10:20 编辑 ]

futuregod

结果表明，有memory leak

scutan

原帖由 futuregod 于 2008-12-9 10:21 发表
结果表明，有memory leak

看内核源代码的话，确实是会回收的。

exec->sys_execve->do_execve
在do_execve中会新创建一个mm_struct结构体。
然后再调用search_binary_handler->load_elf_binary
在 load_elf_binary 中再调用 flush_old_exec，就在这个函数中释放分配给进程的内存描述符，所有的线性区以及所有的页框，并清除进程的页表。
既然页表都没有了，以前所分配的空间自然也就释放了。

futuregod

狠！ kernel都分析了，那块我不懂了。 但是valgrid 不会无故报错吧。