使用clone函数+CLONE_NEWNS函数创建挂载命名空间，为啥别的进程还是能看见挂载信息

也是菜鸟

我的目标是用一个进程创建新的命名空间，在这个进程里做mount操作，达到只有同命名空间里的进程能看到挂载情况的目的。可是，这个效果就是没有，执行进程后，shell 里执行ls ，还是能看到挂载的文件。这是怎么回事呢？请高手指点！

代码如下：

1. #define _GNU_SOURCE
   
2. #include <stdio.h>                /* for convenience */
   
3. #include <stdlib.h>                /* for convenience */
   
4. #include <string.h>                /* for convenience */
   
5. #include <unistd.h>                /* for convenience */
   
6. #include <errno.h>
   
7. #include <pwd.h>
   
8. #include <sched.h>
   
9. #include <sys/types.h>
   
10. #include <sys/stat.h>
    
11. #include <fcntl.h>
    
12. #include <sys/wait.h>
    
13. #include <sys/mount.h>
    
14. 
    
15. 
    
16. #define MAXLINE 10
    
17. 
    
18. 
    
19. /*若某字符串中有多个空格，tab标志，换行符或者回车符 */
    
20. /*且这些字符可能接连出现，则将此字符串中的多个连续的*/
    
21. /*不可显示字符压缩为一个空格*/
    
22. /*参数len看似多余，其实有大用。如果源址与目的地址*/
    
23. /*重叠的情况下，可消除可能出现的死循环*/
    
24. void shrink(char *src,char *dest,size_t len)
    
25. {
    
26.         int i= 0,j=0;
    
27.         int n= 0;
    
28.         int spacelen = 0;
    
29.         while( (src[i]!='\0') && n<=len )
    
30.         {
    
31.                 if( (src[i]==32)||(src[i]==9)||(src[i]==10) )
    
32.                 {
    
33.                         if(spacelen==0)
    
34.                         {
    
35.                                 dest[j]=' ';
    
36.                                 spacelen++;
    
37.                                 i++;
    
38.                                 j++;
    
39.                         }
    
40.                         else
    
41.                                 i++;
    
42.                         n++;
    
43.                         continue;
    
44.                 }
    
45.                 dest[j]=src[i];
    
46.                 i++;
    
47.                 j++;
    
48.                 n++;
    
49.                 spacelen = 0;
    
50.         }
    
51.         dest[j]='\0';
    
52. }
    
53. 
    
54. 
    
55. 
    
56. 
    
57. 
    
58. char * my_itoa(int value,char *string,int radix)
    
59. {
    
60.         char zm[37]="0123456789abcdefghijklmnopqrstuvwxyz";
    
61.         char aa[100]={0};
    
62. 
    
63.         int sum=value;
    
64.         char *cp=string;
    
65.         int i=0;
    
66.        
    
67.         if(radix<2||radix>36)//增加了对错误的检测
    
68.         {
    
69.                 //cout<<"error data!"<<endl;
    
70.                 return string;
    
71.         }
    
72. 
    
73.         if(value<0)
    
74.         {
    
75.                 //cout<<"error data!"<<endl;
    
76.                 return string;
    
77.         }
    
78.        
    
79. 
    
80.         while(sum>0)
    
81.         {
    
82.                 aa[i++]=zm[sum%radix];
    
83.                 sum/=radix;
    
84.         }
    
85. 
    
86.         for(int j=i-1;j>=0;j--)
    
87.         {
    
88.                 *cp++=aa[j];
    
89.         }
    
90.         *cp='\0';
    
91.         return string;
    
92. }
    
93. 
    
94. 
    
95. 
    
96. 
    
97. 
    
98. //按空格切分字符串。假设sub数组的长度够用
    
99. int splitestr(const char *src,char sub[][256],int * argc)
    
100. {
     
101.         /*split a string by space key*/
     
102.         int i=0;
     
103.         int j=0;
     
104.         int len=0;
     
105.         int flag=0;
     
106.         char *tmp=NULL;
     
107.         while( src[i]!='\0' )
     
108.         {
     
109.                 if (src[i]!=' ')
     
110.                 {
     
111.                         i++;
     
112.                         len++;
     
113.                 }
     
114.                 if(src[i]==' ' )
     
115.                 {
     
116.                         i++;
     
117.                         tmp = (char *)&src[flag];
     
118.                         strncpy(sub[j],tmp,len);
     
119.                         j++;
     
120.                         flag = i;
     
121.                         len =0;
     
122.                 }
     
123.         }
     
124.         tmp = (char *)&src[flag];
     
125.         strncpy(sub[j],tmp,len);
     
126.         *argc = j+1;
     
127.         return 0;
     
128. }
     
129. 
     
130. 
     
131. int get_ns_id(pid_t pid,const char *ns_type)
     
132. {
     
133.     char tmp[20] = {0};
     
134.     my_itoa(pid,tmp,10);
     
135. 
     
136.     char cmd[50] = {0};
     
137.     strcat(cmd,"ls -l /proc/");
     
138.     strcat(cmd,tmp);
     
139.     strcat(cmd,"/ns/");
     
140. 
     
141.     FILE   *stream;
     
142.     char buf[1000] = {0};
     
143.     stream = popen(cmd, "r" ); //将命令的输出 通过管道读取(“r”参数)到FILE* stream
     
144.     fread( buf, sizeof(char), sizeof(buf), stream); //将刚刚FILE* stream的数据流读取到buf中
     
145.     pclose( stream );
     
146. 
     
147. 
     
148. /*
     
149. 
     
150.         mode_t f_attrib = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH;   
     
151.         char * tmpfile = tmpnam(0);
     
152.         printf("tmpfile:%s\n",tmpfile);
     
153. 
     
154.         int fd = open(tmpfile, O_RDWR|O_CREAT,f_attrib);
     
155. 
     
156.     if(fd == -1)
     
157.         perror("open tmpfile error");
     
158. 
     
159.     int old_fd=dup(STDOUT_FILENO);  //保存屏幕输出的文件描述符，用于恢复
     
160.         dup2(fd,STDOUT_FILENO);         //输出重定向
     
161. 
     
162.     char buf[1000] = {0};
     
163.         system(cmd);
     
164.     read(fd,buf,1000);
     
165.     close(fd);
     
166.     dup2(old_fd,STDOUT_FILENO);  // 还原屏幕输出默认文件描述符指向
     
167. 
     
168. */
     
169.     //printf("buf:%s\n",buf);
     
170. 
     
171.     char search[20] = {0};
     
172.     strcat(search,ns_type);
     
173.     strcat(search,"[");
     
174. 
     
175.     char *first_pos = strstr(buf,search);
     
176.     char *last_pos = strstr(first_pos,"]");
     
177.     char ns_name[20] = {0};
     
178.     strncpy(ns_name, first_pos+strlen(search), last_pos-(first_pos+strlen(search)) );
     
179.     //printf("ns_name:%s\n",ns_name);
     
180. 
     
181.     return atoi(ns_name);
     
182. }
     
183. 
     
184. 
     
185. void my_system(const char * cmd)
     
186. {
     
187.         char cmd2[200] = {0};
     
188.         strcpy(cmd2,cmd);
     
189.         shrink(cmd2,cmd2,strlen(cmd2));
     
190.        
     
191.         pid_t        pid;
     
192.         if ((pid = fork()) < 0)
     
193.         {
     
194.                 perror("fork error\n");
     
195.         }
     
196.         else if (pid == 0)
     
197.         {       
     
198.                 setuid(0);
     
199. 
     
200.         char path[50] = {0};
     
201.         strcat(path,"/proc/");
     
202. 
     
203.         char tmp[20] = {0};
     
204.         pid_t parent_pid = getppid();
     
205.         my_itoa(parent_pid,tmp,10);
     
206. 
     
207.         strcat(path,tmp);
     
208.         strcat(path,"/ns/mnt");
     
209. 
     
210.         //get mount id of parent
     
211.         int mnt_fd = open(path,O_RDONLY);
     
212.          if (mnt_fd == -1)
     
213.                perror("open mnt");
     
214. 
     
215.         if (setns(mnt_fd, CLONE_NEWNS) == -1)
     
216.             perror("setns error");
     
217. 
     
218. 
     
219.         int argc = 0;
     
220.         char args[10][256] = {0};
     
221.         splitestr(cmd2,args,&argc);
     
222. 
     
223. 
     
224.         char * argv[10] = {0};
     
225.         for(int i=0;i< argc;i++)
     
226.         {
     
227.             argv[i] = args[i];
     
228.                         printf("%s\n",argv[i]);
     
229.         }
     
230. 
     
231.                 if (execvp(argv[0], argv) < 0)
     
232.                         perror("execl error\n");
     
233. 
     
234.         close(mnt_fd);
     
235.         }
     
236. 
     
237.         if (waitpid(pid, 0, 0) < 0)
     
238.                 perror("wait error\n");
     
239. }
     
240. 
     
241. 
     
242. static char child_stack[1048576];
     
243. 
     
244. static int child_fn()
     
245. {
     
246.     setuid(0);
     
247. 
     
248. 
     
249.         //if (unshare(CLONE_NEWNS) < 0)
     
250.         //{
     
251.         //        perrpr("unshare");
     
252.         //}
     
253. 
     
254. 
     
255.         char pass[] = {'1','2','3','4','5','6'};
     
256.         mode_t f_attrib = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH;   
     
257.         char * tmpfile = tmpnam(0);
     
258.         int fd = open(tmpfile, O_RDWR|O_CREAT,f_attrib);
     
259.         write(fd,pass,sizeof(pass));
     
260. 
     
261.     int old_fd=dup(STDIN_FILENO);  //保存描述符，用于恢复
     
262.         dup2(fd,STDIN_FILENO);
     
263.         lseek(0,0,SEEK_SET);
     
264. 
     
265.         //char cmd2[100] = {0};
     
266.         my_system("cryptsetup luksOpen /home/wxf/dss/sdb1 dss_encrypted_partition");
     
267.         close(fd);
     
268.         unlink(tmpfile);
     
269. 
     
270.     dup2(old_fd,STDIN_FILENO);  // 还原文件描述符
     
271. 
     
272.         //my_system("mkfs.ext4 /dev/mapper/dss_encrypted_partition");
     
273.         my_system("mount --make-private  /dev/mapper/dss_encrypted_partition /mnt/dssdir");
     
274.         //my_system("mount    /dev/mapper/dss_encrypted_partition    /mnt/dssdir");
     
275. 
     
276.         while(1)
     
277.         {
     
278.                 sleep(10);
     
279.         }
     
280. 
     
281.     return 0;
     
282. }
     
283. 
     
284. 
     
285. 
     
286. int main(int argc, char *argv[])
     
287. {
     
288.           pid_t child_pid = clone(child_fn, child_stack+1048576,  CLONE_NEWNS, 0);// 0x00020000   CLONE_NEWNS
     
289. 
     
290.     if(child_pid == -1)
     
291.         perror("clone error");
     
292. 
     
293.           return 0;
     
294. }
     

复制代码