Chinaunix首页 | 论坛 | 博客
  • 博客访问: 2545676
  • 博文数量: 308
  • 博客积分: 5547
  • 博客等级: 大校
  • 技术积分: 3782
  • 用 户 组: 普通用户
  • 注册时间: 2009-11-24 09:47
个人简介

hello world.

文章分类

全部博文(308)

分类: LINUX

2016-12-08 17:12:17


点击(此处)折叠或打开

  1. #!/bin/sh

  2. #程序描述:查询进程间,父子进程,相互调用信息
  3. #作者:    程晓鹏
  4. #日期:    2016.12.06

  5. ps_exe_cmd="ps -ef";
  6. print_column_spliter="\t"; #打印列分隔符

  7. #查询字符串长度
  8. #参数1: 查询的字符串
  9. function QueryStrLen
  10. {
  11.   v_input="$1";
  12.   v_result=`echo "${#v_input}" | awk '{print int($0)}'`;
  13.   echo "$v_result";
  14. }

  15. #获取子字符串
  16. #参数1:原始字符串
  17. #参数2:开始的位置(从1开始)
  18. #参数3:长度
  19. function getSubStr
  20. {
  21.   v_result=""; #返回值
  22.   v_input="$1";
  23.   v_idx="$2";
  24.   v_len="$3";
  25.   
  26.   v_result=`echo "${v_input}" | awk '{print substr($0, vv_idx, vv_len)}' vv_idx=${v_idx} vv_len=${v_len}`;
  27.   echo "$v_result"
  28. }

  29. #查询索引值
  30. #参数1:要查询的原始字符串
  31. #参数2:查询的关键字
  32. #返回值:0:代表没有搜索到;大于0,代表搜索到的索引值
  33. function queryIndex
  34. {
  35.   v_result=0; #返回值
  36.   v_str="$1";
  37.   v_key="$2";

  38.   v_str_len=$(QueryStrLen "${v_str}");
  39.   v_key_len=$(QueryStrLen "${v_key}");

  40.   if [ $v_str_len -gt 0 ] && [ $v_key_len -gt 0 ]; then
  41.     v_result=`echo "${v_str}" | awk '{print index($0, q_key)}' q_key=${v_key}`;
  42.   fi;

  43.   echo $v_result;
  44. }

  45. #查询进程ID
  46. #参数1:字符串
  47. function queryProcessID
  48. {
  49.   v_result=""; #返回结果
  50.   v_input="$1";
  51.   v_result=`echo ${v_input} | awk '{print $2}'`;
  52.   echo "$v_result";
  53. }

  54. #查询父进程ID
  55. #参数1:字符串
  56. function queryPProcessID
  57. {
  58.   v_result=""; #返回结果
  59.   v_input="$1";
  60.   v_result=`echo ${v_input} | awk '{print $3}'`;
  61.   echo "$v_result";
  62. }


  63. #查询进程用户
  64. #参数1:字符串
  65. function queryProcessUser
  66. {
  67.   v_result=""; #返回结果
  68.   v_input="$1";
  69.   v_result=`echo ${v_input} | awk '{print $1}'`;
  70.   echo "$v_result";
  71. }

  72. #查询进程名称
  73. #参数1:要查找的字符串
  74. #参数2:查询的关键字
  75. function queryProcessName_exec
  76. {
  77.   v_result=""; #返回结果
  78.   v_input="${1}";
  79.   v_key="${2}";
  80.   v_input_len=$(QueryStrLen "${v_input}");
  81.   v_idx=$(queryIndex "${v_input}" "${v_key}");

  82.   if [ v_idx -gt 0 ]; then
  83.     v_len=`expr "$v_input_len" - "$v_idx" + 1 | bc`;
  84.     v_result=$(getSubStr "${v_input}" "$v_idx" "$v_len");
  85.   fi;

  86.   echo "${v_result}";
  87. }

  88. #获取进程名称
  89. #参数1:字符串
  90. function queryProcessName
  91. {
  92.   v_result=""; #返回结果
  93.   v_input="$1";
  94.   v_exe_name=`echo "${v_input}" | awk '{print $8}'`; #查询进程名称,开始字符串
  95.   v_len=$(QueryStrLen "${v_exe_name}");
  96.   if [ $v_len -gt 0 ]; then
  97.     v_result=$(queryProcessName_exec "${v_input}" "${v_exe_name}");
  98.   fi;

  99.   echo "${v_result}";
  100. }

  101. #清除所有空格
  102. #参数1:所有字符串
  103. function CleanSpace
  104. {
  105.   v_in_str="$1";
  106.   echo "$v_in_str" | sed s/[[:space:]]//g;
  107. }

  108. #打印输出信息头
  109. function PrintHead
  110. {
  111.   column_1="user";
  112.   column_2="pid";
  113.   column_3="ppid";
  114.   column_4="cmd";
  115.   col_char="$print_column_spliter"; #列分隔符

  116.   echo "${column_1}${col_char}${column_2}${col_char}${column_3}${col_char}${column_4}";
  117. }

  118. #打印数据
  119. #参数1: 字符串
  120. function PrintItem
  121. {
  122.   line="$1"; #入参数据
  123.   q_user=$(queryProcessUser "$line");
  124.   q_pid=$(queryProcessID "$line");
  125.   q_ppid=$(queryPProcessID "$line");
  126.   q_pname=$(queryProcessName "$line");
  127.   col_char=${print_column_spliter}; #列分隔符

  128.   echo "${q_user}${col_char}${q_pid}${col_char}${q_ppid}${col_char}${q_pname}";
  129. }

  130. #获取子进程
  131. #参数1:进程ID
  132. function queryChildInfo
  133. {
  134.   pid="$1"; #进程ID
  135.   query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($3==q_key){print $0}}' q_key=$pid`; #根据父进程ID,进行搜索
  136.   v_len_size=$(QueryStrLen "$query_result");
  137.   if [ $v_len_size -gt 0 ]; then
  138.     echo "$query_result" | while read line
  139.     do
  140.       out=$(PrintItem "${line}");
  141.       echo "${out}";
  142.       q_pid=$(queryProcessID "${line}"); #获取进程ID
  143.       queryChildInfo "$q_pid"; #进行递归调用
  144.     done;
  145.   fi;
  146. }


  147. #获取父进程
  148. #参数1:进程ID
  149. function queryParentInfo
  150. {
  151.   pid="$1"; #进程ID
  152.   query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$pid`; #根据进程ID,进行搜索
  153.   v_len_size=$(QueryStrLen "$query_result");
  154.   if [ $v_len_size -gt 0 ]; then
  155.     echo "$query_result" | while read line
  156.     do
  157.       out=$(PrintItem "${line}");
  158.       echo "${out}";
  159.       q_ppid=$(queryPProcessID "${line}"); #获取父进程ID
  160.       queryParentInfo "$q_ppid"; #进行递归调用
  161.     done;
  162.   fi;
  163. }

  164. #是否展示,标题头信息
  165. #参数1:是否打印标题(0:不打印; 1:打印)
  166. function showTitle
  167. {
  168.   v_head="$1";
  169.   if [ $v_head -gt 0 ]; then
  170.     PrintHead; #打印信息头
  171.   fi;
  172. }

  173. #执行查询(当前进程,及子进程)
  174. #参数1: 查询结果
  175. #参数2:是否打印标题(0:不打印; 1:打印)
  176. function query_run
  177. {
  178.   query_result="$1";
  179.   v_head="$2";
  180.   v_len_size=$(QueryStrLen "$query_result");
  181.   if [ $v_len_size -gt 0 ]; then
  182.     showTitle "$v_head";
  183.     echo "$query_result" | while read line #循环处理数据
  184.     do
  185.       tmp_line=${line}; #临时变量,递归时调用
  186.       q_pid=$(queryProcessID "${tmp_line}");
  187.       queryChildInfo "$q_pid"; #获取子进程信息

  188.       out=$(PrintItem "${tmp_line}"); #打印当前进程
  189.       echo "${out}";
  190.     done;
  191.   fi;
  192. }

  193. #开始执行,进程追踪
  194. #参数1: 查询结果
  195. #参数2:是否打印标题(0:不打印; 1:打印)
  196. function query_parent_run
  197. {
  198.   query_result="$1";
  199.   v_head="$2";
  200.   v_len_size=$(QueryStrLen "$query_result");
  201.   if [ $v_len_size -gt 0 ]; then
  202.     showTitle "$v_head";
  203.     #处理父进程,相关信息
  204.     echo "$query_result" | while read line #循环处理数据
  205.     do
  206.       out=$(PrintItem "${line}"); #打印当前进程
  207.       echo "${out}";

  208.       q_ppid=$(queryPProcessID "${line}");
  209.       queryParentInfo "$q_ppid"; #获取父进程信息
  210.     done;
  211.   fi;
  212. }

  213. #开始追踪,父子进程的,所有关系
  214. #参数1: 查询结果
  215. #参数2:是否打印标题(0:不打印; 1:打印)
  216. function query_all_run
  217. {
  218.   query_result="$1";
  219.   v_head="$2";
  220.   v_len_size=$(QueryStrLen "$query_result");
  221.   if [ $v_len_size -gt 0 ]; then
  222.     showTitle "$v_head";
  223.     echo "$query_result" | while read line #循环处理数据
  224.     do
  225.       tmp_line=${line}; #临时变量,递归时调用
  226.       tmp2_line=${line}; #临时变量,递归时调用

  227.       q_pid=$(queryProcessID "${tmp_line}");
  228.       queryChildInfo "$q_pid"; #获取子进程信息

  229.       out=$(PrintItem "${tmp_line}"); #打印当前进程
  230.       echo "${out}";

  231.       q_ppid=$(queryPProcessID "${tmp2_line}");
  232.       queryParentInfo "$q_ppid"; #获取父进程信息
  233.     done;
  234.   fi;
  235. }

  236. #查询自身进程
  237. #参数1: 查询结果
  238. #参数2:是否打印标题(0:不打印; 1:打印)
  239. function query_self_run
  240. {
  241.   query_result="$1";
  242.   v_head="$2";
  243.   tmp_result="$1"; #临时变量
  244.   v_len_size=$(QueryStrLen "$query_result");
  245.   if [ $v_len_size -gt 0 ]; then
  246.     showTitle "$v_head";
  247.     #输出进程相关信息
  248.     echo "$tmp_result" | while read line #循环处理数据
  249.     do
  250.       out=$(PrintItem "${line}");
  251.       echo "${out}";
  252.     done;
  253.   fi;
  254. }

  255. #根据关键字,进行查询
  256. #参数1:查询关键字
  257. #参数2:是否打印标题(0:不打印; 1:打印)
  258. #参数3:过滤掉的数据
  259. function query_key
  260. {
  261.   v_key="$1"; #查询关键字
  262.   v_head="$2";
  263.   v_filter="$3";
  264.   query_result=`${ps_exe_cmd} | grep "${v_key}" | grep -v "${v_filter}" | grep -v grep`;
  265.   query_run "${query_result}" "$v_head";
  266. }

  267. #根据进程id,进行查询
  268. #参数1:进程ID
  269. #参数2:是否打印标题(0:不打印; 1:打印)
  270. function query_pid
  271. {
  272.   p_id="$1"; #进程id
  273.   v_head="$2";
  274.   query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$p_id`;
  275.   query_run "${query_result}" "$v_head";
  276. }

  277. #通过关键字,追踪进程的调用关系
  278. #参数1:查询关键字
  279. #参数2:是否打印标题(0:不打印; 1:打印)
  280. #参数3:过滤掉的数据
  281. function query_parent_key
  282. {
  283.   v_key="$1"; #查询关键字
  284.   v_head="$2";
  285.   v_filter="$3";
  286.   query_result=`${ps_exe_cmd} | grep "${v_key}" | grep -v "${v_filter}" | grep -v grep`;
  287.   query_parent_run "${query_result}" "$v_head";
  288. }

  289. #通过进程id,追踪进程的父子进程,关系
  290. #参数1:进程
  291. #参数2:是否打印标题(0:不打印; 1:打印)
  292. function query_parent_pid
  293. {
  294.   p_id="$1"; #查询关键字
  295.   v_head="$2";
  296.   query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$p_id`;
  297.   query_parent_run "${query_result}" "$v_head";
  298. }

  299. #通过进程,追踪进程的调用关系
  300. #参数1:查询关键字
  301. #参数2:是否打印标题(0:不打印; 1:打印)
  302. #参数3:过滤掉的数据
  303. function query_all_key
  304. {
  305.   v_key="$1"; #查询关键字
  306.   v_head="$2";
  307.   v_filter="$3";
  308.   query_result=`${ps_exe_cmd} | grep "${v_key}" | grep -v "${v_filter}" | grep -v grep`;
  309.   query_all_run "${query_result}" "$v_head";
  310. }

  311. #通过进程ID,追踪进程的父子进程,关系
  312. #参数1:进程ID
  313. #参数2:是否打印标题(0:不打印; 1:打印)
  314. function query_all_pid
  315. {
  316.   p_id="$1"; #查询关键字
  317.   v_head="$2";
  318.   query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$p_id`;
  319.   query_all_run "${query_result}" "$v_head";
  320. }

  321. #根据关键字,查询自己进程
  322. #参数1:查询关键字
  323. #参数2:是否打印标题(0:不打印; 1:打印)
  324. #参数3:过滤掉的数据
  325. function query_self_key
  326. {
  327.   v_key="$1"; #查询关键字
  328.   v_head="$2";
  329.   v_filter="$3";
  330.   query_result=`${ps_exe_cmd} | grep "${v_key}" | grep -v "${v_filter}" | grep -v grep`;
  331.   query_self_run "${query_result}" "$v_head";
  332. }

  333. #根据进程ID,查询自己进程
  334. #参数1:进程ID
  335. #参数2:是否打印标题(0:不打印; 1:打印)
  336. function query_self_pid
  337. {
  338.   p_id="$1"; #查询关键字
  339.   v_head="$2";
  340.   query_result=`${ps_exe_cmd} | grep -v grep | awk '{if($2==q_key){print $0}}' q_key=$p_id`;
  341.   query_self_run "${query_result}" "$v_head";
  342. }

  343. #################################################################################################
  344. #################################################################################################
  345. #################################################################################################

  346. #帮助
  347. #参数1:命令名称
  348. function help
  349. {
  350.   v_name="$1";
  351.   echo "${v_name}程序,为方便查询,进程调用关系的程序。核心代码为通过ps命令,通过递归方式,查找其父子进程相关参数信息。
  352.         执行命令格式为 ${v_name} [-a] [-i] [-p] [-0] [-n] 要查询的参数
  353.         默认为查询入参的进程及子进程。
  354.         可选参数如下:
  355.         -a 搜索父子进程调用关系
  356.         -i 通过进程ID(pid),进行搜索
  357.         -p 查询调用的父进程调用关系
  358.         -0 仅查询当前进程
  359.         -n 隐藏标题输出";
  360. }

  361. #验证参数
  362. #参数1:参数集合,字符串
  363. #参数2:要验证的字符
  364. #返回值:0:不含有该参数; 1:含有该参数
  365. function valid_parameter
  366. {
  367.   v_result=0;
  368.   v_str=`echo "$1" | tr '[A-Z]' '[a-z]'`;
  369.   v_key=`echo "$2" | tr '[A-Z]' '[a-z]'`;

  370.   v_idx=$(queryIndex "${v_str}" "${v_key}");
  371.   if [ $v_idx -gt 0 ]; then
  372.     v_result=1;
  373.   fi;

  374.   echo $v_result;
  375. }

  376. #开始运行(参数:a)
  377. #参数1:是否通过,进程id,进行查询
  378. #参数2:是否输出标题
  379. #参数3:查询关键字
  380. #参数4:需要过滤的关键字
  381. function run_a
  382. {
  383.   v_pid="$1";
  384.   v_title="$2";
  385.   v_key="$3";
  386.   v_filter="$4";

  387.   if [ $v_pid -gt 0 ]; then
  388.     query_all_pid "${v_key}" "$v_title";
  389.   else
  390.     query_all_key "${v_key}" "$v_title" "${v_filter}";
  391.   fi;
  392. }

  393. #开始运行(参数:p)
  394. #参数1:是否通过,进程id,进行查询
  395. #参数2:是否输出标题
  396. #参数3:查询关键字
  397. #参数4:需要过滤的关键字
  398. function run_p
  399. {
  400.   v_pid="$1";
  401.   v_title="$2";
  402.   v_key="$3";
  403.   v_filter="$4";

  404.   if [ $v_pid -gt 0 ]; then
  405.     query_parent_pid "${v_key}" "$v_title";
  406.   else
  407.     query_parent_key "${v_key}" "$v_title" "${v_filter}";
  408.   fi;
  409. }

  410. #开始运行(参数:0)
  411. #参数1:是否通过,进程id,进行查询
  412. #参数2:是否输出标题
  413. #参数3:查询关键字
  414. #参数4:需要过滤的关键字
  415. function run_0
  416. {
  417.   v_pid="$1";
  418.   v_title="$2";
  419.   v_key="$3";
  420.   v_filter="$4";

  421.   if [ $v_pid -gt 0 ]; then
  422.     query_self_pid "${v_key}" "$v_title";
  423.   else
  424.     query_self_key "${v_key}" "$v_title" "${v_filter}";
  425.   fi;
  426. }

  427. #开始运行(默认输出进程,以及子进程信息)
  428. #参数1:是否通过,进程id,进行查询
  429. #参数2:是否输出标题
  430. #参数3:查询关键字
  431. #参数4:需要过滤的关键字
  432. function run_default
  433. {
  434.   v_pid="$1";
  435.   v_title="$2";
  436.   v_key="$3";
  437.   v_filter="$4";

  438.   if [ $v_pid -gt 0 ]; then
  439.     query_pid "${v_key}" "$v_title";
  440.   else
  441.     query_key "${v_key}" "$v_title" "${v_filter}";
  442.   fi;
  443. }

  444. #开始运行
  445. #参数1:是否执行所有(入参:a)
  446. #参数2:是否通过pid,进行查询(入参:i)
  447. #参数3:是否查询父进程相关信息(入参:p)
  448. #参数4:是否仅查询自己的进程(入参:0)
  449. #参数5:是否输出标题(入参:n)
  450. #参数6:查询参数
  451. #参数7:执行shell的名称
  452. function run
  453. {
  454.   v_a="$1";
  455.   v_i="$2";
  456.   v_p="$3";
  457.   v_0="$4";
  458.   v_n="$5";
  459.   v_key="$6";
  460.   v_exe="$7";

  461.   if [ $v_a -gt 0 ]; then
  462.     run_a "$v_i" "$v_n" "${v_key}" "${v_exe}";
  463.   elif [ $v_p -gt 0 ]; then
  464.     run_p "$v_i" "$v_n" "${v_key}" "${v_exe}";
  465.   elif [ $v_0 -gt 0 ]; then
  466.     run_0 "$v_i" "$v_n" "${v_key}" "${v_exe}";
  467.   else
  468.     run_default "$v_i" "$v_n" "${v_key}" "${v_exe}";
  469.   fi;
  470. }

  471. exe_name=$0;
  472. all_paras_str="";
  473. query_key="";
  474. v_head=1; #默认输出标题

  475. if [ $# -gt 0 ]; then
  476.   while [ $# -ne 1 ]
  477.   do
  478.     para_item="$1";
  479.     all_paras_str="${all_paras_str}${para_item}";
  480.     shift;
  481.   done;
  482.   
  483.   query_key="$1";
  484.   #验证入参信息
  485.   valid_a=$(valid_parameter "${all_paras_str}" "a"); #查看关联的,父子进程
  486.   valid_i=$(valid_parameter "${all_paras_str}" "i"); #根据pid,进行查询
  487.   valid_p=$(valid_parameter "${all_paras_str}" "p"); #查看父进程
  488.   valid_0=$(valid_parameter "${all_paras_str}" "0"); #仅查询自己的进程,无关联信息
  489.   valid_n=$(valid_parameter "${all_paras_str}" "n"); #不输出标题
  490.   if [ $valid_n -gt 0 ]; then
  491.     v_head=0; #关闭输出,标题信息
  492.   fi;

  493.   run "$valid_a" "$valid_i" "$valid_p" "$valid_0" "$v_head" "${query_key}" "${exe_name}"; #开始查询
  494. else
  495.   help "$exe_name";
  496. fi;

QueryProcessInfo.rar
阅读(4094) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~