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

4160阅读　0评论2016-12-08　chengxiaopeng
分类：LINUX


点击(此处)折叠或打开

  1. #!/bin/sh

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

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

  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. }

  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. }

  34. #查询索引值
  35. #参数1：要查询的原始字符串
  36. #参数2：查询的关键字
  37. #返回值：0:代表没有搜索到；大于0，代表搜索到的索引值
  38. function queryIndex
  39. {
  40.   v_result=0; #返回值
  41.   v_str="$1";
  42.   v_key="$2";

  44.   v_str_len=$(QueryStrLen "${v_str}");
  45.   v_key_len=$(QueryStrLen "${v_key}");

  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;

  51.   echo $v_result;
  52. }

  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. }

  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. }


  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. }

  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}");

  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;

  101.   echo "${v_result}";
  102. }

  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;

  116.   echo "${v_result}";
  117. }

  119. #清除所有空格
  120. #参数1：所有字符串
  121. function CleanSpace
  122. {
  123.   v_in_str="$1";
  124.   echo "$v_in_str" | sed s/[[:space:]]//g;
  125. }

  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"; #列分隔符

  136.   echo "${column_1}${col_char}${column_2}${col_char}${column_3}${col_char}${column_4}";
  137. }

  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}; #列分隔符

  150.   echo "${q_user}${col_char}${q_pid}${col_char}${q_ppid}${col_char}${q_pname}";
  151. }

  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. }


  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. }

  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. }

  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"; #获取子进程信息

  216.       out=$(PrintItem "${tmp_line}"); #打印当前进程
  217.       echo "${out}";
  218.     done;
  219.   fi;
  220. }

  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}";

  238.       q_ppid=$(queryPProcessID "${line}");
  239.       queryParentInfo "$q_ppid"; #获取父进程信息
  240.     done;
  241.   fi;
  242. }

  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}; #临时变量，递归时调用

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

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

  265.       q_ppid=$(queryPProcessID "${tmp2_line}");
  266.       queryParentInfo "$q_ppid"; #获取父进程信息
  267.     done;
  268.   fi;
  269. }

  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. }

  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. }

  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. }

  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. }

  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. }

  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. }

  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. }

  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. }

  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. }

  387. #################################################################################################
  388. #################################################################################################
  389. #################################################################################################

  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. }

  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]'`;

  417.   v_idx=$(queryIndex "${v_str}" "${v_key}");
  418.   if [ $v_idx -gt 0 ]; then
  419.     v_result=1;
  420.   fi;

  422.   echo $v_result;
  423. }

  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";

  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. }

  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";

  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. }

  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";

  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. }

  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";

  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. }

  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";

  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. }

  530. exe_name=$0;
  531. all_paras_str="";
  532. query_key="";
  533. v_head=1; #默认输出标题

  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;

  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
上一篇：个性化的nohup，可以判断程序是否启动，如启动，则不重复启动指定程序
下一篇：Oracle自定义函数，生成验证码