本文目錄： 1.幾個顯示函數2.action函數3.is_true和is_false函數4.confirm函數5.pid檢測相關函數 5.1 checkpid、__pids_var_run和__pids_pidof函數 5.2 pidfileofproc和pidofproc函數6.重頭戲(一)：da ...

本文目錄：

1.幾個顯示函數
2.action函數
3.is_true和is_false函數
4.confirm函數
5.pid檢測相關函數
　　5.1 checkpid、__pids_var_run和__pids_pidof函數
　　5.2 pidfileofproc和pidofproc函數
6.重頭戲(一)：daemon函數
7.重頭戲(二)：killproc函數
8.重頭戲(三)：status函數
9.幾個重要函數的總結和使用說明
　　9.1 pid相關
　　9.2 daemon的使用
　　9.3 killproc的使用
　　9.4 status的使用
10.memcached服務啟動腳本示例

/etc/rc.d/init.d/functions幾乎被/etc/rc.d/init.d/下所有的Sysv服務啟動腳本載入，也是學習shell腳本時一個非常不錯的材料，在其中使用了不少技巧。

在該文件中提供了幾個有用的函數：

daemon：啟動一個服務程式。啟動前還檢查進程是否已在運行。
killproc：殺掉給定的服務進程。
status：檢查給定進程的運行狀態。
success：顯示綠色的"OK"，表示成功。
failure：顯示紅色的"FAILED"，表示失敗。
passed：顯示綠色的"PASSED"，表示pass該任務。
warning：顯示綠色的"warning"，表示警告。
action：根據進程退出狀態碼自行判斷是執行success還是failure。
confirm：提示"(Y)es/(N)o/(C)ontinue? [Y]"並判斷、傳遞輸入的值。
is_true："$1"的布爾值代表為真時，返回狀態碼0，否則返回1。包括t、y、yes和true，不區分大小寫。
is_false："$1"的布爾值代表為假時，返回狀態碼0。否則返回1。包括f、n、no和false，不區分大小寫。
checkpid：檢查/proc下是否有給定pid對應的目錄。給定多個pid時，只要存在一個目錄都返回狀態碼0。
__pids_var_run：檢查pid是否存在，並保存到變數pid中，同時返回幾種進程狀態碼。是functions中重要函數之一。
__pids_pidof：獲取進程pid。
pidfileofproc：獲取進程的pid。但只能獲取/var/run下的pid文件中的值。
pidofproc：獲取進程的pid。可獲取任意給定pidfile或預設/var/run下pidfile中的值。

前三個是functions文件最重要的3個函數，還用到了一些額外的輔助函數，稍稍有點複雜。所以由簡至繁，先介紹並展示後面幾個函數，再回頭解釋前3個函數。

以下是/etc/init.d/functions文件的開頭定義的語句。設置umask值，使得載入該文件的腳本所在shell的umask為22。導出路徑變數。但說實話，這個導出的路徑變數並不理想，因為要為非rpm包安裝的程式設計服務啟動腳本時，必須寫全路徑命令，例如/usr/local/mysql/bin/mysql。因此，可以考慮將/etc/init.d/functions中的語句註釋掉。

umask 022

# Set up a default search path.
PATH="/sbin:/usr/sbin:/bin:/usr/bin"
export PATH

PS：本文分析的/etc/init.d/functions文件是CentOS 7上的，和CentOS 6有些許區別，但該有的目的和動作都有。

1.幾個顯示函數

包括echo_success、success、echo_failure、failure、echo_passed、passed、echo_warning和warning函數。這幾個函數的定義方式和使用方法完全一樣。

以下是echo_success和success函數的定義語句。

echo_success() {
  [ "$BOOTUP" = "color" ] && $MOVE_TO_COL
  echo -n "["
  [ "$BOOTUP" = "color" ] && $SETCOLOR_SUCCESS
  echo -n $"  OK  "
  [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
  echo -n "]"
  echo -ne "\r"
  return 0
}

success() {
  [ "$BOOTUP" != "verbose" -a -z "${LSB:-}" ] && echo_success
  return 0
}

很簡單，就是不換行帶顏色輸出"[ OK ]"字樣。

[root@xuexi ~]# . /etc/init.d/functions

[root@xuexi ~]# success
[root@xuexi ~]#                                            [  OK  ]
[root@xuexi ~]# echo_success
[root@xuexi ~]#                                            [  OK  ]

同理，剩餘的幾個狀態顯示函數也一樣。

[root@xuexi ~]# echo_failure
[root@xuexi ~]#                                            [FAILED]
[root@xuexi ~]# failure
[root@xuexi ~]#                                            [FAILED]

2.action函數

這個函數在寫腳本時還比較有用，可以根據退出狀態碼自動判斷是執行success還是執行failure函數。

action函數定義語句如下：

action() {
  local STRING rc

  STRING=$1
  echo -n "$STRING "
  shift
  "$@" && success $"$STRING" || failure $"$STRING"
  rc=$?
  echo
  return $rc
}

這個函數定義的很有技巧。先將第一個參數保存並踢掉，再執行後面的命令("$@"表示執行後面的命令)。所以，當action函數只有一個參數時，action直接返回OK，狀態碼為0，當超過一個參數時，第一個參數先被列印，再執行從第二個參數開始的命令。

例如：

[root@xuexi ~]# action
                                                           [  OK  ]
[root@xuexi ~]# action 5
5                                                          [  OK  ]
[root@xuexi ~]# action sleeping sleep 3
sleeping                                                   [  OK  ]
[root@xuexi ~]# action "moving file" mv xxxxxx.sh aaaaa.sh
moving file mv: cannot stat ‘xxxxxx.sh’: No such file or directory
                                                           [FAILED]

所以，在腳本中使用action函數時，可以讓命令執行成功與否的判斷顯得更"專業"。算是一個比較有趣的函數。

通常，該函數會結合/bin/true和/bin/false命令使用，它們無條件返回0或1狀態碼。

action $"MESSAGES: " /bin/true
action $"MESSAGES: " /bin/false

例如，mysqld啟動腳本中，判斷mysqld已在運行時，直接輸出啟動ok的消息。(但實際上根本沒做任何事)

if [ $MYSQLDRUNNING = 1 ] && [ $? = 0 ]; then
    # already running, do nothing
    action $"Starting $prog: " /bin/true
    ret=0

3.is_true和is_false函數

這兩個函數的作用是轉換輸入的布爾值為狀態碼。

is_true() {
    case "$1" in
    [tT] | [yY] | [yY][eE][sS] | [tT][rR][uU][eE])
    return 0
    ;;
    esac
    return 1
}

is_false() {
    case "$1" in
    [fF] | [nN] | [nN][oO] | [fF][aA][lL][sS][eE])
    return 0
    ;;
    esac
    return 1
}

當is_true函數的第一個參數(後面的參數會忽略掉)為忽略大小寫的t、y、yes或true時，返回狀態碼0，否則返回1。
當is_false函數的第一個參數(後面的參數會忽略掉)為忽略大小寫的f、n、no或false時，返回狀態碼0，否則返回1。

4.confirm函數

這個函數一般用不上，因為腳本本來就是為了避免互動式的。在CentOS 7的functions中已經刪除了該函數定義語句。不過，借鑒下它的處理方法還是不錯的。

以下摘自CentOS 6.6的/etc/init.d/functions文件。

# returns OK if $1 contains $2
strstr() {
  [ "${1#*$2*}" = "$1" ] && return 1   # 參數$1中不包含$2時，返回1，否則返回0
  return 0
}

# Confirm whether we really want to run this service
confirm() {
  [ -x /bin/plymouth ] && /bin/plymouth --hide-splash
  while : ; do 
      echo -n $"Start service $1 (Y)es/(N)o/(C)ontinue? [Y] "
      read answer
      if strstr $"yY" "$answer" || [ "$answer" = "" ] ; then
         return 0
      elif strstr $"cC" "$answer" ; then
     rm -f /var/run/confirm
     [ -x /bin/plymouth ] && /bin/plymouth --show-splash
         return 2
      elif strstr $"nN" "$answer" ; then
         return 1
      fi
  done
}

第一個函數strstr的作用是判斷第一個參數"$1"中是否包含了"$2"，如果包含了則返回狀態碼0。這函數也是一個不錯的技巧。

第二個函數confirm的作用是根據互動式輸入的值返回不同的狀態碼，如果輸入的是y或Y或不輸入時，返回0。輸入的是c或C時，返回狀態碼2，輸入的是n或N時返回狀態碼1。

於是可以根據confirm的狀態值決定是否要繼續執行某個程式。

用法和效果如下：

[root@xuexi ~]# confirm
Start service  (Y)es/(N)o/(C)ontinue? [Y] Y
[root@xuexi ~]# echo $?
0
[root@xuexi ~]# confirm
Start service  (Y)es/(N)o/(C)ontinue? [Y] 
[root@xuexi ~]# echo $?
0
[root@xuexi ~]# confirm
Start service  (Y)es/(N)o/(C)ontinue? [Y] n
[root@xuexi ~]# echo $?
1
[root@xuexi ~]# confirm
Start service  (Y)es/(N)o/(C)ontinue? [Y] c
[root@xuexi ~]# echo $?
2

5.pid檢測相關函數

啟動進程時，pid文件非常重要。不僅可以通過它判斷進程是否在運行，還可以從中讀取pid號用來殺進程。

5.1 checkpid、__pids_var_run和__pids_pidof函數

pid文件的路徑可能為/var/run/$base.pid文件($base表示進程名的basename)，也可能是自定義的路徑，例如mysql的pid可以自定義為/mysql/data/mysql01.pid。但無論哪種情況，functions中的__pids_var_run函數都可以處理。
pid文件中可能有多行，表示多實例。
每個進程都必有一個pid，但並不一定都記錄在pid文件中，例如線程的pid。但無論如何，在/proc/目錄下，一定會有pid號命名的目錄，只要有對應pid號的目錄，就表示該進程已經在運行。函數checkpid專門檢測給定的pid值在/proc下是否有對應的目錄存在。
為了獲取進程名的pid值，此處函數__pids_pidof使用的是pidof命令。該命令專門設計用來在腳本中取給定進程的pid。它的"-o"選項用於忽略某些進程號，在腳本中應用時常被忽略的是調用pidof的shell的PID，當前shell的PID以及父shell的pid。總之，該函數的目的就是為了獲取合理無誤的進程pid。

以下是函數checkpid、__pids_var_run和__pids_pidof的定義語句。

# Check if any of $pid (could be plural) are running
checkpid() {
    local i

    for i in $* ; do          # 檢測/proc目錄下是否存在給定的進程目錄
        [ -d "/proc/$i" ] && return 0
    done
    return 1
}

# __proc_pids {program} [pidfile]
# Set $pid to pids from /var/run* for {program}.  $pid should be declared
# local in the caller.
# Returns LSB exit code for the 'status' action.
__pids_var_run() {                # 通過檢測pid判斷程式是否已在運行
    local base=${1##*/}           # 獲取進程名的basename
    local pid_file=${2:-/var/run/$base.pid}     # 定義pid文件路徑

    pid=
    if [ -f "$pid_file" ] ; then        # 給定的pid文件是否存在
            local line p

        [ ! -r "$pid_file" ] && return 4   # "user had insufficient privilege"
        while : ; do                       # 將pid文件中的pid值(可能有多行)賦值給pid變數
            read line
            [ -z "$line" ] && break
            for p in $line ; do
                [ -z "${p//[0-9]/}" ] && [ -d "/proc/$p" ] && pid="$pid $p"
            done
        done < "$pid_file"

            if [ -n "$pid" ]; then  # pid存在，則返回0。否則表示pid文件存在，但/proc下沒有對應命令
                    return 0        # 即進程已死，但pid文件卻存在，返回狀態碼1。
            fi
        return 1 # "Program is dead and /var/run pid file exists"
    fi
    return 3 # "Program is not running"    # pid文件不存在時，表示進程未運行，返回狀態碼3
}

# Output PIDs of matching processes, found using pidof
__pids_pidof() {             # 下麵的pidof命令的意義見稍後解釋
    pidof -c -m -o $$ -o $PPID -o %PPID -x "$1" || \   # 忽略當前shell的PID，父shell的pid和
                                                       # 調用pidof程式的shell的pid
        pidof -c -m -o $$ -o $PPID -o %PPID -x "${1##*/}"    # 總之就是找出合理的pid
}

從__pidsvar_run函數的定義語句中可以瞭解到，只有當pid文件存在，且/proc下有pid對應的目錄時，才表示進程在運行(當然，線程沒有pid文件)。__pids_var_run函數調用方法：

__pids_var_run program [pidfile]

如果不給定pidfile，則預設為/var/run/$base.pid文件。函數的執行結果為4種狀態碼：

0：program正在運行。
1：program進程已死。pid文件存在，但/proc目錄下沒有對應的文件。
3：pid文件不存在。
4：pid文件的許可權錯誤，不可讀。

除了返回狀態碼，__pids_var_run函數還會保存變數pid的結果，以供其他程式引用。

__pids_pidof中使用了pidof命令，其中使用了幾個"-o"選項，它用於忽略指定的pid。但看上去"$$""$PPID""%PPID"不是很好理解。"-o $$"是忽略的是shell進程，大多數時候它會繼承父shell的pid，但在腳本中時它代表的是腳本所在shell的pid。"-o $PPID"忽略的是父shell。"-o %PPID"忽略的是調用pidof命令的shell。不是很好理解，可以參考下麵的測試語句。

測試腳本：

#!/bin/bash

echo 'pidof bash: '`pidof bash`
echo 'script shell pid: '`echo $$`
echo 'script parent shell pid: '`echo $PPID`
echo 'pidof -o $$ bash: '`pidof -o $$ bash`
echo 'pidof -o $PPID bash: '`pidof -o $PPID bash`
echo 'pidof -o %PPID bash: '`pidof -o %PPID bash`
echo 'pidof -o $$ -o $PPID -o %PPID bash: '`pidof -o $$ -o $PPID -o %PPID bash`

測試語句：

[root@xuexi ~]# pidof bash
3306 2436 2302
[root@xuexi ~]# (echo 'parent shell: '$$;echo "current bash pid: `pidof bash`";./test.sh)|cat -n
 1  parent shell: 2302
 2  current bash pid: 3745 3306 2436 2302
 3  pidof bash: 3748 3745 3306 2436 2302
 4  script shell pid: 3748
 5  script parent shell pid: 3745
 6  pidof -o $$ bash: 3745 3306 2436 2302
 7  pidof -o $PPID bash: 3748 3306 2436 2302
 8  pidof -o %PPID bash: 3745 3306 2436 2302
 9  pidof -o $$ -o $PPID -o %PPID bash: 3306 2436 2302

第一個pidof命令：說明當前已有3個bash，pid為：3306、2436和2302。
第二個命令：

行1說明括弧的父shell為2302。
行5說明腳本的父shell為3745。即括弧的父shell為當前bash環境，腳本的父shell為括弧所在shell。
行2減第一個命令的結果說明括弧所在子shell的pid為3745。
行3減行2說明shell腳本所在子shell的pid為3748。
"-o $$"忽略的是當前shell，即腳本所在shell的pid，因為在shell腳本中時，$$不繼承父shell的pid。
"-o $PPID"忽略的是pidof所在父shell，即括弧所在shell。
"-o %PPID"忽略的是調用調用pidof程式所在的shell，即腳本所在shell。

5.2 pidfileofproc和pidofproc函數

除了以上3個pid相關函數，functions文件中，還提供了兩個函數pidfileofproc和pidofproc，均用於獲取給定程式的pid值。

以下是pidfileofproc函數的定義語句。註意，該函數不是獲取pidfile，而是獲取pid值。

# A function to find the pid of a program. Looks *only* at the pidfile
pidfileofproc() {
    local pid

    # Test syntax.
    if [ "$#" = 0 ] ; then
        echo $"Usage: pidfileofproc {program}"
        return 1
    fi

    __pids_var_run "$1"          # 不提供pidfile，因此認為是/var/run/$base.pid
    [ -n "$pid" ] && echo $pid
    return 0
}

因此，pidfileofproc函數只能獲取/var/run下的pid。

以下是pidofproc函數的定義語句：

# A function to find the pid of a program.
pidofproc() {
    local RC pid pid_file=

    # Test syntax.
    if [ "$#" = 0 ]; then
        echo $"Usage: pidofproc [-p pidfile] {program}"
        return 1
    fi
    if [ "$1" = "-p" ]; then    # 既可以獲取/var/run/$base.pid中的pid，
        pid_file=$2             # 也可以獲取自給定pid文件中的pid
        shift 2
    fi
    fail_code=3 # "Program is not running"

    # First try "/var/run/*.pid" files
    __pids_var_run "$1" "$pid_file"
    RC=$?
    if [ -n "$pid" ]; then     # $pid不為空時，輸出program的pid值
        echo $pid
        return 0
    fi

    [ -n "$pid_file" ] && return $RC   # $pid為空，但使用了"-p"指定pidfile時，返回$RC。
    __pids_pidof "$1" || return $RC    # $pid為空，且$pidfile為空時，獲取進程號pid並輸出
}

這兩個函數的區別在於pidfileofproc只能搜索/var/run下的pid，而pidofproc可以搜索自給定的pidfile或/var/run/下的pid。而前面的__pids_pidof函數，只有在獲取bash進程時更精確(因為它會忽略父shell進程)。至於選哪一個，見文末總結。

這兩個函數用的比較少，但確實有使用它的腳本。如crond啟動腳本中藉助pidfileofproc來殺進程：

echo -n $"Stopping $prog: "
if [ -n "`pidfileofproc $exec`" ]; then
        killproc $exec
        RETVAL=3
else
        failure $"Stopping $prog"
fi

dnsbind的named服務啟動腳本中藉助pidofproc來判斷進程是否已在運行。

pidofnamed() {
        pidofproc -p "$ROOTDIR$PIDFILE" "$named";
}

if [ -n "`pidofnamed`" ]; then
  echo -n $"named: already running"
  success
  echo
  exit 0;
fi;

6.重頭戲(一)：daemon函數

daemon函數用於啟動一個程式，並根據結果輸出success或failure。

定義語句如下：

# A function to start a program.
daemon() {
    # Test syntax.
    local gotbase= force= nicelevel corelimit    # 定義一大堆變數
    local pid base= user= nice= bg= pid_file=
    local cgroup=
    nicelevel=0
    while [ "$1" != "${1##[-+]}" ]; do   # 當參數$1以"-"或"+"開頭時進入迴圈，但$1為空時也滿足
      case $1 in
        '')    echo $"$0: Usage: daemon [+/-nicelevel] {program}" "[arg1]..."
               return 1;;
        --check)                 # daemon接受"--arg value"和"--arg=value"兩種格式的參數
           base=$2
           gotbase="yes"
           shift 2
           ;;
        --check=?*)
               base=${1#--check=}
           gotbase="yes"
           shift
           ;;
        --user)
           user=$2
           shift 2
           ;;
        --user=?*)
               user=${1#--user=}
           shift
           ;;
        --pidfile)
           pid_file=$2
           shift 2
           ;;
        --pidfile=?*)
           pid_file=${1#--pidfile=}
           shift
           ;;
        --force)
               force="force"
           shift
           ;;
        [-+][0-9]*)
               nice="nice -n $1"
               shift
           ;;
        *)     echo $"$0: Usage: daemon [+/-nicelevel] {program}" "[arg1]..."
               return 1;;
      esac
    done

        # Save basename.
        [ -z "$gotbase" ] && base=${1##*/}   # 若未傳遞"--check"，則此處獲取bashname

        # See if it's already running. Look *only* at the pid file.
    __pids_var_run "$base" "$pid_file"

    [ -n "$pid" -a -z "$force" ] && return    # 如進程已在運行(已檢測出pid)，且沒有使用force
                                              # 強制啟動，則退出daemon函數

    # make sure it doesn't core dump anywhere unless requested   
    corelimit="ulimit -S -c ${DAEMON_COREFILE_LIMIT:-0}"  # corelimit、cgroup和資源控制有關，忽略它

    # if they set NICELEVEL in /etc/sysconfig/foo, honor it
    [ -n "${NICELEVEL:-}" ] && nice="nice -n $NICELEVEL"

    # if they set CGROUP_DAEMON in /etc/sysconfig/foo, honor it
    if [ -n "${CGROUP_DAEMON}" ]; then
        if [ ! -x /bin/cgexec ]; then
            echo -n "Cgroups not installed"; warning
            echo
        else
            cgroup="/bin/cgexec";
            for i in $CGROUP_DAEMON; do
                cgroup="$cgroup -g $i";
            done
        fi
    fi

    # Echo daemon
        [ "${BOOTUP:-}" = "verbose" -a -z "${LSB:-}" ] && echo -n " $base"

    # And start it up.      # 啟動程式。runuser的"-s"指定執行程式的shell，$user指定運行的身份
                            # "$*"是剔除掉daemon選項後程式的啟動指令。
    if [ -z "$user" ]; then
       $cgroup $nice /bin/bash -c "$corelimit >/dev/null 2>&1 ; $*"
    else
       $cgroup $nice runuser -s /bin/bash $user -c "$corelimit >/dev/null 2>&1 ; $*"
    fi

    [ "$?" -eq 0 ] && success $"$base startup" || failure $"$base startup"
}

daemon函數調用方法：

daemon [--check=servicename] [--user=USER] [--pidfile=PIDFILE] [--force] program [prog_args]

需要註意的是：

只有"--user"可以用來控制program啟動的環境。
"--check"和"--pidfile"都是用來檢查是否已運行的，不是用來啟動的，如果提供了"--check"，則檢查的是名為servicename的進程，否則檢查的是program名稱的進程。
"--force"則表示進程已存在時仍啟動。
prog_args是向program傳遞它的運行參數，一般會從/etc/sysconfig/$base文件中獲取。

例如httpd的啟動腳本中。

echo -n $"Starting $prog: "
daemon --pidfile=${pidfile} $httpd $OPTIONS

這樣的語句的執行結果大致如下：

[root@xuexi ~]# service httpd start
Starting httpd:                            [  OK  ]

還需註意，通常program的運行參數可能也是"--"開頭的，要和program前面的選項區分。例如：

daemon --pidfile $pidfile --check $servicename $processname --pid-file=$pidfile

第二個"--pid-file"是"$processname"的運行參數，第一個"--pidfile"是daemon檢測"$processname"是否已運行的選項。由於提供了"--check $servicename"，所以函數調用語句__pids_var_run $base [pidfile]中的$base等於$servicename，即表示檢查$servicename進程是否允許。如果沒有提供該選項，則檢查的是$processname。

至此，daemon函數已經分析完成。實際上很簡單，就是為daemon提供幾個選項，再提供要執行的命令，併為該命令提供啟動參數。

7.重頭戲(二)：killproc函數

killproc函數的作用是根據給定程式名殺進程。中間它會獲取程式名對應的pid號，且保證/proc目錄下沒有pid對應的目錄才表示進程關閉成功。

# A function to stop a program.
killproc() {
    local RC killlevel= base pid pid_file= delay try

    RC=0; delay=3; try=0
    # Test syntax.
    if [ "$#" -eq 0 ]; then
        echo $"Usage: killproc [-p pidfile] [ -d delay] {program} [-signal]"
        return 1
    fi
    if [ "$1" = "-p" ]; then  # 指定pid_file。不給"-p"時，"__pids_var_run"將檢查/var/run下的文件
        pid_file=$2
        shift 2
    fi
    if [ "$1" = "-d" ]; then  # awk的多目運算符。delay的有效值單位為d(天)、時(h)、分(m)、秒(s)。
                              # 不寫單位時預設為秒。該語句將所給時間轉換成秒，接受小數，做四捨五入計算
        delay=$(echo $2 | awk -v RS=' ' -v IGNORECASE=1 '{if($1!~/^[0-9.]+[smhd]?$/) exit 1;d=$1~/s$|^[0-9.]*$/?1:$1~/m$/?60:$1~/h$/?60*60:$1~/d$/?24*60*60:-1;if(d==-1) exit 1;delay+=d*$1} END {printf("%d",delay+0.5)}')
        if [ "$?" -eq 1 ]; then
            echo $"Usage: killproc [-p pidfile] [ -d delay] {program} [-signal]
            return 1
        fi
        shift 2
    fi


    # check for second arg to be kill level
    [ -n "${2:-}" ] && killlevel=$2     # 獲取稍後的kill程式將要發送的信號

        # Save basename.
        base=${1##*/}

    # Find pid.                       # 獲取program的pid號，以讓kill程式殺掉
    __pids_var_run "$1" "$pid_file"   # 檢查program是否已有對應pid文件，並返回pidfile中所有pid值
    RC=$?
    if [ -z "$pid" ]; then
        if [ -z "$pid_file" ]; then
            pid="$(__pids_pidof "$1")"  # pid為空，且沒有pidfile時，獲取program的pid
        else
            [ "$RC" = "4" ] && { failure $"$base shutdown" ; return $RC ;}
        fi
    fi

    # Kill it.    # 根據pid，殺掉已存在的進程
    if [ -n "$pid" ] ; then    # 如果進程pid存在，則殺死它
        [ "$BOOTUP" = "verbose" -a -z "${LSB:-}" ] && echo -n "$base "
        if [ -z "$killlevel" ] ; then       # 沒有指定要傳遞的信號時
            if checkpid $pid 2>&1; then  # 給定pid在/proc目錄中是否有對應目錄
                # TERM first, then KILL if not dead
                kill -TERM $pid >/dev/null 2>&1   # 先發送TERM信號
                usleep 50000
                if checkpid $pid ; then           # 0.5秒後還沒死透，則
                    try=0
                    while [ $try -lt $delay ] ; do   # 在給定delay時間內不斷檢測是否已死
                        checkpid $pid || break
                        sleep 1
                        let try+=1
                    done
                    if checkpid $pid ; then          # 超出delay後，發送KILL信號強制殺死
                        kill -KILL $pid >/dev/null 2>&1
                        usleep 50000
                    fi
                fi
            fi
            checkpid $pid   # 若/proc下還有pid對應的目錄，則進程關閉失敗
            RC=$?
            [ "$RC" -eq 0 ] && failure $"$base shutdown" || success $"$base shutdown"
            RC=$((! $RC))
        # use specified level only
        else                            # 使用指定的信號殺進程
            if checkpid $pid; then
                kill $killlevel $pid >/dev/null 2>&1
                RC=$?
                [ "$RC" -eq 0 ] && success $"$base $killlevel" || failure $"$base $killlevel"
            elif [ -n "${LSB:-}" ]; then
                RC=7 # Program is not running
            fi
        fi
    else                              # 如果進程pid不存在，表示未運行
        if [ -n "${LSB:-}" -a -n "$killlevel" ]; then
            RC=7 # Program is not running
        else
            failure $"$base shutdown"
            RC=0
        fi
    fi

    # Remove pid file if any.
    if [ -z "$killlevel" ]; then    # 未給定信號時，可能KILL信號強殺時使得pid文件還存在，手動移除它
            rm -f "${pid_file:-/var/run/$base.pid}"
    fi
    return $RC
}

根據此腳本，可以知道關閉進程時，需要再三確定pid文件是否存在，/proc下是否有和pid對應的目錄。直到/proc下已經沒有了和pid對應的目錄時，才表示進程真正殺死了。但此時pid文件仍可能存在，因此還要保證pid文件已被移除。

該函數的調用方法：

killproc [-p pidfile] [ -d delay] {program} [-signal]

8.重頭戲(三)：status函數

status函數用於獲取進程的運行狀態，有以下幾種狀態：

${base} (pid $pid) is running...
${base} dead but pid file exists
${base} status unknown due to insufficient privileges.
${base} dead but subsys locked
${base} is stopped

以下的status函數定義語句。註意，此為CentOS 7上語句，比CentOS 6多了一段systemctl的處理，用於Sysv的status狀態向systemd的status狀態轉換。

status() {
    local base pid lock_file= pid_file=

    # Test syntax.
    if [ "$#" = 0 ] ; then
        echo $"Usage: status [-p pidfile] {program}"
        return 1
    fi
    if [ "$1" = "-p" ]; then
        pid_file=$2           # 指定pidfile
        shift 2
    fi
    if [ "$1" = "-l" ]; then
        lock_file=$2          # 指定lockfile
        shift 2
    fi
    base=${1##*/}

    if [ "$_use_systemctl" = "1" ]; then
        systemctl status ${0##*/}.service
        ret=$?
        # LSB daemons that dies abnormally in systemd looks alive in 
        # systemd's eyes due to RemainAfterExit=yes
        # lets adjust the reality a little bit
        if systemctl show -p ActiveState ${0##*/}.service | grep -q '=active$' && \
        systemctl show -p SubState ${0##*/}.service | grep -q '=exited$' ; then
            ret=3
        fi
        return $ret
    fi

    # First try "pidof"
    __pids_var_run "$1" "$pid_file"   # 根據給定的pidfile獲取program的pid，並返回pid值
    RC=$?
    if [ -z "$pid_file" -a -z "$pid" ]; then   # pid為空，且沒有pidfile時，獲取program的pid
        pid="$(__pids_pidof "$1")"
    fi
    if [ -n "$pid" ]; then             # pid存在，則返回程式正在運行
        echo $"${base} (pid $pid) is running..."
        return 0
    fi

    case "$RC" in
        0)
            echo $"${base} (pid $pid) is running..."
            return 0
            ;;
        1)               # program進程已死。pid文件存在，但/proc目錄下沒有對應的文件。
            echo $"${base} dead but pid file exists"
            return 1
            ;;
        4)               # pid文件不可讀，錯誤
            echo $"${base} status unknown due to insufficient privileges."
            return 4
            ;;
    esac
    if [ -z "${lock_file}" ]; then
        lock_file=${base}
    fi
    # See if /var/lock/subsys/${lock_file} exists  
    if [ -f /var/lock/subsys/${lock_file} ]; then   # 檢查/var/lock/subsys下是否有lockfile
        echo $"${base} dead but subsys locked"      # pid不存在，但鎖文件存在時
        return 2
    fi
    echo $"${base} is stopped"

自己編寫服務啟動腳本(一)：functions文件詳細分析和說明