在分析MySQL Semi-sync故障时，我们用Tcpdump+Wireshark（感谢淘宝雕梁）抓住当时的网络包传送细节，观察到了一次TCP重传最终导致了Semi-sync超时：

第一次传输
13:55:11.893291 master => slave	Binlog pos:319890197
重传：
13:55:12.094596	master => slave	Binlog pos:319890197

看到两次传送间隔约201毫秒，即第一次传输201毫秒后，还没有收到ACK响应，TCP认为传输超时，开始重传。

疑问：host和host之间的RTT大约是0.5毫秒，为什么第一次重传需要等200毫秒？（我希望是<20ms）socket程序可以配置吗RTO吗？TCP有参数可配置RTO吗？

翻开TCP/IP详解找到关于TCP Retransmission章节，较详细的介绍TCP的超时机制，书中是个概述，于是又找到RFC1122。

RFC1122的4.2.2.15和4.2.3.1都介绍了Retransmission Timeout的处理（说来惭愧，这是第一次阅读TCP相关RFC）。

在RFC中搜索Retransmission发现RFC 793 1122 2988 6298都有对重传算法、和初次重传超时的描述。于是开始阅读这个四个RFC，耗时约2小时，了解了大致的重传超时算法。

概述：先根据该socket的RTT计算出SRTT（Smoothed Round Trip Time），然后根据一个最大、最小超时时间确定当前RTO。说明：srtt可以理解为“平滑化”的RTT，即在保持计算简单的情况尽量考虑历史RTT。

详细计算：SRTT = ( ALPHA * SRTT ) + ((1-ALPHA) * RTT)

基于SRTT，我们再来计算RTO：RTO = min[UBOUND,max[LBOUND,(BETA*SRTT)]]

UBOUND是RTO上线，ALPHA是平滑因子（smoothing factor， e.g., .8 to .9），BETA是一个延迟方差因子（BETA is a delay variance factor (e.g., 1.3 to 2.0)）。

仔细看这两个公式大概就能理解了RTO的计算了。

这里对上面两个公式做一个简单的注释：公式1中计算SRTT，ALPHA越接近于0，则表示SRTT越相信这一次的RTT；越接近于1，则表示SRTT越相信上次统计的RTT。公式二给RTO分别设置了一个上限和下限。

上面我们介绍的是初次重传时的RTO，如果重传后还没收到另一端的响应，下一次重传RTO则会指数增加，例如第一次重传RTO是1，之后分别2，4，8，16...。

在RFC-2988和RFC-6298中又重新改进了RTO的计算方法，Linux中的实现即使参考RFC-2988。算法核心公式：

初始：
SRTT <- R
RTTVAR <- R/2
RTO <- SRTT + max (G, K*RTTVAR)
where K = 4.

根据RTT计算SRTT：
RTTVAR <- (1 - beta) * RTTVAR + beta * |SRTT - R'|
SRTT <- (1 - alpha) * SRTT + alpha * R'

最后RTO：
RTO <- SRTT + max (G, K*RTTVAR)

这里说的是RHEL5.4的2.6.18内核，RFC-2988实现参考net/ipv4/tcp_input.c中的tcp_rtt_estimator和tcp_set_rto。可以看到，在Linux中alpha=1/8，RTO最小为TCP_RTO_MIN。因为我们的系统中RTT总是很小，所以RTO取值总是能够取到TCP_RTO_MIN。

在看看TCP_RTO_MIN在Linux中的定义：

123#define TCP_RTO_MAX     ((unsigned)(120*HZ))
124#define TCP_RTO_MIN     ((unsigned)(HZ/5))

(这里简单的介绍介绍一下HZ，HZ可以理解为1s，所以120*HZ就是120秒，HZ/5就是200ms。详细的：HZ表示CPU一秒种发出多少次时间中断--IRQ-0，Linux中通常用HZ来做时间片的计算，参考)

/proc/sys/net/ipv4/tcp_retries1 (integer; default: 3)

TCP尝试了3次（tcp_retries1默认3）重传后，还没有收到ACK的话，则后续每次重传都需要network layer先更新路由。

/proc/sys/net/ipv4/tcp_retries2 (integer; default: 15)

TCP默认最多做15次重传。根据RTO(retransmission timeout)不同，最后一次重传间隔大概是13到30分钟左右。如果15次重传都做完了，TCP/IP就会告诉应用层说：“搞不定了，包怎么都传不过去！”

回答前面的问题：即使RTT很小（0.8ms），但是因为RTO有下限，最小必须是200ms，所以这是RTT再小也白搭；RTO最小值是内核编译是决定的，socket程序中无法修改，Linux TCP也没有任何参数可以改变这个值。

好了，不容易。

广告：我们寻找靠谱的人 | 感谢作者

参考文献

1. RFC 1122 ... (在哪儿查找RFC) TCP协议相关的RFC：
RFC 675 - Specification of Internet Transmission Control Program, December 1974 Version
RFC 793 - TCP v4
RFC 1122 - includes some error corrections for TCP
RFC 1323 - TCP-Extensions
RFC 1379 - Extending TCP for Transactions—Concepts
RFC 1948 - Defending Against Sequence Number Attacks
RFC 2018 - TCP Selective Acknowledgment Options
RFC 2988 - Computing TCP's Retransmission Timer
RFC 4614 - A Roadmap for TCP Specification Documents
RFC 5681 - TCP Congestion Control

z    :打开/关闭彩色显示
x    :高亮显示排序列

在使用top命令后，“先按z键，再按x键”，这时屏幕会彩色显示输出，白色显示的列是当前排序的列；偶尔还会有一些白色显示行，这些行是当前正在运行进程。使用该参数可以帮助我们更清楚的看到排序列。例如，我想按照cpu使用排序来查看进程：

使用了top-z-x命令后是不是看得清晰了一些:)

1    :SMP的系统，会单独显示各个CPU的运行状态

<    :改变排序列
>    :改变排序列

top-z-x-< 试试就知道是什么意思了:) 。例如，默认是按照cpu使用率排序的，现在我想看看安装使用的虚拟内存排序看看，使用命令top-z-x-<-<-<-<-< ：

W    :把当前配置文件到home目录下.toprc配置文件中
F or O :支持更强的选择排序列的方式

-b   :参数可以帮你在脚本中使用top命令
-n   :配合-b使用，表示重新刷新一定次数后退出
-d   :刷新延时时间。例如-d 5 表示top每隔5秒刷新一次。（默认是3秒）

就这些吧，更多请查看top-h或者RTFM。

最后，各位看官，工作之余别忘了多多运动，没什么比健康更重要了:)

使用的是RHEL5.4的系统：

安装基本工具包：rpm-build redhat-rpm-config unifdef。一般情况这三个包都是安装过的，检查一下即可。

现在的RHEL发行版中，已经不再带源码包，所以需要单独下载，供Flashcache编译使用。

可以在ftp://ftp.redhat.com/下载到对应的源码包。这里的内核版本号是：

所以需要下载的是kernel-2.6.18-164.el5.src.rpm，完整的URL是：

注：最好选择合适的镜像下载，速度会差很多的。

有了前面的目录准备，现在可以安装源码包了

OK，这时候源码包就安装到了如下目录：/home/supu/rpmbuild/BUILD/kernel-2.6.18/linux-2.6.18.x86_64

在源码目录执行如下命令，主备Flashcache模块编译

可以在github上下载Flashcache的源代码，和Linux源码一起编译，编译完成后会生成三个可执行程序和一个可动态加载的内核模块：

在在github上可以下载到Flashcache最新的源码。这里下载的是flashcache-1.0.11，解压后，有如下目录：

其中src包含了普通的Flashcache（这里的普通指的是Write-back版本的Flashcache），flashcache-wt包含了Write-Through版本的源码；文件README-CentOS5.4中包含了在RHEL5.4下编译的注意事项，本文主要参考该文件。

按照README-CentOS5.4中的说明，修改文件src/Makefile，将行EXTRA_CFLAGS（第一行），用如下内容替换：

EXTRA_CFLAGS=-I$(KERNEL_TREE)/drivers/md -I$(KERNEL_TREE)/include/linux  -I./

最后需要将模块flashcache.ko加载到内核，这里可以将flashcache.ko拷贝到相应目录：

或者使用insmod命令，动态加载之：

Job Done! Enjoy!

参考：

1. Flashcache README-CentOS5.4

2. Flashcache README

3. Redhat enterprise Linux / CentOS installing kernel source code

随着时间的流逝，网站上的数据一直在不停的积累。如果你经营的只是一个博客的话，这不会是问题，因为10G的空间，大概就够你写一辈子了（如果放在硬盘上，其实一辈子很短）。如果你恰巧在一个快速增长的公司，数据会越来越多，从MB，到GB，再到TB。

如果将这些数据全部放在大容量的SATA、SAS盘上时，会发现性能（响应时间）不够；如果全放在SSD上时，又会发现成本很高。即使公司能够大气到都放到SSD上，你会发现1TB的数据里面可能只有200G是经常被访问的，300G可能偶尔被访问到，最后剩下的500G可能已经成为历史数据了，几乎不被访问到，如果全部都放在SSD上有略有浪费。于是就有了Flashcache。

Flashcache一个非常不错的软件（准确的说是一个Linux的模块），可以动态加载。Flashcache通过在文件系统（VFS）和设备驱动之间新增了一次缓存层，来实现对热门的缓存。Flashcache是另一种缓存，一般用SSD作为介质的缓存（一般的缓存用的是内存），通过将传统硬盘上的热门数据缓存到SSD上，然后利用SSD优秀的读性能，来加速系统。这个方法较之内存缓存，没有内存快，但是空间可以比内存大很多。

本文是一个关于Flashcache的初步介绍。

数据量很大（例如4TB），热门数据也很大（800GB），不必要或者不舍得全部买内存来缓存。

数据量不大的话，一般Flashcache就没什么用武之地了，内存就可以帮你解决问题了；

不差钱，买内存呗；

另外Flashcache的加入也使得系统的复杂度增加了一层，如果你坚持KISS原则（Keep it simple, Stupid!），也可以弃用之。

上图中，Flashcache将普通的SAS盘（/dev/sda）和一个高速的SSD(/dev/sdb)虚拟成一个带缓存的块设备（/dev/mapper/cachedev）。后续还将会有更多关于Flashcache相关的文章出现，敬请期待。

对于当前，PCI接口的SSD价格还十分昂贵，而随着时间的推移，价格会降；另外，根据摩尔定律，未来会有更快的设备出现，所以Flashcache是一个“持久的”产品，还只是一个过渡软件，这并不好说。

关注未来新技术的发展吧:)

参考：

1. Facebook / Flashcache

2. Releasing Flashcache of Facebook

3. flashcache-doc.txt

PS：写完整篇文章，最大的收获是：发现人的一生其实很短、很短，可能连1GB都不到。

        "不积跬步，无以至千里"
                                 《劝学》

查看文本文件使用vim/less就足够了，但如果想要查看一些其他二进制文件（例如DB的数据文件、程序的二进制代码）则借助于od/hexdump这些工具会很方便，这里会通过一些实例来详细介绍od命令的相关参数。

$od -j 49152 -N 38 -w4 -A d -t x1 -v tmp_test.ibd
0049152 fd 6f fb 70
0049156 00 00 00 03
0049160 ff ff ff ff
0049164 ff ff ff ff
0049168 00 00 00 03
0049172 ba 92 ac 0c
0049176 45 bf 00 00
0049180 00 00 00 00
0049184 00 00 00 00

-j 49152 跳过前49152个字节（bytes）

-N 38 仅显示38个字节

-w4 每一行显示4个字节

-A d 表示最左侧的偏移量按十进制显示；-A还可以接[doxn]，其中d表示十进制，o表示8进制，x表示16进制，n表示不显示该偏移量，如：

od -j 49152 -N 8 -w4 -A n -t x1 -v ibdata1
 b4 0b c7 31
 00 00 00 03

-t x1表示如何显示文件内容。这里，x表示按照16进制输出文件内容，x后面跟的“1”表示一次显示一个字节。下面是一个-t x2的输出：

od -j 49152 -N 8 -w4 -A n -t x2 -v ibdata1
 0bb4 31c7    # 0bb4是十进制表示的两个字节
 0000 0300    #

另外，注意到这里是0bb4和前面的b40b略有不同，这是因为我这里的测试平台是little-endian的（x86_64 Linux）。

最后，参数-v表示，即使连续多行都是完全相同的字符0，仍然原样输出；不加该参数，则会使用星号（*）跳过多个相同的行。

好了，再回头看看最前面的命令，已经没那么难理解了吧。

参考文献：man od

进入该状态的进程，会一直等待NFS，不接受任何信号，当然也就无法被杀死（kill/fuser -k）。因为进程一直在运行队列（running queue）中，所以还会导致主机的Load上升（虽然主机并不繁忙）。如果由于这个原因被卡住的进程很多的话，主机的Load可能会看起来非常高。

上次出现这个问题时只有一台主机出了这个症状，当时Google后也注意到很多人有遇到了类似的问题，并且都束手无策(There are some things even root can't do)。Google后，再尝试找了一些Linux原理方面的介绍，依然无解。

解决的终极办法是重启主机（reboot），所以决定等待一段时间（之前遇到过一些僵死进程Z，等待一段时间后也消失了），实在不行就择机重启主机。不过奇怪的是，等了几天过后，这个进程确实消失了（正常结束了？应该是）。

1. Why is Linux so "stupid"?

有人就问，Linux设计是不是有问题，为什么会有一些进程root也无法杀死呢？

jra在How to kill a process in uninterruptible sleep state中给了一个解释：

    There's fairly extensive discussion of this in a couple of the kernel
design books, and I think in Nemeth, Snyder and Seebass: the problem stems
from the fact that there are two types of device drivers -- those
for "fast" devices and those for "slow" devices：

    Slow-device drivers -- for things like terminals, and such -- are
                usually split in two pieces, and can therefore be
                interrupted while they're in the middle of something.

    Fast-device drivers -- which service things like hard drives and (I
                think) ethernet cards -- are designed to expect that
                when they call out to hardware, it will respond  instantly
                (in human terms), and that they won't have to wait
                on anything. Such drivers have, as a rule, proven
                extremely intolerant of hardware trouble -- if your hard
                drive start having to do hardware retries to read a
                sector, your system perfromance is going int he toilet,
                even if you have more than one drive...

大概意思是说，Linux中设备驱动程序可以分为“slow device”和“fast device”两类。磁盘属于“fast device”（如果当作“slow device”处理效率会很低），在这类设备上操作时会以uninterruptible的方式进行。

2. 真的没办法吗?

理论上，除了重启主机，貌似没什么办法了。不过，根据实际经验和运气，也还是有一些办法可以尝试的。

办法1：umount -f

如果是由于NFS故障导致的，可以尝试使用先umount/mount重新挂载NFS。如果NFS无法卸载（如果遇到上述情况，八成是这样），可以尝试使用 -f 参数卸载。最近一次遇到这个故障，有接近上百台主机出现这个故障，就是使用umount -f成功卸载NFS后，相关uninterruptible的进程也都随之正常结束。当时发现，连续重试多次 umount -f 才行：

办法2：等

最早mysqldump遇到这个问题时，束手无策后，就等了几天，发现进程确实结束了。所以如果情况不是很紧急，“等”也是一个办法。

遇到的僵死进程这个办法也可能有效。

办法3：killall -KILL rpciod

在一篇文章中，还提到，进程处于uninterruptible sleep(即ps的D状态)，进程处于rpc_execute调用状态，而rpc_execute调用是由rpciod提供，所以可以通过杀死rpciod来解决问题。（rpciod被杀死后会自动重启过来）【没有实验过，慎用，希望有经验者分享一下】

办法4：reboot

实在不行，就只能reboot了。这是最不推荐的做法，毕竟每次遇到都reboot，代价还是比较大，特别是当你在追求HA的时候。

3. 能够避免这种情况吗?

在RTFM之后，发现可以通过挂载NFS时指定一些参数，尽可能的避免这个问题：

     soft       If an NFS file operation has a major timeout then report
                 an I/O error to the calling program.  The default is  to
                 continue retrying NFS file operations indefinitely.

      hard       If an NFS file operation has a major timeout then report
                 "server not responding"  on  the  console  and  continue
                 retrying indefinitely.  This is the default.

      intr       If  an  NFS file operation has a major timeout and it is
                 hard mounted, then allow signals to  interupt  the  file
                 operation  and  cause  it to return EINTR to the calling
                 program.  The default is to not allow file operations to
                 be interrupted.

上面3个参数，其中hard是默认的。我们通过断开网络模拟NFS故障，测试了 intr 选项，发现能够一定程度上避免上述的情况。在测试 soft 选项时，并没有上面描述的那么好用，在实验中，使用 soft 挂载是现象和 hard 类似（不知道我是不是忽略哪些细节了）。

如果你被这个问题困扰，可以试试使用intr参数挂载NFS：

参考文献
[1]. Linux Man
[2]. How to kill a process in uninterruptible sleep state
[3]. Linux: Killing Tasks On Frozen NFS Mounts
[4]. How to kill a process in uninterruptible sleep state
[5]. 如何杀掉由NFS造成Uninterruptible的进程

简单的脚本处理，一般使用变量$0 $1 $2 ...就可以依次获得全部参数，还可以通过$#获得这个脚本一共有多少个参数。如果你需要处理的情况（或者分支）更多的时候，这个方法就不凑效了，这时候，就可以考虑使用getopts了（man getopts）。

这里将通过一个示例来介绍getopts的用法。

下面的代码，可以通过"./sample -d 5"的方式获取参数：

vi sample.sh
#!/bin/sh
day=7  #default value
while getopts ":d:" opt; do
  case $opt in
    d)
      day=$OPTARG   #get the value
      ;;
    ?)
      echo "How to use: $0 [-d DAY]" >&2
      exit 1
      ;;
    :)
      echo "Option -$OPTARG requires an argument." >&2
      exit 1
      ;;
  esac
done
echo $day

上面例子中需要解释的是下面的部分：

while getopts ":d:" opt; do

这里，第一个冒号表示忽略错误（例如出现了不认识的参数），并在脚本中通过::)来处理这样的错误；字母d则表示，接受参数-d；d后面的冒号表示参数d接收值，即“-d 7”这样的形式；（这里opt变量，可以在while循环中引用当前找到的参数，试试输出$opt试试）

如果是要有很多参数，那么写法可能是：

while getopts ":ixarm:uneh" opt; do

1. 基本使用

$iostat -d -k 1 10

参数 -d 表示，显示设备（磁盘）使用状态；-k某些使用block为单位的列强制使用Kilobytes为单位；1 10表示，数据显示每隔1秒刷新一次，共显示10次。

$iostat -d -k 1 10
Device:            tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn
sda              39.29        21.14         1.44  441339807   29990031
sda1              0.00         0.00         0.00       1623        523
sda2              1.32         1.43         4.54   29834273   94827104
sda3              6.30         0.85        24.95   17816289  520725244
sda5              0.85         0.46         3.40    9543503   70970116
sda6              0.00         0.00         0.00        550        236
sda7              0.00         0.00         0.00        406          0
sda8              0.00         0.00         0.00        406          0
sda9              0.00         0.00         0.00        406          0
sda10            60.68        18.35        71.43  383002263 1490928140

Device:            tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn
sda             327.55      5159.18       102.04       5056        100
sda1              0.00         0.00         0.00          0          0

tps：该设备每秒的传输次数（Indicate the number of transfers per second that were issued to the device.）。“一次传输”意思是“一次I/O请求”。多个逻辑请求可能会被合并为“一次I/O请求”。“一次传输”请求的大小是未知的。

kB_read/s：每秒从设备（drive expressed）读取的数据量；kB_wrtn/s：每秒向设备（drive expressed）写入的数据量；kB_read：读取的总数据量；kB_wrtn：写入的总数量数据量；这些单位都为Kilobytes。

上面的例子中，我们可以看到磁盘sda以及它的各个分区的统计数据，当时统计的磁盘总TPS是39.29，下面是各个分区的TPS。（因为是瞬间值，所以总TPS并不严格等于各个分区TPS的总和）

2. -x 参数

使用-x参数我们可以获得更多统计信息。

iostat -d -x -k 1 10
Device:    rrqm/s wrqm/s   r/s   w/s  rsec/s  wsec/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await  svctm  %util
sda          1.56  28.31  7.80 31.49   42.51    2.92    21.26     1.46     1.16     0.03    0.79   2.62  10.28
Device:    rrqm/s wrqm/s   r/s   w/s  rsec/s  wsec/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await  svctm  %util
sda          2.00  20.00 381.00  7.00 12320.00  216.00  6160.00   108.00    32.31     1.75    4.50   2.17  84.20

rrqm/s：每秒这个设备相关的读取请求有多少被Merge了（当系统调用需要读取数据的时候，VFS将请求发到各个FS，如果FS发现不同的读取请求读取的是相同Block的数据，FS会将这个请求合并Merge）；wrqm/s：每秒这个设备相关的写入请求有多少被Merge了。

rsec/s：每秒读取的扇区数；wsec/：每秒写入的扇区数。r/s：The number of read requests that were issued to the device per second；w/s：The number of write requests that were issued to the device per second；

await：每一个IO请求的处理的平均时间（单位是微秒毫秒）。这里可以理解为IO的响应时间，一般地系统IO响应时间应该低于5ms，如果大于10ms就比较大了。

%util：在统计时间内所有处理IO时间，除以总共统计时间。例如，如果统计间隔1秒，该设备有0.8秒在处理IO，而0.2秒闲置，那么该设备的%util = 0.8/1 = 80%，所以该参数暗示了设备的繁忙程度。一般地，如果该参数是100%表示设备已经接近满负荷运行了（当然如果是多磁盘，即使%util是100%，因为磁盘的并发能力，所以磁盘使用未必就到了瓶颈）。

3. -c 参数

iostat还可以用来获取cpu部分状态值：

iostat -c 1 10
avg-cpu:  %user   %nice    %sys %iowait   %idle
           1.98    0.00    0.35   11.45   86.22
avg-cpu:  %user   %nice    %sys %iowait   %idle
           1.62    0.00    0.25   34.46   63.67

4. 常见用法

$iostat -d -k 1 10        #查看TPS和吞吐量信息
iostat -d -x -k 1 10      #查看设备使用率（%util）、响应时间（await）
iostat -c 1 10            #查看cpu状态

5. 实例分析

$$iostat -d -k 1 |grep sda10
Device:            tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn
sda10            60.72        18.95        71.53  395637647 1493241908
sda10           299.02      4266.67       129.41       4352        132
sda10           483.84      4589.90      4117.17       4544       4076
sda10           218.00      3360.00       100.00       3360        100
sda10           546.00      8784.00       124.00       8784        124
sda10           827.00     13232.00       136.00      13232        136

上面看到，磁盘每秒传输次数平均约400；每秒磁盘读取约5MB，写入约1MB。

iostat -d -x -k 1
Device:    rrqm/s wrqm/s   r/s   w/s  rsec/s  wsec/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await  svctm  %util
sda          1.56  28.31  7.84 31.50   43.65    3.16    21.82     1.58     1.19     0.03    0.80   2.61  10.29
sda          1.98  24.75 419.80  6.93 13465.35  253.47  6732.67   126.73    32.15     2.00    4.70   2.00  85.25
sda          3.06  41.84 444.90 54.08 14204.08 2048.98  7102.04  1024.49    32.57     2.10    4.21   1.85  92.24

可以看到磁盘的平均响应时间<5ms，磁盘使用率>80。磁盘响应正常，但是已经很繁忙了。

参考文献：

1. Linux man iostat
2. How Linux iostat computes its results
3. Linux iostat

1. 硬件结构

一块磁盘由多个盘面组成，每个盘面有一个对应的磁头（heads），我们可以在该盘面上存储我们需要的信息。

每一个盘面，被分成多个圆环，我们称之为柱面（cylinders）。每一个柱面又被分割为多个扇形区域，简称扇区（sectors），参见下图：

（图片来源www.eygle.com/）

两个红色环形之间是一个柱面；图中黄色标记部分是一个扇区。

2. fdisk -l 查看磁盘情况

#fdisk -l
Disk /dev/sda: 73.2 GB, 73274490880 bytes
255 heads, 63 sectors/track, 8908 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
   Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1          16      128488+  83  Linux
/dev/sda2              17        1928    15358140   83  Linux
/dev/sda3            1929        2189     2096482+  82  Linux swap / Solaris
/dev/sda4            2190        8908    53970367+   5  Extended
/dev/sda5            2190        2450     2096451   82  Linux swap / Solaris
/dev/sda6            2451        2711     2096451   82  Linux swap / Solaris
/dev/sda7            2712        2972     2096451   82  Linux swap / Solaris
/dev/sda8            2973        8908    47680888+  83  Linux

可以看到，上面的磁盘/dev/sda有255个磁头，8908个柱面，每个柱面轨道上有63个扇区。因为每个扇区大小为512bytes，所以总大小约为：8908 * 63 * 512 * 255 = 73270794240(和上面的73274490880 相差3696640，不知道是什么地方多出来的)。

3. 磁盘分区、文件系统、挂载点

我们继续看上面的例子，磁盘/dev/sda共分为8个分区：/dev/sda1，/dev/sda2，......，/dev/sda8，Start和End分别为各个分区的起始和结束柱面。例如分区/dev/sda2从柱面17开始到柱面1928结束，则大小约为（1928-17）* 63 * 512 * 255 = 14.6G。

可以通过df -h来查看分区/dev/sda2的挂载目录：

#df -h
Filesystem            Size  Used Avail Use% Mounted on
/dev/sda2              15G   13G  1.1G  92% /
/dev/sda1             122M   20M   96M  17% /boot
tmpfs                 2.0G  669M  1.4G  33% /dev/shm
/dev/sda8              45G   26G   17G  62% /u01

可以看到，分区/dev/sda2挂载根目录 / 上。然后，通过文件/etc/fstab来查看该分区的文件系统：

#more /etc/fstab
LABEL=/                 /                       ext3    defaults        1 1
LABEL=/boot1            /boot                   ext3    defaults        1 2
devpts                  /dev/pts                devpts  gid=5,mode=620  0 0
tmpfs                   /dev/shm                tmpfs   defaults        0 0
proc                    /proc                   proc    defaults        0 0
sysfs                   /sys                    sysfs   defaults        0 0
LABEL=/u01              /u01                    ext3    defaults        1 2
LABEL=SWAP-sda5         swap                    swap    defaults        0 0
LABEL=SWAP-sda6         swap                    swap    defaults        0 0
LABEL=SWAP-sda7         swap                    swap    defaults        0 0
LABEL=SWAP-sda3         swap                    swap    defaults        0 0

看到根目录 / 使用了Linux ext3文件系统。

至此，我们看到磁盘/dev/sda共分为八个分区。其中第二个分区/dev/sda2从柱面17到柱面1928结束，大小约为15G，该分区挂载在根目录 / 上，使用了ext3的文件系统。

4. 其他磁盘分区

在上面的fdisk -l 列表中我们一共可以看到八个磁盘分区。上面已经分析了/dev/sda2，我们再看来看看其他的分区。

• 在Linux中第一个分区/dev/sda1，为引导扇区，挂载在/boot上
• 第二个分区挂载在根目录 / 上，大小15G，为ext3文件系统
• 第三个分区为交换分区，从柱面1929到2189，大小约：（2189 - 1929）* 63 * 512 * 255 = 2G。
• 第四个分区为扩展分区，后面四个分区均是该分区的一部分。该分区从柱面2190到8908结束。
• 分区五、六、七为扩展分区的子分区，均为交换分区，单个大小均为2G。所以全部的交换分区大小共2G + 2G*3 = 8G。
• 第八个分区为扩展分区的最后一个子分区，挂载在/u01上，大小约为 （8908 - 2973）* 63 * 512 * 255 = 45G。

以上为示例主机上的全部磁盘分区，以及挂载情况。

5. 小结

有了以上信息，我们就基本清楚了硬件结构以及对应的逻辑结构，需要使用的命令其实也很少：

6. 补充

# This file is edited by fstab-sync - see 'man fstab-sync' for details
LABEL=/1                /                       ext3    defaults        1 1
LABEL=/boot1            /boot                   ext3    defaults        1 2
......

关于/etc/fstab的简单补充：

• 第一列是：一般是设备（分区），如也有是LABEL=×××的，这是ext2 ext3特有的卷标，可以通过e2label来查看各个设备的卷标。
• 第二列是：挂载点
• 第三列是：文件系统
• 第四列是：文件系统挂载时候的参数（例如NFS有时候需要用户名密码等）
• 第五列是：标志是否需要备份1为需要，0为不需要
• 第六列是：启动时，是否需要fsck检查磁盘1为先检查，2为后检查，0为不检查

在fstab文件还有部分第一列是none的，这些都是不需要物理磁盘的文件系统。典型的如/proc文件系统：

none                    /dev/shm                tmpfs   defaults        0 0
none                    /proc                   proc    defaults        0 0
none                    /sys                    sysfs   defaults        0 0

要实现随开启自动启动mysqld，我们需要搞定如下几个问题：

1. Linux开机自动启动脚本放在哪儿？

一般的，作为服务器使用的Linux一般会以“完全多用户模式(Multi-User Mode with Networking)”级别来启动，这种情况下Linux在启动时会运行/etc/rc.d/rc3.d/下的全部脚本。例如我们在这个目录下会看到脚本"/etc/rc.d/rc3.d/S90crond"，意味着开机启动时会运行S90crond脚本。

2. Linux如何运行这些脚本？

既然已经知道自动启动脚本该放在哪儿了，一切就好办。我们只需要将一个启动MySQL的脚本放过去就好了。下面是我们的一个简单的启动脚本v0.1 mysqldauto

这样我们就把创建的mysqldauto脚本放到了/etc/rc.d/rc3.d/下面（注意这里使用了link的方式），mysqld可以自动启动了。

这有两个问题需要解释：

* * * * * 为什么不直接在目录/etc/rc.d/rc3.d/下创建文件，而要创建一个软连接？这并不是必须的。但是这样做是有很多好处的（后面会解释），不过这样做至少会看起来更加专业。

* * * * * 为什么文件名要用S99mysqld？这是规则，在rc3.d下面的脚本如果以字母S开头，那么执行时Linux会给它传递一个start参数（如果以字母K开头，则会传递stop参数）；S后面接个数字，表示了这个脚本的启动顺序，如果目录rc3.d下还有S98*那么它会在S99之前运行。（看到这儿，你可以猜测一下前面我们为什么要创建软连接了）

好了，自此你的mysqld就已经可以随Linux开机自动启动了。

3. 怎样做更专业些？

上面这样做，已经可以解决问题了，不过写法多少有些“山寨”，下面我们看看怎样改造一下。

* * * * * 改造1：处理参数start。既然前面提到以字母S开头的脚本会自动传递一个参数start，K则会传递stop。那么我再做如下修改：

$vi mysqldauto
#!/bin/sh
# Version: 0.2 by orczhou@gmail.com
MYSQLHOME=/opt/mysql                         #这里需要修改为你的mysql安装目录
if [ $# -ge 1 ];then
        mysqldProc=`ps -ef|grep -E "mysqld.+safe"|grep -v "grep"|wc -l`
        if [ $1 = "stop" ] ;then
                if [ $mysqldProc -eq 1 ];then
                        $MYSQLHOME/bin/mysqladmin -uroot shutdown
	fi
        elif [ $1 = "start" ];then
                if [ $mysqldProc -eq 0 ];then
                        $MYSQLHOME/bin/mysqld_safe --user=mysql &
	        fi
        fi
fi

做了如此改造后，我们脚本需要接收两个参数start stop了。如果你想让你mysqld在关闭主机的时候自动关闭，那么stop参数就可以起作用了：

这里做软连接好处就体现出来了，启动和关闭只需要用一个脚本就可以了。

* * * * * 改造2：当你面临几十上百台主机的时候，MySQL的启动参数可能会不一样，例如备库启动时可能需要mysqld_safe --user=mysql --read_olny=1 &，这种情况怎么办呢？这里提供一个解决思路。

在主机上运行一个脚本，探测当前mysqld的启动参数，然后写到一个指定的文件里。最后，在你的启动脚本中，读取这个文件里面的启动参数来启动mysqld。It works。

最后，祝你睡个好觉，做个好梦。

（全文完）