查询进程间，父子进程，相互调用信息

点击(此处)折叠或打开

1. #!/bin/sh
   
2. 
   
3. #程序描述：查询进程间，父子进程，相互调用信息
   
4. #作者:    程晓鹏
   
5. #日期：    2016.12.06
   
6. 
   
7. ps_exe_cmd="ps -ef";
   
8. print_column_spliter="\t"; #打印列分隔符
   
9. 
   
10. #查询字符串长度
    
11. #参数1： 查询的字符串
    
12. function QueryStrLen
    
13. {
    
14.   v_input="$1";
    
15.   v_result=`echo "${#v_input}" | awk '{print int($0)}'`;
    
16.   echo "$v_result";
    
17. }
    
18. 
    
19. #获取子字符串
    
20. #参数1：原始字符串
    
21. #参数2：开始的位置（从1开始）
    
22. #参数3：长度
    
23. function getSubStr
    
24. {
    
25.   v_result=""; #返回值
    
26.   v_input="$1";
    
27.   v_idx="$2";
    
28.   v_len="$3";
    
29.   
    
30.   v_result=`echo "${v_input}" | awk '{print substr($0, vv_idx, vv_len)}' vv_idx=${v_idx} vv_len=${v_len}`;
    
31.   echo "$v_result"
    
32. }
    
33. 
    
34. #查询索引值
    
35. #参数1：要查询的原始字符串
    
36. #参数2：查询的关键字
    
37. #返回值：0:代表没有搜索到；大于0，代表搜索到的索引值
    
38. function queryIndex
    
39. {
    
40.   v_result=0; #返回值
    
41.   v_str="$1";
    
42.   v_key="$2";
    
43. 
    
44.   v_str_len=$(QueryStrLen "${v_str}");
    
45.   v_key_len=$(QueryStrLen "${v_key}");
    
46. 
    
47.   if [ $v_str_len -gt 0 ] && [ $v_key_len -gt 0 ]; then
    
48.     v_result=`echo "${v_str}" | awk '{print index($0, q_key)}' q_key=${v_key}`;
    
49.   fi;
    
50. 
    
51.   echo $v_result;
    
52. }
    
53. 
    
54. #查询进程ID
    
55. #参数1：字符串
    
56. function queryProcessID
    
57. {
    
58.   v_result=""; #返回结果
    
59.   v_input="$1";
    
60.   v_result=`echo ${v_input} | awk '{print $2}'`;
    
61.   echo "$v_result";
    
62. }
    
63. 
    
64. #查询父进程ID
    
65. #参数1：字符串
    
66. function queryPProcessID
    
67. {
    
68.   v_result=""; #返回结果
    
69.   v_input="$1";
    
70.   v_result=`echo ${v_input} | awk '{print $3}'`;
    
71.   echo "$v_result";
    
72. }
    
73. 
    
74. 
    
75. #查询进程用户
    
76. #参数1：字符串
    
77. function queryProcessUser
    
78. {
    
79.   v_result=""; #返回结果
    
80.   v_input="$1";
    
81.   v_result=`echo ${v_input} | awk '{print $1}'`;
    
82.   echo "$v_result";
    
83. }
    
84. 
    
85. #查询进程名称
    
86. #参数1：要查找的字符串
    
87. #参数2：查询的关键字
    
88. function queryProcessName_exec
    
89. {
    
90.   v_result=""; #返回结果
    
91.   v_input="${1}";
    
92.   v_key="${2}";
    
93.   v_input_len=$(QueryStrLen "${v_input}");
    
94.   v_idx=$(queryIndex "${v_input}" "${v_key}");
    
95. 
    
96.   if [ v_idx -gt 0 ]; then
    
97.     v_len=`expr "$v_input_len" - "$v_idx" + 1 | bc`;
    
98.     v_result=$(getSubStr "${v_input}" "$v_idx" "$v_len");
    
99.   fi;
    
100. 
     
101.   echo "${v_result}";
     
102. }
     
103. 
     
104. #获取进程名称
     
105. #参数1：字符串
     
106. function queryProcessName
     
107. {
     
108.   v_result=""; #返回结果
     
109.   v_input="$1";
     
110.   v_exe_name=`echo "${v_input}" | awk '{print $8}'`; #查询进程名称，开始字符串
     
111.   v_len=$(QueryStrLen "${v_exe_name}");
     
112.   if [ $v_len -gt 0 ]; then
     
113.     v_result=$(queryProcessName_exec "${v_input}" "${v_exe_name}");
     
114.   fi;
     
115. 
     
116.   echo "${v_result}";
     
117. }
     
118. 
     
119. #清除所有空格
     
120. #参数1：所有字符串
     
121. function CleanSpace
     
122. {
     
123.   v_in_str="$1";
     
124.   echo "$v_in_str" | sed s/[[:space:]]//g;
     
125. }
     
126. 
     
127. #打印输出信息头
     
128. function PrintHead
     
129. {
     
130.   column_1="user";
     
131.   column_2="pid";
     
132.   column_3="ppid";
     
133.   column_4="cmd";
     
134.   col_char="$print_column_spliter"; #列分隔符
     
135. 
     
136.   echo "${column_1}${col_char}${column_2}${col_char}${column_3}${col_char}${column_4}";
     
137. }
     
138. 
     
139. #打印数据
     
140. #参数1: 字符串
     
141. function PrintItem
     
142. {
     
143.   line="$1"; #入参数据
     
144.   q_user=$(queryProcessUser "$line");
     
145.   q_pid=$(queryProcessID "$line");
     
146.   q_ppid=$(queryPProcessID "$line");
     
147.   q_pname=$(queryProcessName "$line");
     
148.   col_char=${print_column_spliter}; #列分隔符
     
149. 
     
150.   echo "${q_user}${col_char}${q_pid}${col_char}${q_ppid}${col_char}${q_pname}";
     
151. }
     
152. 
     
153. #获取子进程
     
154. #参数1：进程ID
     
155. function queryChildInfo
     
156. {
     
157.   pid="$1"; #进程ID
     
158.   query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($3==q_key){print $0}}' q_key=$pid`; #根据父进程ID，进行搜索
     
159.   v_len_size=$(QueryStrLen "$query_result");
     
160.   if [ $v_len_size -gt 0 ]; then
     
161.     echo "$query_result" | while read line
     
162.     do
     
163.       out=$(PrintItem "${line}");
     
164.       echo "${out}";
     
165.       q_pid=$(queryProcessID "${line}"); #获取进程ID
     
166.       queryChildInfo "$q_pid"; #进行递归调用
     
167.     done;
     
168.   fi;
     
169. }
     
170. 
     
171. 
     
172. #获取父进程
     
173. #参数1：进程ID
     
174. function queryParentInfo
     
175. {
     
176.   pid="$1"; #进程ID
     
177.   query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$pid`; #根据进程ID，进行搜索
     
178.   v_len_size=$(QueryStrLen "$query_result");
     
179.   if [ $v_len_size -gt 0 ]; then
     
180.     echo "$query_result" | while read line
     
181.     do
     
182.       out=$(PrintItem "${line}");
     
183.       echo "${out}";
     
184.       q_ppid=$(queryPProcessID "${line}"); #获取父进程ID
     
185.       queryParentInfo "$q_ppid"; #进行递归调用
     
186.     done;
     
187.   fi;
     
188. }
     
189. 
     
190. #是否展示，标题头信息
     
191. #参数1：是否打印标题(0:不打印; 1:打印)
     
192. function showTitle
     
193. {
     
194.   v_head="$1";
     
195.   if [ $v_head -gt 0 ]; then
     
196.     PrintHead; #打印信息头
     
197.   fi;
     
198. }
     
199. 
     
200. #执行查询(当前进程，及子进程)
     
201. #参数1: 查询结果
     
202. #参数2：是否打印标题(0:不打印; 1:打印)
     
203. function query_run
     
204. {
     
205.   query_result="$1";
     
206.   v_head="$2";
     
207.   v_len_size=$(QueryStrLen "$query_result");
     
208.   if [ $v_len_size -gt 0 ]; then
     
209.     showTitle "$v_head";
     
210.     echo "$query_result" | while read line #循环处理数据
     
211.     do
     
212.       tmp_line=${line}; #临时变量，递归时调用
     
213.       q_pid=$(queryProcessID "${tmp_line}");
     
214.       queryChildInfo "$q_pid"; #获取子进程信息
     
215. 
     
216.       out=$(PrintItem "${tmp_line}"); #打印当前进程
     
217.       echo "${out}";
     
218.     done;
     
219.   fi;
     
220. }
     
221. 
     
222. #开始执行，进程追踪
     
223. #参数1: 查询结果
     
224. #参数2：是否打印标题(0:不打印; 1:打印)
     
225. function query_parent_run
     
226. {
     
227.   query_result="$1";
     
228.   v_head="$2";
     
229.   v_len_size=$(QueryStrLen "$query_result");
     
230.   if [ $v_len_size -gt 0 ]; then
     
231.     showTitle "$v_head";
     
232.     #处理父进程，相关信息
     
233.     echo "$query_result" | while read line #循环处理数据
     
234.     do
     
235.       out=$(PrintItem "${line}"); #打印当前进程
     
236.       echo "${out}";
     
237. 
     
238.       q_ppid=$(queryPProcessID "${line}");
     
239.       queryParentInfo "$q_ppid"; #获取父进程信息
     
240.     done;
     
241.   fi;
     
242. }
     
243. 
     
244. #开始追踪，父子进程的，所有关系
     
245. #参数1: 查询结果
     
246. #参数2：是否打印标题(0:不打印; 1:打印)
     
247. function query_all_run
     
248. {
     
249.   query_result="$1";
     
250.   v_head="$2";
     
251.   v_len_size=$(QueryStrLen "$query_result");
     
252.   if [ $v_len_size -gt 0 ]; then
     
253.     showTitle "$v_head";
     
254.     echo "$query_result" | while read line #循环处理数据
     
255.     do
     
256.       tmp_line=${line}; #临时变量，递归时调用
     
257.       tmp2_line=${line}; #临时变量，递归时调用
     
258. 
     
259.       q_pid=$(queryProcessID "${tmp_line}");
     
260.       queryChildInfo "$q_pid"; #获取子进程信息
     
261. 
     
262.       out=$(PrintItem "${tmp_line}"); #打印当前进程
     
263.       echo "${out}";
     
264. 
     
265.       q_ppid=$(queryPProcessID "${tmp2_line}");
     
266.       queryParentInfo "$q_ppid"; #获取父进程信息
     
267.     done;
     
268.   fi;
     
269. }
     
270. 
     
271. #查询自身进程
     
272. #参数1: 查询结果
     
273. #参数2：是否打印标题(0:不打印; 1:打印)
     
274. function query_self_run
     
275. {
     
276.   query_result="$1";
     
277.   v_head="$2";
     
278.   tmp_result="$1"; #临时变量
     
279.   v_len_size=$(QueryStrLen "$query_result");
     
280.   if [ $v_len_size -gt 0 ]; then
     
281.     showTitle "$v_head";
     
282.     #输出进程相关信息
     
283.     echo "$tmp_result" | while read line #循环处理数据
     
284.     do
     
285.       out=$(PrintItem "${line}");
     
286.       echo "${out}";
     
287.     done;
     
288.   fi;
     
289. }
     
290. 
     
291. #根据关键字,进行查询
     
292. #参数1：查询关键字
     
293. #参数2：是否打印标题(0:不打印; 1:打印)
     
294. #参数3：过滤掉的数据
     
295. function query_key
     
296. {
     
297.   v_key="$1"; #查询关键字
     
298.   v_head="$2";
     
299.   v_filter="$3";
     
300.   query_result=`${ps_exe_cmd} | grep "${v_key}" | grep -v "${v_filter}" | grep -v grep`;
     
301.   query_run "${query_result}" "$v_head";
     
302. }
     
303. 
     
304. #根据进程id,进行查询
     
305. #参数1：进程ID
     
306. #参数2：是否打印标题(0:不打印; 1:打印)
     
307. function query_pid
     
308. {
     
309.   p_id="$1"; #进程id
     
310.   v_head="$2";
     
311.   query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$p_id`;
     
312.   query_run "${query_result}" "$v_head";
     
313. }
     
314. 
     
315. #通过关键字，追踪进程的调用关系
     
316. #参数1：查询关键字
     
317. #参数2：是否打印标题(0:不打印; 1:打印)
     
318. #参数3：过滤掉的数据
     
319. function query_parent_key
     
320. {
     
321.   v_key="$1"; #查询关键字
     
322.   v_head="$2";
     
323.   v_filter="$3";
     
324.   query_result=`${ps_exe_cmd} | grep "${v_key}" | grep -v "${v_filter}" | grep -v grep`;
     
325.   query_parent_run "${query_result}" "$v_head";
     
326. }
     
327. 
     
328. #通过进程id，追踪进程的父子进程，关系
     
329. #参数1：进程
     
330. #参数2：是否打印标题(0:不打印; 1:打印)
     
331. function query_parent_pid
     
332. {
     
333.   p_id="$1"; #查询关键字
     
334.   v_head="$2";
     
335.   query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$p_id`;
     
336.   query_parent_run "${query_result}" "$v_head";
     
337. }
     
338. 
     
339. #通过进程，追踪进程的调用关系
     
340. #参数1：查询关键字
     
341. #参数2：是否打印标题(0:不打印; 1:打印)
     
342. #参数3：过滤掉的数据
     
343. function query_all_key
     
344. {
     
345.   v_key="$1"; #查询关键字
     
346.   v_head="$2";
     
347.   v_filter="$3";
     
348.   query_result=`${ps_exe_cmd} | grep "${v_key}" | grep -v "${v_filter}" | grep -v grep`;
     
349.   query_all_run "${query_result}" "$v_head";
     
350. }
     
351. 
     
352. #通过进程ID，追踪进程的父子进程，关系
     
353. #参数1：进程ID
     
354. #参数2：是否打印标题(0:不打印; 1:打印)
     
355. function query_all_pid
     
356. {
     
357.   p_id="$1"; #查询关键字
     
358.   v_head="$2";
     
359.   query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$p_id`;
     
360.   query_all_run "${query_result}" "$v_head";
     
361. }
     
362. 
     
363. #根据关键字，查询自己进程
     
364. #参数1：查询关键字
     
365. #参数2：是否打印标题(0:不打印; 1:打印)
     
366. #参数3：过滤掉的数据
     
367. function query_self_key
     
368. {
     
369.   v_key="$1"; #查询关键字
     
370.   v_head="$2";
     
371.   v_filter="$3";
     
372.   query_result=`${ps_exe_cmd} | grep "${v_key}" | grep -v "${v_filter}" | grep -v grep`;
     
373.   query_self_run "${query_result}" "$v_head";
     
374. }
     
375. 
     
376. #根据进程ID,查询自己进程
     
377. #参数1：进程ID
     
378. #参数2：是否打印标题(0:不打印; 1:打印)
     
379. function query_self_pid
     
380. {
     
381.   p_id="$1"; #查询关键字
     
382.   v_head="$2";
     
383.   query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$p_id`;
     
384.   query_self_run "${query_result}" "$v_head";
     
385. }
     
386. 
     
387. #################################################################################################
     
388. #################################################################################################
     
389. #################################################################################################
     
390. 
     
391. #帮助
     
392. #参数1：命令名称
     
393. function help
     
394. {
     
395.   v_name="$1";
     
396.   echo "${v_name}程序,为方便查询，进程调用关系的程序。核心代码为通过ps命令，通过递归方式，查找其父子进程相关参数信息。
     
397.         执行命令格式为 ${v_name} [-a] [-i] [-p] [-0] [-n] 要查询的参数
     
398.         默认为查询入参的进程及子进程。
     
399.         可选参数如下：
     
400.         -a 搜索父子进程调用关系
     
401.         -i 通过进程ID(pid)，进行搜索
     
402.         -p 查询调用的父进程调用关系
     
403.         -0 仅查询当前进程
     
404.         -n 隐藏标题输出";
     
405. }
     
406. 
     
407. #验证参数
     
408. #参数1：参数集合，字符串
     
409. #参数2：要验证的字符
     
410. #返回值：0：不含有该参数; 1:含有该参数
     
411. function valid_parameter
     
412. {
     
413.   v_result=0;
     
414.   v_str=`echo "$1" | tr '[A-Z]' '[a-z]'`;
     
415.   v_key=`echo "$2" | tr '[A-Z]' '[a-z]'`;
     
416. 
     
417.   v_idx=$(queryIndex "${v_str}" "${v_key}");
     
418.   if [ $v_idx -gt 0 ]; then
     
419.     v_result=1;
     
420.   fi;
     
421. 
     
422.   echo $v_result;
     
423. }
     
424. 
     
425. #开始运行(参数：a)
     
426. #参数1：是否通过，进程id，进行查询
     
427. #参数2：是否输出标题
     
428. #参数3：查询关键字
     
429. #参数4：需要过滤的关键字
     
430. function run_a
     
431. {
     
432.   v_pid="$1";
     
433.   v_title="$2";
     
434.   v_key="$3";
     
435.   v_filter="$4";
     
436. 
     
437.   if [ $v_pid -gt 0 ]; then
     
438.     query_all_pid "${v_key}" "$v_title";
     
439.   else
     
440.     query_all_key "${v_key}" "$v_title" "${v_filter}";
     
441.   fi;
     
442. }
     
443. 
     
444. #开始运行(参数：p)
     
445. #参数1：是否通过，进程id，进行查询
     
446. #参数2：是否输出标题
     
447. #参数3：查询关键字
     
448. #参数4：需要过滤的关键字
     
449. function run_p
     
450. {
     
451.   v_pid="$1";
     
452.   v_title="$2";
     
453.   v_key="$3";
     
454.   v_filter="$4";
     
455. 
     
456.   if [ $v_pid -gt 0 ]; then
     
457.     query_parent_pid "${v_key}" "$v_title";
     
458.   else
     
459.     query_parent_key "${v_key}" "$v_title" "${v_filter}";
     
460.   fi;
     
461. }
     
462. 
     
463. #开始运行(参数：0)
     
464. #参数1：是否通过，进程id，进行查询
     
465. #参数2：是否输出标题
     
466. #参数3：查询关键字
     
467. #参数4：需要过滤的关键字
     
468. function run_0
     
469. {
     
470.   v_pid="$1";
     
471.   v_title="$2";
     
472.   v_key="$3";
     
473.   v_filter="$4";
     
474. 
     
475.   if [ $v_pid -gt 0 ]; then
     
476.     query_self_pid "${v_key}" "$v_title";
     
477.   else
     
478.     query_self_key "${v_key}" "$v_title" "${v_filter}";
     
479.   fi;
     
480. }
     
481. 
     
482. #开始运行(默认输出进程，以及子进程信息)
     
483. #参数1：是否通过，进程id，进行查询
     
484. #参数2：是否输出标题
     
485. #参数3：查询关键字
     
486. #参数4：需要过滤的关键字
     
487. function run_default
     
488. {
     
489.   v_pid="$1";
     
490.   v_title="$2";
     
491.   v_key="$3";
     
492.   v_filter="$4";
     
493. 
     
494.   if [ $v_pid -gt 0 ]; then
     
495.     query_pid "${v_key}" "$v_title";
     
496.   else
     
497.     query_key "${v_key}" "$v_title" "${v_filter}";
     
498.   fi;
     
499. }
     
500. 
     
501. #开始运行
     
502. #参数1：是否执行所有(入参:a)
     
503. #参数2：是否通过pid，进行查询(入参:i)
     
504. #参数3：是否查询父进程相关信息(入参:p)
     
505. #参数4：是否仅查询自己的进程(入参:0)
     
506. #参数5：是否输出标题(入参:n)
     
507. #参数6：查询参数
     
508. #参数7：执行shell的名称
     
509. function run
     
510. {
     
511.   v_a="$1";
     
512.   v_i="$2";
     
513.   v_p="$3";
     
514.   v_0="$4";
     
515.   v_n="$5";
     
516.   v_key="$6";
     
517.   v_exe="$7";
     
518. 
     
519.   if [ $v_a -gt 0 ]; then
     
520.     run_a "$v_i" "$v_n" "${v_key}" "${v_exe}";
     
521.   elif [ $v_p -gt 0 ]; then
     
522.     run_p "$v_i" "$v_n" "${v_key}" "${v_exe}";
     
523.   elif [ $v_0 -gt 0 ]; then
     
524.     run_0 "$v_i" "$v_n" "${v_key}" "${v_exe}";
     
525.   else
     
526.     run_default "$v_i" "$v_n" "${v_key}" "${v_exe}";
     
527.   fi;
     
528. }
     
529. 
     
530. exe_name=$0;
     
531. all_paras_str="";
     
532. query_key="";
     
533. v_head=1; #默认输出标题
     
534. 
     
535. if [ $# -gt 0 ]; then
     
536.   while [ $# -ne 1 ]
     
537.   do
     
538.     para_item="$1";
     
539.     all_paras_str="${all_paras_str}${para_item}";
     
540.     shift;
     
541.   done;
     
542.   
     
543.   query_key="$1";
     
544.   #验证入参信息
     
545.   valid_a=$(valid_parameter "${all_paras_str}" "a"); #查看关联的，父子进程
     
546.   valid_i=$(valid_parameter "${all_paras_str}" "i"); #根据pid，进行查询
     
547.   valid_p=$(valid_parameter "${all_paras_str}" "p"); #查看父进程
     
548.   valid_0=$(valid_parameter "${all_paras_str}" "0"); #仅查询自己的进程，无关联信息
     
549.   valid_n=$(valid_parameter "${all_paras_str}" "n"); #不输出标题
     
550.   if [ $valid_n -gt 0 ]; then
     
551.     v_head=0; #关闭输出，标题信息
     
552.   fi;
     
553. 
     
554.   run "$valid_a" "$valid_i" "$valid_p" "$valid_0" "$v_head" "${query_key}" "${exe_name}"; #开始查询
     
555. else
     
556.   help "$exe_name";
     
557. fi;

QueryProcessInfo.rar