自己写的命令，还无法进行并发执行。shell的一个缺点。没有并发的概念。只能通过后台进程去实现了。最后终于解决。

粗糙简单的代码

gexecbg()
{
    jid_old=`jobs -p|tail -n 1`
    for i in ${*:1:$#-1};
    do
        [[ $i > = ]]&&host=$i.asc.cnz.alimama.com||host=119.42.239.$i
        ssh $host ${*:$#} &
    done
    jid_new=`jobs -p`
    wait ${jid_new#*`echo $jid_old`} 2>/dev/null||:
}

用法:  gexecbg 31 32 33 'hostname' 
就会在指定的ip上，运行上述命令。而且是并发的。一些分析大量日志的操作，可以使用此函数。

另一篇比较好的参考文章：http://www.cnitblog.com/sysop/archive/2008/11/03/50974.aspx

附上关于linux的jobs的细节。（转）


下列命令可以用来操纵进程任务：
T"^9t�MQ?7b#mE 　　ps 列出系统中正在运行的进程；
%gNPr ` 　　kill 发送信号给一个或多个进程（经常用来杀死一个进程）；
d| O/E9h.}[} 　　jobs 列出当前shell环境中已启动的任务状态，若未指定jobsid，则显示所有活动的任务状态信息；如果报告了一个任务的终止(即任务的状态被标记为Terminated)，shell 从当前的shell环境已知的列表中删除任务的进程标识；3V$MlE$m
　　bg 将进程搬到后台运行（Background）；
D DB OAk6o 　　fg 将进程搬到前台运行（Foreground）；
(Z8Y(_9m-F
V8cwzFL.f
*Io:SB(d 　　将job转移到后台运行 q0u�c9rq)Q9`?"O
　　如果你经常在X图形下工作，你可能有这样的经历：通过终端命令运行一个GUI程序，GUI界面出来了，但是你的终端还停留在原地，你不能在shell中继续执行其他命令了，除非将GUI程序关掉。

hN#~+wa${W
&`�};b9@-b9W 　　为了使程序执行后终端还能继续接受命令，你可以将进程移到后台运行，使用如下命令运行程序： #假设要运行xmmsK-^\qXXDK

K K7^Od;aY_v6} 　　$xmms &
b"f"@.}5X5|Is y }-A0U*u7S�?L
　　这样打开xmms后，终端的提示又回来了。现在xmms在后台运行着呢；但万一你运行程序时忘记使用“&”了，又不想重新执行；你可以先使用ctrl+z挂起程序，然后敲入bg命令，这样程序就在后台继续运行了。
X%x!@ R7^v
@ x
;P}BHn/xS/{5d)Kc 　　概念：当前任务
4@#zJ/d(~e
Gn2T
siN4]�y 　　如果后台的任务号有2个，[1],[2]；如果当第一个后台任务顺利执行完毕，第二个后台任务还在执行中时，当前任务便会自动变成后台任务号码 “[2]”的后台任务。所以可以得出一点，即当前任务是会变动的。当用户输入“fg”、“bg”和“stop”等命令时，如果不加任何引号，则所变动的均 是当前任务。
8K3Q2Z~vO e`"t
s1q,@ vS7P9`+eHC"| 　　察看jobs zur2GSr
　　使用jobs或ps命令可以察看正在执行的jobs。
"rCQ5G)rr ?,S sq1gfkW�]
　　jobs命令执行的结果，＋表示是一个当前的作业，减号表是是一个当前作业之后的一个作业，jobs -l选项可显示所有任务的PID,jobs的状态可以是running, stopped, Terminated,但是如果任务被终止了（kill），shell 从当前的shell环境已知的列表中删除任务的进程标识；也就是说，jobs命令显示的是当前shell环境中所起的后台正在运行或者被挂起的任务信息；
i$q~rb4hK5D s.[k m;TQX2v
　　进程的挂起 "u"G2A-W3qRZ7l/VJ'X

{ {\G:E$h1V~n,J 　　后台进程的挂起：
^(MXS|u-}YJz 9P DlE3pR
　　在solaris中通过stop命令执行，通过jobs命令查看job号(假设为num)，然后执行stop %num；LQS{
E1}
|!`+H.}%W9y
　　在redhat中，不存在stop命令，可通过执行命令kill -stop PID，将进程挂起；;cIfB7l$K0GY"P

)ki(_c
M 　　当要重新执行当前被挂起的任务时，通过bg %num 即可将挂起的job的状态由stopped改为running，仍在后台执行；当需要改为在前台执行时，执行命令fg %num即可；
7Ka@'r
i$d E
$ti!\#u9i6j/k"j 　　前台进程的挂起：y6b`4Br
ABs

D4g%u1~$_0d&sJY 　　ctrl+Z;
sE+K'Ah1{/Q+H/Z`8y}
FJ,E.~U/N i 　　进程的终止 l|?m\}
;o6xr i_+Ue F
　　后台进程的终止：
'Y:T5M9ZP|1e 　　方法一：
(V(y
iO5`T@6_ 　　通过jobs命令查看job号（假设为num），然后执行kill %numZ8`l~�B

yf(N%g�{,lgn u 　　方法二：SwQ,D6}h1nr8G
　　通过ps命令查看job的进程号（PID，假设为pid），然后执行kill pid :d]�Bt7vO
rt9a.mPW"FA
　　前台进程的终止：!MX`w}

#b'p$J�Bv9I$J{w 　　ctrl+c
r7\yXf Ws)c6K}/T
q
@{5["M"g#f(O |,G 　　kill的其他作用
9CFa"rC3_Z 　　kill除了可以终止进程，还能给进程发送其它信号，使用kill -l 可以察看kill支持的信号。 7Iv"z&KA:f'K

EWC:V
sm;r�vi:y.XV+q 　　SIGTERM是不带参数时kill发送的信号，意思是要进程终止运行，但执行与否还得看进程是否支持。如果进程还没有终止，可以使用kill -SIGKILL pid，这是由内核来终止进程，进程不能监听这个信号。

同事让我把两份csv文件中的数据连接起来，就是把一个csv文件中的id换成另一个csv文件中的对应的字符串。
excel不熟，数量也不小。放弃手工的可能性了。
可惜我不会excel，不知道是否有这种功能。

初步设想是使用shell编程实现，但是里面含有大量的汉字，转换的时候，容易出现乱码的情况。
后来想一下，发现这种要求很像sql的连接查询。

如果能够转换成数据库，然后再连接查询出来，岂不更好。就不用谢一堆代码了。
研究了一阵子，发现了 MySQL-Front 可以很方便的输入输出数据表为xls等其他文件格式。非常的方便。
导入进去了。然后使用连接查询得出结果。然后把结果再导出问excel文件即可。

或者使用access，利用access的导入功能，把xls导入为表，然后连接查询，把结果粘贴进excel即可。

任务顺利完成，庆幸自己幸好没有使用shell完成，会点sql还是挺有帮助的。
有的时候需要转换下思路，这样更好。
附上sql的语句。

SELECT *
FROM data
left  JOIN ff
ON  ff.id=data.fid

vmstat
iostat
top
ps
sar
nmon

sysstat工具包
http://pagesperso-orange.fr/sebastien.godard/download.html

最近想利用系统中的一些基本命令，以脚本的形式，自动分析系统的状况。
可以监控到全系统。也可以监控到进程级别。

一些基本的指标
cpu_busy,cpu_idle,cpu_iowait,mem_user,memcache,load_one

最近在找进程级别的监控工具。发现了这篇文章，还是不错的。收录下。sar的功能其实已经涵盖了vmstat，iostat。

linux 和unix下SAR命令的用法，对机器性能检测很有帮助

dmesg可以直接查看cpu的主频，要查看CPU、内存的使用情况可以使用sar！

sar 命令行的常用格式： sar [options] [-A] [-o file] t [n]

在命令行中，n 和t 两个参数组合起来定义采样间隔和次数，t为采样间隔，是必须有 的参数，n为采样次数，是可选的，默认值是1，-o file表示将命令结果以二进制格式 存放在文件中，file 在此处不是关键字，是文件名。options 为命令行选项，sar命令 的选项很多，下面只列出常用选项：

　　　　　　-A：所有报告的总和。 　　　　　　　　-u：CPU利用率 　　　　　　　　-v：进程、I节点、文件和锁表状态。 　　　　　　　　-d：硬盘使用报告。 　　　　　　　　-r：没有使用的内存页面和硬盘块。 　　　　　　　　-g：串口I/O的情况。 -b：缓冲区使用情况。 -a：文件读写情况。 -c：系统调用情况。 -R：进程的活动情况。 -y：终端设备活动情况。 -w：系统交换活动。

下面将举例说明。

例一：使用命令行 sar -u t n

例如，每60秒采样一次，连续采样5次，观察CPU 的使用情况，并将采样结果以二进制 形式存入当前目录下的文件zhou中，需键入如下命令：

# sar -u -o zhou 60 5

屏幕显示：

　　SCO_SV　　　scosysv　3.2v5.0.5　i80386　　　10/01/2001 　　　　14:43:50　　　%usr　　　%sys　　%wio　　　　%idle(-u) 　　　　14:44:50　　　0　　　　　1　　　　4　　　　　　94 　　　　14:45:50　　　0　　　　　2　　　　4　　　　　　93 　　　　14:46:50　　　0　　　　　2　　　　2　　　　　　96 　　　　14:47:50　　　0　　　　　2　　　　5　　　　　　93 　　　　14:48:50　　　0　　　　　2　　　　2　　　　　　96 　　　　Average　　　 0　　　　　2　　　　4　　　　　　94

在显示内容包括：

　　%usr：CPU处在用户模式下的时间百分比。 　　%sys：CPU处在系统模式下的时间百分比。 　　%wio：CPU等待输入输出完成时间的百分比。 　　%idle：CPU空闲时间百分比。

在所有的显示中，我们应主要注意%wio和%idle，%wio的值过高，表示硬盘存在I/O瓶颈， %idle值高，表示CPU较空闲，如果%idle值高但系统响应慢时，有可能是CPU等待分配内存， 此时应加大内存容量。%idle值如果持续低于10，那么系统的CPU处理能力相对较低，表 明系统中最需要解决的资源是CPU。

如果要查看二进制文件zhou中的内容，则需键入如下sar命令：

　　　　# sar -u -f zhou

可见，sar命令即可以实时采样，又可以对以往的采样结果进行查询。

例二：使用命行sar -v t n

例如，每30秒采样一次，连续采样5次，观察核心表的状态，需键入如下命令：

# sar -v 30 5

屏幕显示： 　　　　　　SCO_SV scosysv 3.2v5.0.5 i80386 10/01/2001 　　　　　　10:33:23 proc-sz ov inod-sz ov file-sz ov lock-sz　　 (-v) 10:33:53　305/　321 　0　1337/2764　 0　1561/1706　0　40/　128 10:34:23　308/　321 　0　1340/2764　 0　1587/1706　0　37/　128 10:34:53　305/　321 　0　1332/2764　 0　1565/1706　0　36/　128 10:35:23　308/　321 　0　1338/2764　 0　1592/1706　0　37/　128 10:35:53　308/　321　 0　1335/2764　 0　1591/1706　0　37/　128

显示内容包括：

proc-sz：目前核心中正在使用或分配的进程表的表项数，由核心参数MAX-PROC控制。

　　inod-sz：目前核心中正在使用或分配的i节点表的表项数，由核心参数 MAX-INODE控制。

　　file-sz： 目前核心中正在使用或分配的文件表的表项数，由核心参数MAX-FILE控 制。

　　ov：溢出出现的次数。

　　Lock-sz：目前核心中正在使用或分配的记录加锁的表项数，由核心参数MAX-FLCKRE 控制。

显示格式为

实际使用表项/可以使用的表项数

显示内容表示，核心使用完全正常，三个表没有出现溢出现象，核心参数不需调整，如 果出现溢出时，要调整相应的核心参数，将对应的表项数加大。

例三：使用命行sar -d t n

例如，每30秒采样一次，连续采样5次，报告设备使用情况，需键入如下命令：

# sar -d 30 5

屏幕显示：

　　　　　　SCO_SV scosysv 3.2v5.0.5 i80386 10/01/2001 11:06:43 device　%busy　　　avque　　　r+w/s　　blks/s　　avwait avserv (-d) 11:07:13 wd-0　　　1.47　　　2.75　　　4.67　　　14.73　　 5.50 3.14 11:07:43 wd-0　　　0.43　　　18.77　　 3.07　　　8.66　　　25.11 1.41 11:08:13 wd-0　　　0.77　　　2.78　　　2.77　　　7.26　　　4.94 2.77 11:08:43 wd-0　　　1.10　　　11.18　　 4.10　　　11.26　　 27.32 2.68 11:09:13 wd-0　　　1.97　　　21.78　　 5.86　　　34.06　　　69.66 3.35 Average wd-0　　　1.15　　　12.11　　 4.09　　　15.19　　　31.12 2.80

显示内容包括：

device： sar命令正在监视的块设备的名字。 　　%busy： 设备忙时，传送请求所占时间的百分比。 　　avque： 队列站满时，未完成请求数量的平均值。 　　r+w/s： 每秒传送到设备或从设备传出的数据量。 　　blks/s： 每秒传送的块数，每块512字节。 　　avwait： 队列占满时传送请求等待队列空闲的平均时间。 　　avserv： 完成传送请求所需平均时间（毫秒）。

在显示的内容中，wd-0是硬盘的名字，%busy的值比较小，说明用于处理传送请求的有 效时间太少，文件系统效率不高，一般来讲，%busy值高些，avque值低些，文件系统 的效率比较高，如果%busy和avque值相对比较高，说明硬盘传输速度太慢，需调整。

例四：使用命行sar -b t n

例如，每30秒采样一次，连续采样5次，报告缓冲区的使用情况，需键入如下命令：

# sar -b 30 5

屏幕显示：

　　SCO_SV scosysv 3.2v5.0.5 i80386 10/01/2001 14:54:59 bread/s lread/s %rcache bwrit/s lwrit/s %wcache pread/s pwrit/s (-b) 14:55:29　0　　147　　100　 5　　21　　78　　 0　　　0 14:55:59　0　　186　　100　 5　　25　　79　　 0　　　0 14:56:29　4　　232 　　98　 8　　58　　86　　 0　　　0 14:56:59　0　　125　　100　 5　　23　　76　　 0　　　0 14:57:29　0　　 89　　100　 4　　12　　66　　 0　　　0 Average　 1　　156 　　99　 5　　28　　80　　 0　　　0

显示内容包括：

bread/s： 每秒从硬盘读入系统缓冲区buffer的物理块数。 lread/s： 平均每秒从系统buffer读出的逻辑块数。 %rcache： 在buffer cache中进行逻辑读的百分比。 bwrit/s： 平均每秒从系统buffer向磁盘所写的物理块数。 lwrit/s： 平均每秒写到系统buffer逻辑块数。 %wcache： 在buffer cache中进行逻辑读的百分比。 pread/s： 平均每秒请求物理读的次数。 pwrit/s： 平均每秒请求物理写的次数。

在显示的内容中，最重要的是%cache和%wcache两列，它们的值体现着buffer的使用效 率，%rcache的值小于90或者%wcache的值低于65，应适当增加系统buffer的数量，buffer 数量由核心参数NBUF控制，使%rcache达到90左右，%wcache达到80左右。但buffer参数 值的多少影响I/O效率，增加buffer，应在较大内存的情况下，否则系统效率反而得不到 提高。

例五：使用命行sar -g t n

例如，每30秒采样一次，连续采样5次，报告串口I/O的操作情况，需键入如下命令：

# sar -g 30 5

屏幕显示：

SCO_SV scosysv 3.2v5.0.5 i80386　　11/22/2001 17:07:03 　ovsiohw/s　 ovsiodma/s　　ovclist/s (-g) 17:07:33　　　0.00　　　0.00　　　0.00 17:08:03　　　0.00　　　0.00　　　0.00 17:08:33　　　0.00　　　0.00　　　0.00 17:09:03　　　0.00　　　0.00　　　0.00 17:09:33　　　0.00　　　0.00　　　0.00 Average 　　　0.00　　　0.00　　　0.00

显示内容包括：

ovsiohw/s：每秒在串口I/O硬件出现的溢出。

ovsiodma/s：每秒在串口I/O的直接输入输出通道高速缓存出现的溢出。

ovclist/s ：每秒字符队列出现的溢出。

在显示的内容中，每一列的值都是零，表明在采样时间内，系统中没有发生串口I/O溢 出现象。

sar命令的用法很多，有时判断一个问题，需要几个sar命令结合起来使用，比如，怀疑 CPU存在瓶颈，可用sar -u 和sar -q来看，怀疑I/O存在瓶颈，可用sar -b、sar -u和sar-d来看。 -------------------------------------------------------------------------------- Sar -A 所有的报告总和 -a 文件读，写报告 -B 报告附加的buffer cache使用情况 -b buffer cache使用情况 -c 系统调用使用报告 -d 硬盘使用报告 -g 有关串口I/O情况 -h 关于buffer使用统计数字 -m IPC消息和信号灯活动 -n 命名cache -p 调页活动 -q 运行队列和交换队列的平均长度 -R 报告进程的活动 -r 没有使用的内存页面和硬盘块 -u CPU利用率 -v 进程，i节点，文件和锁表状态 -w 系统交换活动 -y TTY设备活动

-a 报告文件读，写报告 sar –a 5 5 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/07/2002 11:45:40 iget/s namei/s dirbk/s (-a) 11:45:45 6 2 2 11:45:50 91 20 28 11:45:55 159 20 18 11:46:00 157 21 19 11:46:05 177 30 35 Average 118 18 20

iget/s 每秒由i节点项定位的文件数量 namei/s 每秒文件系统路径查询的数量 dirbk/s 每秒所读目录块的数量

＊这些值越大，表明核心花在存取用户文件上的时间越多，它反映着一些程序和应用文件系统产生的负荷。一般地，如果iget/s与namei /s的比值大于5，并且namei/s的值大于30，则说明文件系统是低效的。这时需要检查文件系统的自由空间，看看是否自由空间过少。

-b 报告缓冲区（buffer cache）的使用情况 sar -b 2 3 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/07/2002 13:51:28 bread/s lread/s %rcache bwrit/s lwrit/s %wcache pread/s pwrit/s (-b) 13:51:30 382 1380 72 131 273 52 0 0 13:51:32 378 516 27 6 22 72 0 0 13:51:34 172 323 47 39 57 32 0 0 Average 310 739 58 58 117 50 0 0

bread/s 平均每秒从硬盘（或其它块设备）读入系统buffer的物理块数 lread/s 平均每秒从系统buffer读出的逻辑块数 %rcache 在buffer cache中进行逻辑读的百分比（即100％ - bread/lreads） bwrit/s 平均每秒从系统buffer向磁盘（或其它块设备）所写的物理块数 lwrit/s 平均每秒写到系统buffer的逻辑块数 %wcache 在buffer cache中进行逻辑写的百分比（即100％ - bwrit/lwrit）. pread/sgu 平均每秒请求进行物理读的次数 pwrit/s 平均每秒请求进行物理写的次数

＊所显示的内容反映了目前与系统buffer有关的读，写活。在所报告的数字中，最重要的是%rcache和%wcache（统称为 cache命中率）两列，它们具体体现着系统buffer的效率。衡量cache效率的标准是它的命中率值的大小。 ＊如果%rcache的值小于90或者%wcache的值低于65，可能就需要增加系统buffer的数量。如果在系统的应用中，系统的I/O活动十分频 繁，并且在内存容量配置比较大时，可以增加buffer cache，使%rcache达到95左右，%wcache达到80左右。 ＊系统buffer cache中，buffer的数量由核心参数NBUF控制。它是一个要调的参数。系统中buffer数量的多少是影响系统I/O效率的瓶颈。要增加系统 buffer数量，则要求应该有较大的内存配置。否则一味增加buffer数量，势必减少用户进程在内存中的运行空间，这同样会导致系统效率下降。

-c 报告系统调用使用情况 sar -c 2 3 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/07/2002 17:02:42 scall/s sread/s swrit/s fork/s exec/s rchar/s wchar/s (-c) 17:02:44 2262 169 141 0.00 0.00 131250 22159 17:02:46 1416 61 38 0.00 0.00 437279 6464 17:02:48 1825 43 25 0.00 0.00 109397 42331 Average 1834 91 68 0.00 0.00 225975 23651

scall/s 每秒使用系统调用的总数。一般地，当4~6个用户在系统上工作时，每秒大约30个左右。 sread/s 每秒进行读操作的系统调用数量。 swrit/s 每秒进行写操作的系统调用数量。 fork/s 每秒fork系统调用次数。当4~6个用户在系统上工作时，每秒大约0.5秒左右。 exec/s 每秒exec系统调用次数。 rchar/s 每秒由读操作的系统调用传送的字符（以字节为单位）。 wchar/s 每秒由写操作的系统调用传送的字符（以字节为单位）。 ＊如果scall/s持续地大于300，则表明正在系统中运行的可能是效率很低的应用程序。在比较 典型的情况下，进行读操作的系统调用加上进行写操作的系统调用之和，约是scall的一半左右。

-d 报告硬盘使用情况 sar -d 2 3 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/07/2002 17:27:49 device %busy avque r+w/s blks/s avwait avserv (-d) 17:27:51 ida-0 6.93 1.00 13.86 259.41 0.00 5.00 ida-1 0.99 1.00 17.33 290.10 0.00 0.57 17:27:53 ida-0 75.50 1.00 54.00 157.00 0.00 13.98 ida-1 9.50 1.00 12.00 75.00 0.00 7.92 17:27:55 ida-0 7.46 1.00 46.77 213.93 0.00 1.60 ida-1 17.41 1.00 57.71 494.53 0.00 3.02 Average ida-0 29.85 1.00 38.14 210.28 0.00 7.83 ida-1 9.29 1.00 29.02 286.90 0.00 3.20

device 这是sar命令正在监视的块设备的名字。 %busy 设备忙时，运行传送请求所占用的时间。这个值以百分比表示。 avque 在指定的时间周期内，没有完成的请求数量的平均值。仅在队列被占满时取这个值。 r+w/s 每秒传送到设备或者从设备传送出的数据量。 blks/s 每秒传送的块数。每块512个字节。 avwait 传送请求等待队列空闲的平均时间（以毫秒为单位）。仅在队列被占满时取这个值。 avserv 完成传送请求所需平均时间（以毫秒为单位） ＊ida-0和ida-1是硬盘的设备名字。在显示的内容中，如果%busy的值比较小，说明用于处理 传送请求的有效时间太少，文件系统的效率不高。要使文件系统的效率得到优化，应使%busy的数值相对高一些，而avque的值应该低一些。

-g 报告有关串口I/O情况 sar -g 3 3 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/13/2002 11:10:09 ovsiohw/s ovsiodma/s ovclist/s (-g) 11:10:12 0.00 0.00 0.00 11:10:15 0.00 0.00 0.00 11:10:18 0.00 0.00 0.00 Average 0.00 0.00 0.00

ovsiohw/s 每秒在串囗I/O硬件出现的溢出。 ovsiodma/s 每秒在串囗I/O的直接输入，输出信道高速缓存出现的溢出。 ovclist/s 每秒字符队列出现的溢出。

-m 报告进程间的通信活动（IPC消息和信号灯活动）情况 sar -m 4 3 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/13/2002 13:24:28 msg/s sema/s (-m) 13:24:32 2.24 9.95 13:24:36 2.24 21.70 13:24:40 2.00 36.66 Average 2.16 22.76

msg/s 每秒消息操作的次数（包括发送消息的接收信息）。 sema/s 每秒信号灯操作次数。 ＊信号灯和消息作为进程间通信的工具，如果在系统中运行的应用过程中没有使用它们，那么由sar命令报告的msg 和sema的值都将等于0.00。如果使用了这些工具，并且其中或者msg/s大于100，或者sema/s大于100，则表明这样的应用程序效率比较 低。原因是在这样的应用程序中，大量的时间花费在进程之间的沟通上，而对保证进程本身有效的运行时间必然产生不良的影响。

-n 报告命名缓冲区活动情况 sar -n 4 3 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/13/2002 13:37:31 c_hits cmisses (hit %) (-n) 13:37:35 1246 71 (94%) 13:37:39 1853 81 (95%) 13:37:43 969 56 (94%) Average 1356 69 (95%)

c_hits cache命中的数量。 cmisses cache未命中的数量。 (hit %) 命中数量/(命中数理+未命中数量)。 ＊不难理解，(hit %)值越大越好，如果它低于90％，则应该调整相应的核心参数。

-p 报告分页活动 sar -p 5 3 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/13/2002 13:45:26 vflt/s pflt/s pgfil/s rclm/s (-p) 13:45:31 36.25 50.20 0.00 0.00 13:45:36 32.14 58.48 0.00 0.00 13:45:41 79.80 58.40 0.00 0.00 Average 49.37 55.69 0.00 0.00

vflt/s 每秒进行页面故障地址转换的数量（由于有效的页面当前不在内存中）。 pflt/s 每秒来自由于保护错误出现的页面故障数量（由于对页面的非法存，取引起的页面故障）。 pgfil/s 每秒通过”页—入”满足vflt/s的数量。 rclm/s 每秒由系统恢复的有效页面的数量。有效页面被增加到自由页面队列上。 ＊如果vflt/s的值高于100，可能预示着对于页面系统来说，应用程序的效率不高，也可能分页参数需要调整，或者内存配置不太合适。

-q 报告进程队列（运行队列和交换队列的平均长度）情况 sar -q 2 3 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/13/2002 14:25:50 runq-sz %runocc swpq-sz %swpocc (-q) 14:25:52 4.0 50 14:25:54 9.0 100 14:25:56 9.0 100 Average 7.3 100

runq-sz 准备运行的进程运行队列。 %runocc 运行队列被占用的时间（百分比） swpq-sz 要被换出的进程交换队列。 %swpocc 交换队列被占用的时间（百分比）。 ＊如果%runocc大于90，并且runq-sz的值大于2，则表明CPU的负载较重。其直接后果，可能使系统的响应速度降低。如果%swpocc大于 20，表明交换活动频繁，将严重导致系统效率下降。解决的办法是加大内存或减少缓存区数量，从而减少交换及页—入,页—出活动。

-r 报告内存及交换区使用情况（没有使用的内存页面和硬盘块） sar -r 2 3 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/14/2002 10:14:19 freemem freeswp availrmem availsmem (-r) 10:14:22 279729 6673824 93160 1106876 10:14:24 279663 6673824 93160 1106876 10:14:26 279661 6673824 93160 1106873 Average 279684 6673824 93160 1106875

freemem 用户进程可以使用的内存页面数，4KB为一个页面。 freeswp 用于进程交换可以使用的硬盘盘块，512B为一个盘块。

-u CPU利用率 sar -u 2 3 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/14/2002 10:27:23 %usr %sys %wio %idle (-u) 10:27:25 2 3 8 88 10:27:27 3 3 5 89 10:27:29 0 0 0 100 Average 2 2 4 92 . %usr cpu处在用户模式下时间（百分比） %sys cpu处在系统模式下时间（百分比） %wio cpu等待输入，输出完成（时间百分比） %idle cpu空闲时间（百分比） ＊在显示的内容中，%usr和 %sys这两个值一般情况下对系统无特别影响，%wio的值不能太高，如果%wio的值过高，则CPU花在等待输入，输出上的时间太多，这意味着硬盘存在 I/O瓶颈。如果%idle的值比较高，但系统响应并不快，那么这有可能是CPU花时间等待分配内存引起的。%idle的值可以较深入帮助人们了解系统的 性能，在这种情况上，%idle的值处于40~100之间，一旦它持续低于30，则表明进程竟争的主要资源不是内存而是CPU。 ＊在有大量用户运行的系统中，为了减少CPU的压力，应该使用智能多串卡，而不是非智能多串卡。智能多串卡可以承担CPU的某些负担。 ＊此外，如果系统中有大型的作业运行，应该把它们合理调度，错开高峰，当系统相对空闲时再运行。

-v 报告系统表的内容（进程，i节点，文件和锁表状态） sar -v 2 3 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/14/2002 10:56:46 proc-sz ov inod-sz ov file-sz ov lock-sz (-v) 10:56:48 449/ 500 0 994/4147 0 1313/2048 0 5/ 128 10:56:50 450/ 500 0 994/4147 0 1314/2048 0 5/ 128 10:56:52 450/ 500 0 994/4147 0 1314/2048 0 5/ 128

proc-sz 目前在核心中正在使用或分配的进程表的表项数 inod-sz 目前在核心中正在使用或分配的i节点表的表项数 file-sz 目前在核心中正在使用或分配的文件表的表项数 ov 溢出出现的次数 lock-sz 目前在核心中正在使用或分配的记录加锁的表项数 ＊除ov外，均涉及到unix的核心参数，它们分别受核心参数NPROC,NIMODE,NFILE和FLOCKREC的控制。 ＊显示格式为： 实际使用表项/整个表可以使用的表项数 比如，proc-sz一列所显示的四个数字中，分母的100是系统中整个进程表的长度（可建立100个表项），分子上的24，26和25分别是采样的那一段时间所使用的进程表项。inod-sz，file-sz和lock-sz三列数字的意义也相同。 三列ov的值分别对应进程表，i节点表和文件表，表明目前这三个表都没有出现溢出现象，当出现溢出时，需要调整相应的核心参数，将对应表加大。

-w 系统交换活动 sar -w 2 3 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/14/2002 11:22:05 swpin/s bswin/s swpot/s bswots pswch/s (-w) 11:22:07 0.00 0.0 0.00 0.0 330 11:22:09 0.00 0.0 0.00 0.0 892 11:22:11 0.00 0.0 0.00 0.0 1053 Average 0.00 0.0 0.00 0.0 757

swpin/s 每秒从硬盘交换区传送进入内存的次数。 bswin/s 每秒为换入而传送的块数。 swpot/s 每秒从内存传送到硬盘交换区的次数。 bswots 每秒为换出而传送的块数。 pswch/s 每秒进程交换的数量。 ＊swpin/s，bswin/s，swpot/s和bswots描述的是与硬盘交换区相关的交换活动。交换关系到系统的效率。交换区在硬盘上对硬盘的 读，写操作比内存读，写慢得多，因此，为了提高系统效率就应该设法减少交换。通常的作法就是加大内存，使交换区中进行的交换活动为零，或接近为零。如果 swpot/s的值大于1，预示可能需要增加内存或减少缓冲区（减少缓冲区能够释放一部分自由内存空间）。

-y 报告终端的I/O活动（TTY设备活动）情况 sar -y 2 3 SCO_SV scosvr 3.2v5.0.5 PentII(D)ISA 06/14/2002 11:38:03 rawch/s canch/s outch/s rcvin/s xmtin/s mdmin/s (-y) 11:38:05 5 0 951 0 1 0 11:38:07 10 0 996 0 0 0 11:38:09 4 0 2264 0 0 0 Average 6 0 1404 0 1 0

rawch/s 每秒输入的字符数（原始队列） canch/s 每秒由正则队列（canonical queue）处理的输入字符数。进行正则处理过程中，可以识别出一些有特殊意义的字符。比如，(中断字符)，(退出符)，(退格键)等。因此，canch/s中的计数不包括这些有特殊意义的字符。 outch/s 每秒输出的字符数。 rcvin/s 每秒接收的硬件中断次数。 xmtin/s 每秒发出的硬件中断次数。 mdmin/s 每秒modem中断次数。 ＊应该特别说明，sar命令可以对任意终端活动进行统计，所谓任意终端，是指任意tty设备。它们可以是串行终端，主控台，伪终端等等。 ＊在这几个量中，modem中断次数mdmin/s应该接近0。其它没有特殊要求，但如果每发送一个字符，中断的数量就动态地增加，这表明终端线出了差错，可能是接触不好。

假设有记录占据了三行，两个记录。
以前都是使用sed去读取。不停的变化行数来实现。
后来想象，awk的功能，我应该还没有挖掘到底。
需要把更多的逻辑运算通过awk来完成。

echo '
111
222
333
4444
555
666
'|awk 'BEGIN{FS="\n";RS="";}{for(i=1;i<NF;i++) {print $i,$(++i),$(++i)}}'
111 222 333
4444 555 666

看了red hat的招聘，感觉挺高端的。
项目中用到的linux技术很多，很多人都不懂，最近公司在讨论一些分布式的话题，我也是一点都不懂。
谈的都是架构的问题。发现自己的技术还是欠缺很多。

突然萌发了一个想法。想学习一下linux，转去red hat这样的大公司作测试。做上一年。学到的技术，应该就可以为国内的这些公司服务了。
现在在公司，自己什么都不是。也不能老是这样。
要尽快由菜鸟变成凤凰。

学习linux。自己的shell在公司已经无敌了。开始转入高端的领域学习吧。
同时坚持学习英语。等英语过关了，linux也就是小菜一碟了。

困扰了很久，我使用的是函数式编程，脚本里经常使用的getopts，放在函数中就是不行。今天终于解决了。
铭记一下。

showopts () {
    unset OPTIND
    while getopts "pq:" optname
    do
        echo  $optname
        case "$optname" in
            "p")
            echo "Option $optname is specified"
            ;;
            "q")
            echo "Option $optname has value $OPTARG"
            ;;
            "?")
            echo "Unknown option $OPTARG"
            ;;
            ":")
            echo "No argument value for option $OPTARG"
            ;;
            *)
            # Should not occur
            echo "Unknown error while processing options"
            ;;
        esac
    done
}

系统

# uname -a               # 查看内核/操作系统/CPU信息
# head -n 1 /etc/issue   # 查看操作系统版本
# cat /proc/cpuinfo      # 查看CPU信息
# hostname               # 查看计算机名
# lspci -tv              # 列出所有PCI设备
# lsusb -tv              # 列出所有USB设备
# lsmod                  # 列出加载的内核模块
# env                    # 查看环境变量

资源

# free -m                # 查看内存使用量和交换区使用量
# df -h                  # 查看各分区使用情况
# du -sh <目录名>        # 查看指定目录的大小
# grep MemTotal /proc/meminfo   # 查看内存总量
# grep MemFree /proc/meminfo    # 查看空闲内存量
# uptime                 # 查看系统运行时间、用户数、负载
# cat /proc/loadavg      # 查看系统负载

磁盘和分区

# mount | column -t      # 查看挂接的分区状态
# fdisk -l               # 查看所有分区
# swapon -s              # 查看所有交换分区
# hdparm -i /dev/hda     # 查看磁盘参数(仅适用于IDE设备)
# dmesg | grep IDE       # 查看启动时IDE设备检测状况

网络

# ifconfig               # 查看所有网络接口的属性
# iptables -L            # 查看防火墙设置
# route -n               # 查看路由表
# netstat -lntp          # 查看所有监听端口
# netstat -antp          # 查看所有已经建立的连接
# netstat -s             # 查看网络统计信息

进程

# ps -ef                 # 查看所有进程
# top                    # 实时显示进程状态

用户

# w                      # 查看活动用户
# id <用户名>            # 查看指定用户信息
# last                   # 查看用户登录日志
# cut -d: -f1 /etc/passwd   # 查看系统所有用户
# cut -d: -f1 /etc/group    # 查看系统所有组
# crontab -l             # 查看当前用户的计划任务

服务

# chkconfig --list       # 列出所有系统服务
# chkconfig --list | grep on    # 列出所有启动的系统服务

程序

# rpm -qa                # 查看所有安装的软件包

自己最近纯粹吃饱撑的了。
想把多个性能测试的case用脚本去实现。
目前已经实现了大部分了。只差一点点了。

不止一次的问自己，真的是没有必要。自己越来越懒了。
越来越依赖自己的脚本了。

发现了写脚本的一个非常不错的方法。
采用函数编程。

      gexec $search_list $proxy_list  logsave 2>&1 |tee logsave.txt #save log  #去所有的search和proxy上去保存日志

可以在每个机器上，修改启动脚本，增加关于logsave的定义，实现不同角色的个性定义。

发现这个方法非常的棒，解决了不少问题，记录一下。

abenchloadm()

{

         [ $# -eq 0 ]&&echo "abenchloadm paramters ip port datadir

         example abenchload  -s 7200 -p 18 -k 119.42.239.38 2312 offer_url"&&return||echo "OK,start abench"

         [[ `echo $*|grep "\-p"` ]]&&(echo $*|grep "\-k"&&print "OK,-p with -k"||print "Be carefull , no -k")

         #all the history operations would be record in the abench.log , you can use it to check history .

         seven #reload seven.sh and $USER.sh

         abench_log=abench.log

         now=`date +%Y%m%d%H%M`

         #show the start time and parameters and save them to abench.log

         echo $*

         echo "Start at $now

         $* " >>$abench_log

         #invoke abench and give it the parameters

         abench -l abench_$now.log $*  2>&1|tee abench_$now

         timestop=`date +"%m/%d/%Y %H:%M"`

         echo "End at `date +%Y%m%d%H%M`    " >>$abench_log

         #get the time and format it for simon

         timestart="${now:4:2}/${now:6:2}/${now:0:4} ${now:8:2}:${now:10}"

         #invoke report function for get the urls of simon and some basic infomation

         reportm "$timestart"  "$timestop"  >report_${now}.htm   #生成相关simon图报告，此函数不同之前的report，它可以提供机器列表的资源占用信息，比如cpu，memuser之类的，并统计出search的平均指标作为参考。

         echo start save log

         gexec $search_list $proxy_list  logsave 2>&1 |tee logsave.txt #save log  #去所有的search和proxy上去保存日志

         echo start get config

         gexec $search_list $proxy_list  '{ cd $install_dir/etc; getconfig;check root=; } ' > config.txt 2>&1 #check config  #去所有机器上收集配置信息，以备检查。

         echo start check log

         glogcheck|uniq -c > logcheck.txt  2>&1 #check log  #去所有机器上分析日志

         #mail you the result by attachments

         echo start send mail

         echo "$*"|mutt -s AT@`hostname` -a abench_$now -a report_${now}.htm -a logsave.txt -a logcheck.txt -a config.txt $mail_addr  #发送所有结果到你的工作信箱

         #if you setted the mobie_mail var , it will notice you by a sms

         if [[ -n $mobile_mail ]]    #设置手机邮箱的话，就发短信提醒。

         then

                   qps="qps=`cat abench_$now|grep "query per second"|awk -F: '{print $2}'`"

                   art="art=`cat abench_$now|grep "average response time"|awk -F: '{print $2}'`"

                   echo "`cat abench_$now` "|mutt -s "$qps $art cmd abenchloadm $*"  $mobile_mail

         fi

}

 

练习shell的总结。
函数库中的部门代码
远程执行命令，传送文件，或者文件同步。自动输入密码。需要expect的支持。
常在linux下操作的话，这些肯定是容易用到的。绿色的。不用使用rexec和rsync。
更方便。存入文件，source 一下即可。

用法
登陆  se ip/主机名
gexec ip/主机名  ip/主机名  'cmd'
gsyn ip/主机名  ip/主机名  文件或者目录的位置

#ssh login or execute comd
se()
{
    [[ -z $1 ]]&& echo se se3 who
    [[ "$1" > = ]]&&host=$1.xxxxx.com||host=119.42.239.$1
    ssh $host $2

}

#execute cmd in group, example, gexec se2 se3 35 'ps -x'
gexec()
{
    for i in ${*:1:$#-1};
    do
        [[ $i > = ]]&&host=$i.xxxxx.com||host=119.42.239.$i
        ex ssh $host ${*:$#}
    done
}

#distribute directorys or files, example, gsyn se2 se3 35 ~/dir
gsyn()
{
    cd `dirname ${*:$#}`
    cd $OLDPWD
    for i in ${*:1:$#-1};
    do  
        [[ $i > = ]]&&host=$i.xxxxx.com||host=119.42.239.$i  
        ex scp -r ${*:$#} $host:$OLDPWD/
    done
}

gscp()
{
    for i in ${*:1:$#-2};
    do
        [[ $i > = ]]&&host=$i.xxxxx.com||host=119.42.239.$i
        ex scp -r ${*:$#-1:1} $host:~/${*:$#}      
    done
}

check()
{
    if [ $# = 0 ]
    then
        echo "check ip|file|config string"
        return
    fi
    case $* in
        file)
        find . -name "*.*" | xargs grep /home/.* | awk -F/home '{print $1":/home"$2}'| sed -e 's/[^a-zA-Z0-9]*$//'|awk -F: '{gsub("\""," ");system("if [ ! -e  "$3" ] ;then echo \""$0"\" ;fi;")}'
        echo "WARNNING, those files wasn't exist,please check "
        ;;
        ip)
        find . -name "*.*" |xargs grep "[1-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}"
        ;;
        *)
        ls|xargs grep "$1"
        temp=`ls|xargs grep "$1"|sed -n $3p|uniq`      
        if [[ -n $2 ]]
        then
            temp=`echo $temp|awk -F= '{print $2}'`
            [[ $temp = "$2" ]]&&print OK||print WARNNING
        fi
        ;;
    esac
}

#set for load seven.sh when login
autostart()
{
    sed -i -e '/source seven/d' ~/.bashrc
    echo "source seven.sh ||: ; source /home/huangysh/seven.sh ||:" >>~/.bashrc && print "OK, you already have the power of qa shell functions, good luck"  
}

#the core of whole script. used for automation
ex()
{
    expect -c "set timeout -1;spawn $*; while {1} {expect eof {puts \nEX_OK\n;exit}  Password {puts Password;send ${PW}\n}  (yes/no)? {puts EX_YES;send yes\n}  timeout {puts EX_TIMEOUT;interact} }"
}

最近在做性能测试。发现集群中，有一个机器的io比较大。还不是太熟悉linux下的io如何评测。搜索到了如下的文章，挺好的，记录一下，分析io的一个不错的方法。

# iostat -x 1 10
Linux 2.6.18-92.el5xen    02/03/2009

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
           1.10    0.00    4.82   39.54    0.07   54.46

Device:         rrqm/s   wrqm/s   r/s   w/s   rsec/s   wsec/s avgrq-sz avgqu-sz   await  svctm  %util
sda               0.00     3.50  0.40  2.50     5.60    48.00    18.48     0.00    0.97   0.97   0.28
sdb               0.00     0.00  0.00  0.00     0.00     0.00     0.00     0.00    0.00   0.00   0.00
sdc               0.00     0.00  0.00  0.00     0.00     0.00     0.00     0.00    0.00   0.00   0.00
sdd               0.00     0.00  0.00  0.00     0.00     0.00     0.00     0.00    0.00   0.00   0.00
sde               0.00     0.10  0.30  0.20     2.40     2.40     9.60     0.00    1.60   1.60   0.08
sdf              17.40     0.50 102.00  0.20 12095.20     5.60   118.40     0.70    6.81   2.09  21.36
sdg             232.40     1.90 379.70  0.50 76451.20    19.20   201.13     4.94   13.78   2.45  93.16

rrqm/s:   每秒进行 merge 的读操作数目。即 delta(rmerge)/s
wrqm/s:  每秒进行 merge 的写操作数目。即 delta(wmerge)/s
r/s:           每秒完成的读 I/O 设备次数。即 delta(rio)/s
w/s:         每秒完成的写 I/O 设备次数。即 delta(wio)/s
rsec/s:    每秒读扇区数。即 delta(rsect)/s
wsec/s:  每秒写扇区数。即 delta(wsect)/s
rkB/s:      每秒读K字节数。是 rsect/s 的一半，因为每扇区大小为512字节。(需要计算)
wkB/s:    每秒写K字节数。是 wsect/s 的一半。(需要计算)
avgrq-sz: 平均每次设备I/O操作的数据大小 (扇区)。delta(rsect+wsect)/delta(rio+wio)
avgqu-sz: 平均I/O队列长度。即 delta(aveq)/s/1000 (因为aveq的单位为毫秒)。
await:    平均每次设备I/O操作的等待时间 (毫秒)。即 delta(ruse+wuse)/delta(rio+wio)
svctm:   平均每次设备I/O操作的服务时间 (毫秒)。即 delta(use)/delta(rio+wio)
%util:      一秒中有百分之多少的时间用于 I/O 操作，或者说一秒中有多少时间 I/O 队列是非空的。即 delta(use)/s/1000 (因为use的单位为毫秒)

如果 %util 接近 100%，说明产生的I/O请求太多，I/O系统已经满负荷，该磁盘
可能存在瓶颈。
idle小于70% IO压力就较大了,一般读取速度有较多的wait.
同时可以结合vmstat 查看查看b参数(等待资源的进程数)和wa参数(IO等待所占用的CPU时间的百分比,高过30%时IO压力高)

另外还可以参考
svctm 一般要小于 await (因为同时等待的请求的等待时间被重复计算了)，svctm 的大小一般和磁盘性能有关，CPU/内存的负荷也会对其有影响，请求过多也会间接导致 svctm 的增加。await 的大小一般取决于服务时间(svctm) 以及 I/O 队列的长度和 I/O 请求的发出模式。如果 svctm 比较接近 await，说明 I/O 几乎没有等待时间；如果 await 远大于 svctm，说明 I/O 队列太长，应用得到的响应时间变慢，如果响应时间超过了用户可以容许的范围，这时可以考虑更换更快的磁盘，调整内核 elevator 算法，优化应用，或者升级 CPU。
队列长度(avgqu-sz)也可作为衡量系统 I/O 负荷的指标，但由于 avgqu-sz 是按照单位时间的平均值，所以不能反映瞬间的 I/O 洪水。

  别人一个不错的例子.(I/O 系统 vs. 超市排队)

举一个例子，我们在超市排队 checkout 时，怎么决定该去哪个交款台呢? 首当是看排的队人数，5个人总比20人要快吧? 除了数人头，我们也常常看看前面人购买的东西多少，如果前面有个采购了一星期食品的大妈，那么可以考虑换个队排了。还有就是收银员的速度了，如果碰上了连 钱都点不清楚的新手，那就有的等了。另外，时机也很重要，可能 5 分钟前还人满为患的收款台，现在已是人去楼空，这时候交款可是很爽啊，当然，前提是那过去的 5 分钟里所做的事情比排队要有意义 (不过我还没发现什么事情比排队还无聊的)。

I/O 系统也和超市排队有很多类似之处:

r/s+w/s 类似于交款人的总数
平均队列长度(avgqu-sz)类似于单位时间里平均排队人的个数
平均服务时间(svctm)类似于收银员的收款速度
平均等待时间(await)类似于平均每人的等待时间
平均I/O数据(avgrq-sz)类似于平均每人所买的东西多少
I/O 操作率 (%util)类似于收款台前有人排队的时间比例。

我们可以根据这些数据分析出 I/O 请求的模式，以及 I/O 的速度和响应时间。

下面是别人写的这个参数输出的分析

# iostat -x 1
avg-cpu: %user %nice %sys %idle
16.24 0.00 4.31 79.44
Device: rrqm/s wrqm/s r/s w/s rsec/s wsec/s rkB/s wkB/s avgrq-sz avgqu-sz await svctm %util
/dev/cciss/c0d0
0.00 44.90 1.02 27.55 8.16 579.59 4.08 289.80 20.57 22.35 78.21 5.00 14.29
/dev/cciss/c0d0p1
0.00 44.90 1.02 27.55 8.16 579.59 4.08 289.80 20.57 22.35 78.21 5.00 14.29
/dev/cciss/c0d0p2
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00

上面的 iostat 输出表明秒有 28.57 次设备 I/O 操作: 总IO(io)/s = r/s(读) +w/s(写) = 1.02+27.55 = 28.57 (次/秒) 其中写操作占了主体 (w:r = 27:1)。

平均每次设备 I/O 操作只需要 5ms 就可以完成，但每个 I/O 请求却需要等上 78ms，为什么? 因为发出的 I/O 请求太多 (每秒钟约 29 个)，假设这些请求是同时发出的，那么平均等待时间可以这样计算:

平均等待时间 = 单个 I/O 服务时间 * ( 1 + 2 + ... + 请求总数-1) / 请求总数

应用到上面的例子: 平均等待时间 = 5ms * (1+2+...+28)/29 = 70ms，和 iostat 给出的78ms 的平均等待时间很接近。这反过来表明 I/O 是同时发起的。

每秒发出的 I/O 请求很多 (约 29 个)，平均队列却不长 (只有 2 个 左右)，这表明这 29 个请求的到来并不均匀，大部分时间 I/O 是空闲的。

一秒中有 14.29% 的时间 I/O 队列中是有请求的，也就是说，85.71% 的时间里 I/O 系统无事可做，所有 29 个 I/O 请求都在142毫秒之内处理掉了。

delta(ruse+wuse)/delta(io) = await = 78.21 => delta(ruse+wuse)/s =78.21 * delta(io)/s = 78.21*28.57 = 2232.8，表明每秒内的I/O请求总共需要等待2232.8ms。所以平均队列长度应为 2232.8ms/1000ms = 2.23，而 iostat 给出的平均队列长度 (avgqu-sz) 却为 22.35，为什么?! 因为 iostat 中有 bug，avgqu-sz 值应为 2.23，而不是 22.35。

今天意外的碰到了这个blog系统的错误，提示信息如下。
竟然把sql给爆出来了。有意思。

mysql经常会出现这类错误信息。最好是关掉为好。暴露了sql语句，容易让别人钻空子的。


SupeSite info: MySQL Query Error

User: sihanjishu
Time: 2009-2-20 1:10pm
Script: /index.php

SQL: SELECT profile_1, profile_2, profile_3, profile_4, profile_5, profile_6, profile_7, profile_8, profile_9, profile_10, profile_11, profile_12, profile_13, profile_14, profile_15, profile_16, profile_17, profile_18, profile_19, profile_20, profile_21, profile_22, profile_23, profile_24, profile_25, profile_26, profile_27, profile_28, profile_29 FROM [Table]userfields WHERE uid='159438'
Error: Unknown column 'profile_1' in 'field list'
Errno.: 1054

631     2009-02-08 01:12 = huangysh
632     2009-02-08 01:34 a huangysh
633     2009-02-08 01:56 a huangysh
634     2009-02-08 02:18 a huangysh
635     2009-02-08 02:40 a huangysh
636     2009-02-08 03:02 a huangysh
637     2009-02-08 03:24 a huangysh
638     2009-02-08 03:46 a huangysh
639     2009-02-08 04:08 a huangysh
640     2009-02-08 14:00 a huangysh
641     2009-02-08 14:22 a huangysh
642     2009-02-08 14:44 a huangysh
643     2009-02-08 15:06 a huangysh
644     2009-02-08 15:28 a huangysh
645     2009-02-08 15:50 a huangysh
646     2009-02-08 16:12 a huangysh
647     2009-02-08 16:34 a huangysh
648     2009-02-08 16:56 a huangysh
649     2009-02-08 17:18 a huangysh
650     2009-02-08 17:40 a huangysh
651     2009-02-08 18:02 a huangysh
652     2009-02-08 18:24 a huangysh
653     2009-02-08 18:46 a huangysh
654     2009-02-08 19:08 a huangysh

可怜啊，公司的服务器。
利用服务器空闲的时候，我一直在做一些测试。短短一个星期。
定时任务的序号已经排到了600多。
利用自己写的脚本，我添加了N多的测试任务。
去验证测试工具，验证某些服务的性能。
数据收集了不少，分析了一下，感觉自己对公司的性能测试的工具已经比较熟悉了。
对服务器的负载曲线图也终于可以了如指掌了。

还没有太好的测试工具，不同的工具，同样的服务，测试出来的结果却各有差距。哎。
部分工具是用c写的。我想用ruby或者python去模拟一下，自己去写一个工具。
因为ruby或者python的特性，代码肯定会精简不少。
然后使用自己写的工具，可以在测试的时候，插入额外的请求，来判断处于压力状态下的服务的性能和响应时间等指标。就像探针一样。

不少人担心ruby和python的效率。其实运行的时候，差别是很小很小的。人们感觉他们慢，是因为启动的时候，有明显的延迟，而实际上，运行时的速度是丝毫不逊色的。

另外，在http://chinaonrails.com/topic/view/903.html 上发现了更多的测试工具。
我打算使用工作之余的时间，慢慢试验他们。得出数据，参考一下。然后确定一款合适的工具，
总结好测试的策略。
彻底的消灭掉测试中发现的问题。

接到了一系列的通知。
全面转向ruby。
看了一天，发现ruby的确有不少闪光点。
这下不用担心了，ruby了。不迟疑了。
以后还要研究watir。

努力工作了很久，终于因为春节而可以告一段落了。
总结一下吧。

这半年，因为接触新的领域，比较兴奋。一直疯狂先前冲。在技术上，开始有点深度了。

技术方面：
首先学习了shell两个月。然后总结了一个函数库，把常用的操作都封装在里面了。
把一个简单的测试工具执行的过程进行了很大的扩展。可以定时执行，批量执行，结果汇总和分析，自动发送结果邮件到工作信箱，而且把手机提醒也加上了，后来想想真汗，有点过分了。

把工作流程优化了一下。把大量的手工操作给自动化了。
另外，利用shell的优势，对一些性能测试的工具进行了试验。
因为工作中遇到了对这些工具的疑问，自己就干脆利用空余时间做了很多组的测试。
这些测试，以前是通过手工根本无法实现的。不过有了shell的脚本自动化辅助，就非常的高效了。

一点一滴的帮助大家学习shell，推广我写的那个函数库。
是同事鼓励我推广的，看到能给大家带来帮助，还是非常兴奋的。

然后继续学习python，还好，在项目组用到了。还利用它解决了很多的问题。帮助同事写了一些程序。比如发送html格式邮件，实时汇报自动化测试结果等等。


项目方面：
做了几个项目。感觉自己在慢慢成熟。自己做项目很小心。本来我是个很马虎的人。不过，在同事中，还是得到了一个细心谨慎的称谓。主要是我在工作中投入的精力比别人多。

团队方面：
当上了别人的buddy，带一位新同事。这个任务只是刚开始而已。
辅助同事学习新技术。分享自己的收获和心得。

交际方面：
空白




没有什么成就，不过自己在慢慢成长。虽然自己还是依旧穷困潦倒，但是自己的能力还是在工作中得到了肯定。
下年就要开始正式在工作中，把自己的能力全释放出来。


工作中需要注意的几个问题
1、技术上不要冲的太猛，这行会给同事无形之中增加很多的压力。
2、不要显露自己的全部能力，尽量不要让同事产生嫉妒心理。要谨慎。
3、不要对自己要求太高。自己太追求完美了。可能导致别人不屑。脱离项目需求。
4、沟通谨慎，不要让领导和同事产生什么误解。与同事和领导的关系压倒一切。这是团队工作之本。


下年的工作计划

1、转正。
2、帮团队获得荣誉，首先确保辅助自己敬佩的几个同事拿到奖项。
3、参加培训，想办法升级。想办法提升工资。自己快穷死啦。

生活方面
1、还清信用卡的欠款。摆脱资不抵债的困境。
2、开始交际，加入志愿者协会。参加基督教会活动。健身，练吉他
3、找女朋友


技术领域
1、深入python
2、熟练shell和精通linux，包括ubuntu，aix，unix，salaries。
3、学习ruby
4、研究sql injection 和xss
5、一心学习英语

经过了一段时间的学习，还有在项目中的使用。已经深深的喜欢上它了。
经过了几个月的积累，我的函数库已经足够强大了。
现在自己的效率已经是同事的N倍了。越来越多的任务，开始使用shell去自动化完成了。

让自己自豪的一件事情，就是当初我决定编写自己的函数库。当初的决定，让自己受用匪浅。
同事发现后，感觉挺好，就鼓励我推广一下。现在已经开始教同事学习shell。
呵呵，小小的成就，庆祝一下。

那个函数库，的确花费了自己不少的心血。搜索了很多资料，一点一滴的改进，才到了今天这个地步。
现在同事感到很有用，我还是非常欣慰的。
这一年，主要是为同事做事，下一年开始我就要专心为自己的发展着想了。
同事都转正了，就剩下我还没有转正。好伤心。
努力做好吧，不做最好，就离开。
暂时还不想离开这个岗位。公司的环境挺好，喜欢那种氛围。

比较了N久 python和ruby。转了一个大圈，又重新回到了原地。
接到领导的指示，我要参与自动化项目。
不幸的是，那个项目是基于ruby的。
说实话，使用ruby去做系统管理类的自动化，肯定是蹩脚的。
ruby优秀，它的成名很大部分是靠ror的。现在大部分应用，也是基于web的。
关于web开发的书挺多的，关于系统管理的，肯定就没有perl和python多了。

从年会上看，公司里也有项目组，把watir扩展了。watir貌似是ruby写的。如果没有记错的话。
看来我是不能专心学习python了。

这些天利用早晨坐车的时间，看完了《python核心编程》。这本书非常棒，对python介绍的比较相信。
不过面向对象那一个章节写的就有点混乱。也可能是我没有看下去。
从里面学到了很多的python的东西。明白了很多。以前读英文版的《python in a nutshell》
感觉太生硬了，没有一个感性的认识。现在终于可以说，对python已经没有大问题了。

前些天，公司的一个项目遇到了编码问题。
就是一个网站，使用的是gbk编码，保存的日志。另一个网站用utf8编码保存的日志。
我获得了其中一个网站的访问日志数据，需要解码后去访问另一个网站。
研究了一下，使用python解决了。
流程貌似挺绕，
url解码--gbk解码--utf8编码---url编码
使用python一下子就搞定了。

不要再折腾了。两样都学啦。省的自己再犹豫。
ruby用于做项目，python作为自己的日常使用语言。

在程序不寻常退出时，内核会在当前工作目录下生成一个core文件（是一个内存映像，同时加上调试信息）。使用gdb来查看core文件，可以指示出导致程序出错的代码所在文件和行数。

1.core文件的生成开关和大小限制
---------------------------------
 1）使用ulimit -c命令可查看core文件的生成开关。若结果为0，则表示关闭了此功能，不会生成core文件。
 2） 使用ulimit -c filesize命令，可以限制core文件的大小（filesize的单位为kbyte）。若ulimit -c unlimited，则表示core文件的大小不受限制。如果生成的信息超过此大小，将会被裁剪，最终生成一个不完整的core文件。在调试此core文 件的时候，gdb会提示错误。

2.core文件的名称和生成路径
----------------------------
core文件生成路径:
输入可执行文件运行命令的同一路径下。
若系统生成的core文件不带其它任何扩展名称，则全部命名为core。新的core文件生成将覆盖原来的core文件。

1）/proc/sys/kernel/core_uses_pid可以控制core文件的文件名中是否添加pid作为扩展。文件内容为1，表示添加pid作为扩展名，生成的core文件格式为core.xxxx；为0则表示生成的core文件同一命名为core。
可通过以下命令修改此文件：
echo "1" > /proc/sys/kernel/core_uses_pid

2）proc/sys/kernel/core_pattern可以控制core文件保存位置和文件名格式。
可通过以下命令修改此文件：
echo "/corefile/core-%e-%p-%t" > core_pattern，可以将core文件统一生成到/corefile目录下，产生的文件名为core-命令名-pid-时间戳
以下是参数列表:
    %p - insert pid into filename 添加pid
    %u - insert current uid into filename 添加当前uid
    %g - insert current gid into filename 添加当前gid
    %s - insert signal that caused the coredump into the filename 添加导致产生core的信号
    %t - insert UNIX time that the coredump occurred into filename 添加core文件生成时的unix时间
    %h - insert hostname where the coredump happened into filename 添加主机名
    %e - insert coredumping executable name into filename 添加命令名

 

3.core文件的查看
-----------------
 core文件需要使用gdb来查看。
 gdb ./a.out
 core-file core.xxxx
 使用bt命令即可看到程序出错的地方。
以下两种命令方式具有相同的效果，但是在有些环境下不生效，所以推荐使用上面的命令。
1）gdb -core=core.xxxx
file ./a.out
bt
2）gdb -c core.xxxx
file ./a.out
bt

4.开发板上使用core文件调试
-----------------------------
如果开发板的操作系统也是linux，core调试方法依然适用。如果开发板上不支持gdb，可将开发板的环境（依赖库）、可执行文件和core文件拷贝到PC的linux下。
在 PC上调试开发板上产生的core文件，需要使用交叉编译器自带的gdb，并且需要在gdb中指定solib-absolute-prefix和 solib-search-path两个变量以保证gdb能够找到可执行程序的依赖库路径。有一种建立配置文件的方法，不需要每次启动gdb都配置以上变 量，即：在待运行gdb的路径下建立.gdbinit。
配置文件内容：
set solib-absolute-prefix YOUR_CROSS_COMPILE_PATH
set solib-search-path YOUR_CROSS_COMPILE_PATH
set solib-search-path YOUR_DEVELOPER_TOOLS_LIB_PATH
handle SIG32 nostop noprint pass

注意：待调试的可执行文件，在编译的时候需要加-g，core文件才能正常显示出错信息！有时候core信息很大，超出了开发板的空间限制，生成的core信息会残缺不全而无法使用，可以通过挂载到PC的方式来规避这一点。

很全~
目录(Contents)

1. awk简介
2. awk命令格式和选项
    2.1. awk的语法有两种形式
    2.2. 命令选项
3. 模式和操作
    3.1. 模式
    3.2. 操作
4. awk的环境变量
5. awk运算符
6. 记录和域
    6.1. 记录
    6.2. 域
    6.3. 域分隔符
7. gawk专用正则表达式元字符
8. POSIX字符集
9. 匹配操作符(~)
10. 比较表达式
11. 范围模板
12. 一个验证passwd文件有效性的例子
13. 几个实例
14. awk编程
     14.1. 变量
     14.2. BEGIN模块
     14.3. END模块
     14.4. 重定向和管道
     14.5. 条件语句
     14.6. 循环
     14.7. 数组
     14.8. awk的内建函数
15. How-to




正文


1. awk简介
      awk 是一种编程语言，用于在linux/unix下对文本和数据进行处理。数据可以来自标准输入、一个或多个文件，或其它命令的输出。它支持用户自定义函数和 动态正则表达式等先进功能，是linux/unix下的一个强大编程工具。它在命令行中使用，但更多是作为脚本来使用。awk的处理文本和数据的方式是这 样的，它逐行扫描文件，从第一行到最后一行，寻找匹配的特定模式的行，并在这些行上进行你想要的操作。如果没有指定处理动作，则把匹配的行显示到标准输出 (屏幕)，如果没有指定模式，则所有被操作所指定的行都被处理。awk分别代表其作者姓氏的第一个字母。因为它的作者是三个人，分别是Alfred Aho、Brian Kernighan、Peter Weinberger。gawk是awk的GNU版本，它提供了Bell实验室和GNU的一些扩展。下面介绍的awk是以GUN的gawk为例的，在 linux系统中已把awk链接到gawk，所以下面全部以awk进行介绍。



2. awk命令格式和选项
      2.1. awk的语法有两种形式

awk [options] 'scrīpt' var=value file(s)

awk [options] -f scrīptfile var=value file(s)

      2.2. 命令选项

-F fs or --field-separator fs 指定输入文件折分隔符，fs是一个字符串或者是一个正则表达式，如-F:。 -v var=value or --asign var=value 赋值一个用户定义变量。 -f scripfile or --file scrīptfile 从脚本文件中读取awk命令。 -mf nnn and -mr nnn 对nnn值设置内在限制，-mf选项限制分配给nnn的最大块数目；-mr选项限制记录的最大数目。这两个功能是Bell实验室版awk的扩展功能，在标准awk中不适用。 -W compact or --compat, -W traditional or --traditional 在兼容模式下运行awk。所以gawk的行为和标准的awk完全一样，所有的awk扩展都被忽略。 -W copyleft or --copyleft, -W copyright or --copyright 打印简短的版权信息。 -W help or --help, -W usage or --usage 打印全部awk选项和每个选项的简短说明。 -W lint or --lint 打印不能向传统unix平台移植的结构的警告。 -W lint-old or --lint-old 打印关于不能向传统unix平台移植的结构的警告。 -W posix 打开兼容模式。但有以下限制，不识别：\x、函数关键字、func、换码序列以及当fs是一个空格时，将新行作为一个域分隔符；操作符**和**=不能代替^和^=；fflush无效。 -W re-interval or --re-inerval 允许间隔正则表达式的使用，参考(grep中的Posix字符类)，如括号表达式[[:alpha:]]。 -W source program-text or --source program-text 使用program-text作为源代码，可与-f命令混用。 -W version or --version 打印bug报告信息的版本。

3. 模式和操作
       awk脚本是由模式和操作组成的：

pattern {action} 如$ awk '/root/' test，或$ awk '$3 < 100' test

      两者是可选的，如果没有模式，则action应用到全部记录，如果没有action，则输出匹配全部记录。默认情况下，每一个输入行都是一条记录，但用户可通过RS变量指定不同的分隔符进行分隔。

     3.1. 模式
     模式可以是以下任意一个：
     /正则表达式/：使用通配符的扩展集。
     关系表达式：可以用下面运算符表中的关系运算符进行操作，可以是字符串或数字的比较，如$2>%1选择第二个字段比第一个字段长的行。
     模式匹配表达式：用运算符~(匹配)和~!(不匹配)。
     模式，模式：指定一个行的范围。该语法不能包括BEGIN和END模式。
     BEGIN：让用户指定在第一条输入记录被处理之前所发生的动作，通常可在这里设置全局变量。
     END：让用户在最后一条输入记录被读取之后发生的动作。
   3.2. 操作
    操作由一人或多个命令、函数、表达式组成，之间由换行符或分号隔开，并位于大括号内。主要有四部份：
    变量或数组赋值
    输出命令
    内置函数
    控制流命令
4. awk的环境变量
Table 1. awk的环境变量

变量	描述
$n	当前记录的第n个字段，字段间由FS分隔。
$0	完整的输入记录。
ARGC	命令行参数的数目。
ARGIND	命令行中当前文件的位置(从0开始算)。
ARGV	包含命令行参数的数组。
CONVFMT	数字转换格式(默认值为%.6g)
ENVIRON	环境变量关联数组。
ERRNO	最后一个系统错误的描述。
FIELDWIDTHS	字段宽度列表(用空格键分隔)。
FILENAME	当前文件名。
FNR	同NR，但相对于当前文件。
FS	字段分隔符(默认是任何空格)。
IGNORECASE	如果为真，则进行忽略大小写的匹配。
NF	当前记录中的字段数。
NR	当前记录数。
OFMT	数字的输出格式(默认值是%.6g)。
OFS	输出字段分隔符(默认值是一个空格)。
ORS	输出记录分隔符(默认值是一个换行符)。
RLENGTH	由match函数所匹配的字符串的长度。
RS	记录分隔符(默认是一个换行符)。
RSTART	由match函数所匹配的字符串的第一个位置。
SUBSEP	数组下标分隔符(默认值是\034)。

5. awk运算符
Table 2. 运算符

运算符	描述
= += -= *= /= %= ^= **=	赋值
?:	C条件表达式
||	逻辑或
&&	逻辑与
~ ~!	匹配正则表达式和不匹配正则表达式
< <= > >= != ==	关系运算符
空格	连接
+ -	加，减
* / &	乘，除与求余
+ - !	一元加，减和逻辑非
^ ***	求幂
++ --	增加或减少，作为前缀或后缀
$	字段引用
in	数组成员

6. 记录和域
   6.1. 记录
     awk把每一个以换行符结束的行称为一个记录。
     记录分隔符：默认的输入和输出的分隔符都是回车，保存在内建变量ORS和RS中。
     $0变量：它指的是整条记录。如$ awk '{print $0}' test将输出test文件中的所有记录。
     变量NR：一个计数器，每处理完一条记录，NR的值就增加1。如$ awk '{print NR,$0}' test将输出test文件中所有记录，并在记录前显示记录号。
  6.2. 域
     记录中每个单词称做“域”，默认情况下以空格或tab分隔。awk可跟踪域的个数，并在内建变量NF中保存该值。如$ awk '{print $1,$3}' test将打印test文件中第一和第三个以空格分开的列(域)。
    6.3. 域分隔符
     内建变量FS保存输入域分隔符的值，默认是空格或tab。我们可以通过-F命令行选项修改FS的值。如$ awk -F: '{print $1,$5}' test将打印以冒号为分隔符的第一，第五列的内容。
     可以同时使用多个域分隔符，这时应该把分隔符写成放到方括号中，如$awk -F'[:\t]' '{print $1,$3}' test，表示以空格、冒号和tab作为分隔符。
     输出域的分隔符默认是一个空格，保存在OFS中。如$ awk -F: '{print $1,$5}' test，$1和$5间的逗号就是OFS的值。
7. gawk专用正则表达式元字符
     一般通用的元字符集就不讲了，可参考我的Sed和Grep学习笔记。以下几个是gawk专用的，不适合unix版本的awk。
\Y
匹配一个单词开头或者末尾的空字符串。
\B
匹配单词内的空字符串。
\<
匹配一个单词的开头的空字符串，锚定开始。
\>
匹配一个单词的末尾的空字符串，锚定末尾。
\w
匹配一个字母数字组成的单词。
\W
匹配一个非字母数字组成的单词。
\‘
匹配字符串开头的一个空字符串。
\'
匹配字符串末尾的一个空字符串。
8. POSIX字符集
待完善
9. 匹配操作符(~)
用来在记录或者域内匹配正则表达式。如$ awk '$1 ~/^root/' test将显示test文件第一列中以root开头的行。
10. 比较表达式

conditional expression1 ? expression2: expression3

例如：

$ awk '{max = {$1 > $3} ? $1: $3: print max}' test

如果第一个域大于第三个域，$1就赋值给max，否则$3就赋值给max。

$ awk '$1 + $2 < 100' test

如果第一和第二个域相加大于100，则打印这些行。

$ awk '$1 > 5 && $2 < 10' test

如果第一个域大于5，并且第二个域小于10，则打印这些行。
11. 范围模板
范围模板匹配从第一个模板的第一次出现到第二个模板的第一次出现之间所有行。如果有一个模板没出现，则匹配到开头或末尾。如$ awk '/root/,/mysql/' test将显示root第一次出现到mysql第一次出现之间的所有行。
12. 一个验证passwd文件有效性的例子

$ cat /etc/passwd | awk -F: '\ NF != 7{\ printf("line %d,does not have 7 fields:%s\n",NR,$0)}\ $1 !~ /[A-Za-z0-9]/{printf("line %d,non alpha and numeric user id:%d: %s\n,NR,$0)}\ $2 == "*" {printf("line %d, no password: %s\n",NR,$0)}'

cat把结果输出给awk，awk把域之间的分隔符设为冒号。
如果域的数量(NF)不等于7，就执行下面的程序。
printf打印字符串"line ?? does not have 7 fields"，并显示该条记录。
如果第一个域没有包含任何字母和数字，printf打印“no alpha and numeric user id" ，并显示记录数和记录。
如果第二个域是一个星号，就打印字符串“no passwd”，紧跟着显示记录数和记录本身。
13. 几个实例
打印所有以模式no或so开头的行。

$ awk '/^(no|so)/' test

如果记录以n或s开头，就打印这个记录。

$ awk '/^[ns]/{print $1}' test

如果第一个域以两个数字结束就打印这个记录。

$ awk '$1 ~/[0-9][0-9]$/(print $1}' test

如果第一个或等于100或者第二个域小于50，则打印该行。

$ awk '$1 == 100 || $2 < 50' test

如果第一个域不等于10就打印该行。

$ awk '$1 != 10' test

如果记录包含正则表达式test，则第一个域加10并打印出来。

$ awk '/test/{print $1 + 10}' test

如果第一个域大于5则打印问号后面的表达式值，否则打印冒号后面的表达式值。

$ awk '{print ($1 > 5 ? "ok "$1: "error"$1)}' test

打印以正则表达式root开头的记录到以正则表达式mysql开头的记录范围内的所有记录。如果找到一个新的正则表达式root开头的记录，则继续打印直到下一个以正则表达式mysql开头的记录为止，或到文件末尾。

$ awk '/^root/,/^mysql/' test

14. awk编程
14.1. 变量
在awk中，变量不需要定义就可以直接使用，变量类型可以是数字或字符串。
赋值格式：

Variable = expression，如$ awk '$1 ~/test/{count = $2 + $3; print count}' test

上式的作用是,awk先扫描第一个域，一旦test匹配，就把第二个域的值加上第三个域的值，并把结果赋值给变量count，最后打印出来。
      awk可以在命令行中给变量赋值，然后将这个变量传输给awk脚本。如

$ awk -F: -f awkscrīpt month=4 year=2004 test

上式的month和year都是自定义变量，分别被赋值为4和2004。在awk脚本中，这些变量使用起来就象是在脚本中建立的一样。注意，如果参数前面出现test，那么在BEGIN语句中的变量就不能被使用。
      域变量也可被赋值和修改，如

$ awk '{$2 = 100 + $1; print }' test

上式表示，如果第二个域不存在，awk将计算表达式100加$1的值，并将其赋值给$2，如果第二个域存在，则用表达式的值覆盖$2原来的值。再例如：

$ awk '$1 == "root"{$1 ="test";print}' test

如果第一个域的值是“root”，则把它赋值为“test”，注意，字符串一定要用双引号。
      内建变量的使用。变量列表在前面已列出，现在举个例子说明一下。

$ awk -F: '{IGNORECASE=1; $1 == "MARY"{print NR,$1,$2,$NF}'test

把IGNORECASE设为1代表忽略大小写，打印第一个域是mary的记录数、第一个域、第二个域和最后一个域。