
# 安装

**mac**

mac直接使用brew安装就好，brew请求的github，慢的话可以ss开启全局模式
```shell
$ brew install webp
```

**centos7**
因为是png、gif、jpeg转webp，所以这里需要libpng,libjpeg,giflib

libpng,libjpeg
```shell
sudo yum install libjpeg-turbo-devel libjpeg-turbo libpng-devel -y
```

webp还需要依赖LibTIFF, [http://download.osgeo.org/libtiff/](http://download.osgeo.org/libtiff/)这里可以下载最新的安装包
```shell
$ cd /opt
$ wget http://download.osgeo.org/libtiff/tiff-4.1.0.tar.gz
$ tar -zxvf tiff-4.1.0.tar.gz && cd tiff-4.1.0
$ ./configure
$ make && make install 
```

giflib安装, 这里可以获取最新的giflib [https://sourceforge.net/projects/giflib/files/latest/download](https://sourceforge.net/projects/giflib/files/latest/download)
```shell
$ cd /opt
$ wget https://nchc.dl.sourceforge.net/project/giflib/giflib-5.2.1.tar.gz
$ tar -zxvf giflib-5.2.1.tar.gz
$ cd giflib-5.2.1
$ make && make install
```

libwebp安装, 从github获取即可 [http://www.linuxfromscratch.org/blfs/view/svn/general/libwebp.html](http://www.linuxfromscratch.org/blfs/view/svn/general/libwebp.html)
```shell
$ cd /opt
$ wget https://github.com/webmproject/libwebp/archive/v1.0.3.tar.gz
$ tar -zxvf v1.0.3.tar.gz
$ cd v1.0.3
$ ./configure --prefix=/usr           \
            --enable-libwebpmux     \
            --enable-libwebpdemux   \
            --enable-libwebpdecoder \
            --enable-libwebpextras  \
            --enable-swap-16bit-csp \
            --disable-static
$ make && make install
```

安装完libwebp之后，执行dwebp或者cwebp命令报 dwebp: error while loading shared libraries: libwebpdemux.so.2: cannot open shared object file: No such file or directory 错误的解决办法：
```shell
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib:/usr/lib
echo "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib:/usr/lib" >> ~/.bashrc
```

添加环境变量： 

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib
echo $LD_LIBRARY_PATH
echo "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib" >> ~/.bashrc



# libwebp提供的功能

**cwebp**

compresses an image using the WebP format.

**dwebp**

decompresses WebP files into PNG, PAM, PPM or PGM images.

**gif2webp**

converts a GIF image to a WebP image.

**vwebp**

decompress a WebP file and display it in a window.

**webpmux**

creates animated WebP files from non-animated WebP images, extracts frames from animated WebP images, and manages XMP/EXIF metadata and ICC profile.

**libwebp.so**

contains the API functions for WebP encoding and decoding.


这里主要是用到cwebp的功能
```shell
$ cwebp
Usage:

   cwebp [options] -q quality input.png -o output.webp

where quality is between 0 (poor) to 100 (very good).
Typical value is around 80.
```

我这里测试了一下quality 10 80 100的效果，当前使用webp的主要目的是为了减小图片的大小节省流量。



## quality 10
**stack.png**
![](/images/blog/1/linux/assert/stack.10.webp)

**stack.10.webp**

```shell
$ cwebp -q 10 stack.png -o stack.10.webp
$ Desktop ll stack.*
-rw-r--r--  1 douyacun  staff   8.3K 12  1 23:09 stack.10.webp
-rw-r--r--@ 1 douyacun  staff   127K 12  1 23:08 stack.png
```
可以看到减少了118.7k, 然后在看下效果:
![](/images/blog/1/linux/assert/stack.png)


可以看到10的这个效果也是非常吃惊，像一些清晰度要求不高的场景使用webp绝对超值

**stack.80.webp**
```shell
$ cwebp -q 80 stack.png -o stack.80.webp
Saving file 'stack.80.webp'

$ ll stack.*
-rw-r--r--@ 1 douyacun  staff   8.3K 12  1 23:09 stack.10.webp
-rw-r--r--@ 1 douyacun  staff    19K 12  1 23:15 stack.80.webp
-rw-r--r--@ 1 douyacun  staff   127K 12  1 23:08 stack.png
```

![](/images/blog/1/linux/assert/stack.80.webp)

quality 10和80的区别也只是一些颜色上的区别，没有出现锯齿的效果，而且80也是只有19k

**stack.100.webp**

```shell
$ cwebp -q 100 stack.png -o stack.100.webp
Saving file 'stack.100.webp'
-rw-r--r--@ 1 douyacun  staff   8.3K 12  1 23:09 stack.10.webp
-rw-r--r--@ 1 douyacun  staff    36K 12  1 23:20 stack.100.webp
-rw-r--r--@ 1 douyacun  staff    19K 12  1 23:15 stack.80.webp
-rw-r--r--@ 1 douyacun  staff   127K 12  1 23:08 stack.png
```

100压缩有36K
![](/images/blog/1/linux/assert/stack.100.webp)

图片转webp


# 安装
```
yum install sysstat
```

# 实例1：显示所有设备负载情况
```
iostat

Linux 2.6.32-754.2.1.el6.x86_64 (iZ2zej76z8h545jaqmtldsZ) 	2019年01月20日 	_x86_64_	(4 CPU)

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
          16.00    0.00    4.59    0.03    0.00   79.37

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
vda              13.70         0.66       241.78    5414754 1984862152
vdb               0.00         0.00         0.00       1440          0
```

cpu属性值说明：
- %user：CPU处在用户模式下的时间百分比。
- %nice：CPU处在带NICE值的用户模式下的时间百分比。
- %system：CPU处在系统模式下的时间百分比。
- %iowait：CPU等待输入输出完成时间的百分比。
- %steal：管理程序维护另一个虚拟处理器时，虚拟CPU的无意识等待时间百分比。
- %idle：CPU空闲时间百分比。
> 注：如果%iowait的值过高，表示硬盘存在I/O瓶颈，%idle值高，表示CPU较空闲，如果%idle值高但系统响应慢时，有可能是CPU等待分配内存，此时应加大内存容量。%idle值如果持续低于10，那么系统的CPU处理能力相对较低，表明系统中最需要解决的资源是CPU。

disk属性值说明：
rrqm/s: 每秒进行 merge 的读操作数目。即 rmerge/s
wrqm/s: 每秒进行 merge 的写操作数目。即 wmerge/s
r/s: 每秒完成的读 I/O 设备次数。即 rio/s
w/s: 每秒完成的写 I/O 设备次数。即 wio/s
rsec/s: 每秒读扇区数。即 rsect/s
wsec/s: 每秒写扇区数。即 wsect/s
rkB/s: 每秒读K字节数。是 rsect/s 的一半，因为每扇区大小为512字节。
wkB/s: 每秒写K字节数。是 wsect/s 的一半。
avgrq-sz: 平均每次设备I/O操作的数据大小 (扇区)。
avgqu-sz: 平均I/O队列长度。
await: 平均每次设备I/O操作的等待时间 (毫秒)。
svctm: 平均每次设备I/O操作的服务时间 (毫秒)。
%util: 一秒中有百分之多少的时间用于 I/O 操作，即被io消耗的cpu百分比
备注：如果 %util 接近 100%，说明产生的I/O请求太多，I/O系统已经满负荷，该磁盘可能存在瓶颈。如果 svctm 比较接近 await，说明 I/O 几乎没有等待时间；如果 await 远大于 svctm，说明I/O 队列太长，io响应太慢，则需要进行必要优化。如果avgqu-sz比较大，也表示有当量io在等待。

# 实例2：定时显示所有信息
```
iostat 2 3
Linux 2.6.32-279.el6.x86_64 (colin)   07/16/2014      _x86_64_        (4 CPU)

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
10.81    0.00   14.11    0.18    0.00   74.90

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sda               1.95         1.48        70.88    9145160  437106156
dm-0              3.08         0.55        24.34    3392770  150088376
dm-1              5.83         0.93        46.49    5714522  286728384
dm-2              0.01         0.00         0.05      23930     289288

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
22.62    0.00   19.67    0.26    0.00   57.46

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sda               2.50         0.00        28.00          0         56
dm-0              0.00         0.00         0.00          0          0
dm-1              3.50         0.00        28.00          0         56
dm-2              0.00         0.00         0.00          0          0

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
22.69    0.00   19.62    0.00    0.00   57.69

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sda               0.00         0.00         0.00          0          0
dm-0              0.00         0.00         0.00          0          0
dm-1              0.00         0.00         0.00          0          0
dm-2              0.00         0.00         0.00          0          0
说明：每隔 2秒刷新显示，且显示3次
```

# 实例3：查看TPS和吞吐量
```
iostat -d -k 1 1
Linux 2.6.32-279.el6.x86_64 (colin)   07/16/2014      _x86_64_        (4 CPU)

Device:            tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn
sda               1.95         0.74        35.44    4572712  218559410
dm-0              3.08         0.28        12.17    1696513   75045968
dm-1              5.83         0.46        23.25    2857265  143368744
dm-2              0.01         0.00         0.02      11965     144644
```
- 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是1.95，下面是各个分区的TPS。（因为是瞬间值，所以总TPS并不严格等于各个分区TPS的总和）

## 实例4：查看设备使用率（%util）和响应时间（await）
```
iostat -dx 5 
Linux 2.6.32-279.el6.x86_64 (colin)   07/16/2014      _x86_64_        (4 CPU)

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await  svctm  %util
sda               0.02     7.25    0.04    1.90     0.74    35.47    37.15     0.04   19.13   5.58   1.09
dm-0              0.00     0.00    0.04    3.05     0.28    12.18     8.07     0.65  209.01   1.11   0.34
dm-1              0.00     0.00    0.02    5.82     0.46    23.26     8.13     0.43   74.33   1.30   0.76
dm-2              0.00     0.00    0.00    0.01     0.00     0.02     8.00     0.00    5.41   3.28   0.00
```
- 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压力高)。

另外 await 的参数也要多和 svctm 来参考。差的过高就一定有 IO 的问题。

avgqu-sz 也是个做 IO 调优时需要注意的地方，这个就是直接每次操作的数据的大小，如果次数多，但数据拿的小的话，其实 IO 也会很小。如果数据拿的大，才IO 的数据会高。也可以通过 avgqu-sz × ( r/s or w/s ) = rsec/s or wsec/s。也就是讲，读定速度是这个来决定的。

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 洪水。

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

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

每秒发出的I/0请求很多,但是平均队列就4,表示这些请求比较均匀,大部分处理还是比较及时。

iostat文档


# shadowsocks

centos安装ss，需要先安装pip，ss是python实现的， libsodium库有些加密方法依赖

```shell
yum -y install epel-release
yum -y install python-pip
yum install libsodium -y
```

安装ss

```shell
pip -v
# 安装最新的ss版本
pip install https://github.com/shadowsocks/shadowsocks/archive/master.zip -U
```

shadowsocks.json

```json
{
  "server":"ss服务器ip",            
  "server_port": 端口,                
  "local_address": "127.0.0.1",   
  "local_port":1080,                 
  "password":"password",         
  "timeout":300,                  
  "method":"加密方法",         
  "workers": 1                    
}
```

本地启动ss

```shell
nohup sslocal -c /etc/shadowsocks.json > /dev/null 2>&1 &
```

测试本地scoekt代理：

```curl
curl --socks5 127.0.0.1:1080 http://httpbin.org/ip
```

 可以直接设置socket5代理:



# privoxy

ss 是socket5代理， 安装privoxy将socket5转发成http代理

```shell
yum -y install privoxy
systemctl start privoxy
```

配置privoxy `/etc/privoxy/config`

```
listen-address 127.0.0.1:8118 # 8118 是默认端口，不用改  
forward-socks5t / 127.0.0.1:1080 . #转发到本地端口，注意别忘了最后的.
```

不知道是谁做的决定限速github，心里默默诅咒他

centos使用ss代理的方法


# 系统

- 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                - 查看所有安装的软件包

linux常用命令_磁盘_进程_网络_内存_负载


# 页面缓存

查看页面缓存：
```shell
[www@00h ~]$ cat /proc/meminfo
MemTotal:        1882236 kB
MemFree:           75952 kB
MemAvailable:      58212 kB
Buffers:           14576 kB
Cached:           136732 kB
SwapCached:            0 kB
Active:          1630800 kB
Inactive:          79352 kB
Active(anon):    1584460 kB
Inactive(anon):    34188 kB
Active(file):      46340 kB
Inactive(file):    45164 kB
Unevictable:           0 kB
Mlocked:               0 kB
SwapTotal:             0 kB
SwapFree:              0 kB
Dirty:                84 kB  => 写入缓存页，Dirty的值会增加
Writeback:             0 kB  => 缓存页开始写入硬盘，Writeback值会增加直到结束
...
```

## [脏页](#dirty_page)

硬盘的读写速度远源跟不上内存的速度，内核会把读写比较频繁的数据事先放到内存中，以提高读写速度减少I/O操作，这叫高速缓存，
linux是以页作为高速缓存的单位，当进程修改了高速缓冲中的数据时，该页就被称为脏页

## 延迟写

当将数据写入文件时，内核通常先将数据复制页面高速缓存，如果该缓冲区没有写满，并不将其写入到输出队列，而是等待其写满或者当内核需要重用这块缓冲区以便存放其他磁盘块数据时，
在将该缓冲区排入到输出队列，待其到达队首时，才进程实际的I/O操作，这种输出方式被称为延迟写

## 内存映射(mmap)

mmap用于把文件映射到内存空间中，简单说mmap就是把一个文件的内容在内存里面做一个映像。映射成功后，用户对这段内存区域的修改可以直接反映到内核空间，同样，内核空间对这段区域的修改也直接反映用户空间。那么对于内核空间<---->用户空间两者之间需要大量数据传输等操作的话效率是非常高的。

# 页面缓存后，如何访问数据？

1. 内核开始读时，先检查高速缓存中是否有该数据
2. 如果有，命中缓存，没有直接从磁盘读取
3. 内核调度块I/O，从磁盘中读取全部数据，将全部数据放入到页高速缓冲中


# 写缓冲

内核从磁盘读取数据时，如果从页高速缓冲中没有读取到的话，会直接从磁盘中读取数据并将数据存入页高速缓存中，保证下次使用，写缓存策略：
- 直接I/O，不经过页高速缓存，会增大磁盘I/O开销
- 写透缓存，写操作更新内存缓存，同时更新磁盘文件，可以保持缓存一致性
- 回写，程序执行写操作直接将数据写入到缓存中，然后将被写入的页面标记为脏页，加入脏页链表中，[回写进程](/linux/页缓存.md#pdflush)会将脏页刷新到磁盘中,最终保持数据一致性

# [缓存回收(pdflush)](#pdflush)
缓存回收，清除页的数据，为更重要的数据提供坑位，收缩缓存大小减小内存压力
linux回收策略：

- LRU（最近最少使用）
- 双链，分活跃链表/非活跃链表

pdflush写入到硬盘主要看两个参数：
1. 数据在页缓冲中是否超过30秒，如果是标记为脏页
2. 脏页缓存是否达到工作内存的100%

以下也会影响pdflush线程：
- 用户进程调用[sync/fsync/fdatasync](/article/5346fecbca9c98ddeb6290c06a5a9a36)
- `/proc/sys/vm/dirty_ratio`: 默认30，总内存的百分比，系统所能拥有的最大脏页缓存总量
- `/proc/sys/vm/dirty_background_ratio`: 默认 10， 如果需要把缓存持续的而不是一下子大量的写入磁盘，降低这个值

pdflsuh 受 `/proc/sys/vm/` 下的参数控制：
```
[root@00h www]# ll /proc/sys/vm/|gawk '{print $9}'
admin_reserve_kbytes
block_dump
compact_memory 
dirty_background_bytes
dirty_background_ratio (10) 判断脏页缓存是否到了最大值 内存的%
dirty_ratio（30） 总内存的最大百分比，超过这个值开启pdflush写入硬盘，如果cache大于pdflush，会遇到I/O瓶颈，所有的I/O都要等待cache被pdflush进磁盘, 业务繁忙建议5-10%
dirty_bytes
dirty_expire_centisecs (3000) 缓存页里的过期时间，默认30秒
dirty_writeback_centisecs (500) 单位（1/100秒）多长时间唤醒pdflush将缓存页写入硬盘，默认：2个线程/5秒
drop_caches
extfrag_threshold
hugepages_treat_as_movable
hugetlb_shm_group
laptop_mode
legacy_va_layout
lowmem_reserve_ratio
max_map_count
memory_failure_early_kill
memory_failure_recovery
min_free_kbytes 保留内存的值
min_slab_ratio
min_unmapped_ratio
mmap_min_addr
mmap_rnd_bits
mmap_rnd_compat_bits
nr_hugepages
nr_hugepages_mempolicy
nr_overcommit_hugepages
nr_pdflush_threads 查看多少个pdflush进程
numa_zonelist_order
oom_dump_tasks
oom_kill_allocating_task
overcommit_kbytes
overcommit_memory
overcommit_ratio
page-cluster
panic_on_oom
percpu_pagelist_fraction
stat_interval
swappiness (0) linux倾向于从物理内存映射到硬盘缓存，保持硬盘缓存尽可能大。未用的页缓存会被放进swap区, 少用swapping会增加程序的响应速度；多用swapping将会提高系统的可用性。
    - 0 将会避免使用swapping
    - 100 尽量使用swapping
user_reserve_kbytes
vfs_cache_pressure
zone_reclaim_mode
```


- dirty_ratio 单位百分比，表示当写缓冲内存占用内存多少的时候，开始向磁盘写数据，增大会使更多的系统内存用于磁盘写缓冲，可以极大的提高系统的写性能, 但是当你需要持续、恒定的写入场合时，应该降低其值
- dirty_background_ratio 控制pdflush进程，在何时刷新磁盘，单位百分比，pdflush用于将内存中的内容和文件系统进行同步，每当内存中的垃圾页（dirty page）超过10%的时候,pdflush就会将这些页面备份回硬盘.增大之会使用更多系统内存用于磁盘写缓冲，也可以极大提高系统的写性能。但是，当你需要持续、恒定的写入场合时，应该降低其数值， 配合dirty_ratio
- min_free_kbytes: 文件系统数据缓冲需要频繁的内存分配。加大保留内存的值能提升系统速度和稳定。小于8G的内存，保留内存为64M，大于8G的设置为256M
```
echo 65536 > /proc/sys/vm/min_free_kbytes
```
- dirty_writeback_centisecs: 控制pdflush线程的运行间隔，单位时1/100秒，默认5秒（500），如果是持续的写入操作，降低这个值比较好，可以把剑锋的写操作削平成多次写操作，该参数的设置应该小于dirty_expire_centisecs, 也不能太小，太小I/0太频繁, 1:6 (dirty_expire_centisecs  : dirty_writeback_centisecs )的比例比较好。
- dirty_expire_centisecs: 声明Linux内核写缓冲区里面的数据多“旧”了之后，pdflush进程就开始考虑写到磁盘中去。单位是 1/100秒。缺省是 30000，也就是 30 秒的数据就算旧了，将会刷新磁盘。对于特别重载的写操作来说，这个值适当缩小也是好的，但也不能缩小太多，因为缩小太多也会导致IO提高太快。
- min_free_kbytes: VM最低保留多少空闲内存（Kbytes）



理解一下Linux的是如何处理脏页的

linux页高速缓存_脏页_延迟写_I/O内核参数优化_pdflush

# 电脑重装成centos系统

## 下载iso镜像

[镜像下载](http://centos.01link.hk/)

```
[DIR] Parent Directory                                             -   
[TXT] 0_README.txt                            10-May-2018 04:16  2.4K  
[   ] CentOS-7-x86_64-DVD-1804.iso            04-May-2018 05:07  4.2G  
[   ] CentOS-7-x86_64-DVD-1804.torrent        11-May-2018 23:43   84K  
[   ] CentOS-7-x86_64-Everything-1804.iso     07-May-2018 20:55  8.8G  
[   ] CentOS-7-x86_64-Everything-1804.torrent 11-May-2018 23:43  176K  
[   ] CentOS-7-x86_64-LiveGNOME-1804.iso      03-May-2018 02:21  1.3G  
[   ] CentOS-7-x86_64-LiveGNOME-1804.torrent  11-May-2018 23:43   52K  
[   ] CentOS-7-x86_64-LiveKDE-1804.iso        03-May-2018 02:28  1.8G  
[   ] CentOS-7-x86_64-LiveKDE-1804.torrent    11-May-2018 23:43   71K  
[   ] CentOS-7-x86_64-Minimal-1804.iso        04-May-2018 05:07  906M  
[   ] CentOS-7-x86_64-Minimal-1804.torrent    11-May-2018 23:43   36K  
[   ] CentOS-7-x86_64-NetInstall-1804.iso     04-May-2018 04:34  495M  
[   ] CentOS-7-x86_64-NetInstall-1804.torrent 11-May-2018 23:43   20K     >>>>>>>>>
[TXT] sha1sum.txt                             10-May-2018 04:02  454   
[TXT] sha1sum.txt.asc                         11-May-2018 23:12  1.3K  
[TXT] sha256sum.txt                           10-May-2018 03:59  598   
[TXT] sha256sum.txt.asc                       11-May-2018 23:12  1.4K  
```
> 选择的是 上面标记的 网络安装版本 >>>>>>>>> ,一些基础软件没有, 需要联网下载

## 制作centos系统盘 (mac os)

----

1. 把ISO转成DMG，命令中的-o后面的linux是目标文件名，按自己需求改

    ```
    # hdiutil convert -format UDRW -o 输出 输入文件.iso
    # hdiutil convert /Users/os/Downloads/ylmf.iso -format UDRW -o ylmf.img    // windows
    ```


2. .把U盘插上，查看盘符

    ```
    # diskutil list
    ```

3. 卸载U盘，把命令里的disk2改成你自己的盘符，还要注意卸载不是弹出！

    ```
    # diskutil unmountDisk /dev/disk2
    ```

4. 开始把光盘写入到u盘

    ```
    # sudo dd if=linux.dmg of=/dev/disk2 bs=1m

    之后终端里就不动了，看着没反应了，其实正在后台运行呢，等着就行，写入完成以后终端有提示，然后再弹出U盘就可以正常使用了。

    408+0 records in
    408+0 records out
    427819008 bytes transferred in 3.608223 secs (118567786 bytes/sec)
    ```

## 装机 安装选择

- f12 进入bios
```
Boot Mode  : Legacy Support
Boot Priority : Legacy First
```
- 重启 f12 选 use 启动

- 设置启动盘, 配置目录google或baidu搜吧!

- 上面的关键点来了, 因为选择的netinstall, 需要设置安装源, 下面的源可能会失效 (https://opsx.alibaba.com/mirror) 自己选吧

- https://mirrors.aliyun.com/centos/7.5.1804/os/x86_64/

- 选择最小化安装就行


# 扩展
- linux 挂载FAT32系统
    ```
    # mount -t vfat /dev/sdb1 /package
    ```

制作centos7系统盘


epoll时linux内核的可扩展I/O事件通知机制，于Linux 2.5.44首度登场， 让需要大量操作文件描述的程序得以发挥更优异的性能，poll和select的时间复杂度是O(n), 而epoll的复杂度时O(log n)。

# 接口

[http://man7.org/linux/man-pages/man2/epoll_create.2.html](http://man7.org/linux/man-pages/man2/epoll_create.2.html)

```c#
int epoll_create(int size);
```

在内核中创建`epoll`实例并返回一个`epoll`文件描述符。 在最初的实现中，调用者通过 `size` 参数告知内核需要监听的文件描述符数量。如果监听的文件描述符数量超过 size, 则内核会自动扩容。而现在 size 已经没有这种语义了，但是调用者调用时 size 依然必须大于 0，以保证后向兼容性。

[http://man7.org/linux/man-pages/man2/epoll_ctl.2.html](http://man7.org/linux/man-pages/man2/epoll_ctl.2.html)


```c
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

typedef union epoll_data {
    void        *ptr;
    int          fd;
    uint32_t     u32;
    uint64_t     u64;
} epoll_data_t;

struct epoll_event {
    uint32_t     events;      /* Epoll events */
    epoll_data_t data;        /* User data variable */
};
```

向 epfd 对应的内核`epoll` 实例添加、修改或删除对 fd 上事件 event 的监听。

- op 可以为
  -  `EPOLL_CTL_ADD`  添加新的事件
  -  `EPOLL_CTL_MOD` 修改文件描述符上监听的事件类型
  - `EPOLL_CTL_DEL` 从实例上删除一个事件
- Event 可以是以下几个宏的集合

    -   EPOLLIN 触发该事件，表示对应的文件描述符上有可读数据。(包括对端SOCKET正常关闭)
    -   EPOLLOUT  触发该事件，表示对应的文件描述符上可以写数据
    -   EPOLLPRI 表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）
    -   EPOLLERR 表示对应的文件描述符发生错误
    -   EPOLLHUP 表示对应的文件描述符被挂断
    -   EPOLLET 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的
    -   EPOLLONESHOT 只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里

[http://man7.org/linux/man-pages/man2/epoll_wait.2.html](http://man7.org/linux/man-pages/man2/epoll_wait.2.html)

```c
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
```

- events是结构体epoll_event数组， epoll会把就绪文件描述符赋值给events
- maxevents告诉内核这个events数组有多大
- 当 timeout 为 0 时，epoll_wait 永远会立即返回。而 timeout 为 -1 时，epoll_wait 会一直阻塞直到任一已注册的事件变为就绪。当 timeout 为一正整数时，epoll 会阻塞直到计时 timeout 毫秒终了或已注册的事件变为就绪。因为内核调度延迟，阻塞的时间可能会略微超过 timeout 毫秒。

go实现epoll, goroutine适合cpu密集型，而epoll是I/O密集型，而I/O密集型的场景也是比较多的

```go
package main

import (
	"github.com/gorilla/websocket"
	"log"
	"reflect"
	"sync"
	"syscall"
)

type epoll struct {
	fd       int
	connects map[int]*websocket.Conn
	lock     *sync.RWMutex
}

func MakeEpoll() (*epoll, error) {
	fd, err := syscall.EpollCreate(1)
	if err != nil {
		return nil, err
	}
	return &epoll{
		fd:       fd,
		connects: make(map[int]*websocket.Conn),
		lock:     &sync.RWMutex{},
	}, nil
}

func (e *epoll) Add(conn *websocket.Conn) error {
	// e.fd epoll_create 初始化返回epoll文件描述符
	// syscall.EPOLL_CTL_ADD 对内核epoll实例增加一个描述符
	// websocketSysFd(conn) 获取conn的文件描述符
	// nil 水平触发模式
	fd := websocketSysFd(conn)
	err := syscall.EpollCtl(e.fd, syscall.EPOLL_CTL_ADD, fd,  &syscall.EpollEvent{Events: syscall.EPOLLIN | syscall.EPOLLHUP, Fd: int32(fd)})
	if err != nil {
		return err
	}
	e.lock.Lock()
	defer e.lock.Unlock()

	e.connects[fd] = conn
	if len(e.connects)%100 == 0 {
		log.Printf("number of connections: %d", len(e.connects))
	}
	return nil
}

func (e *epoll) Wait() ([]*websocket.Conn, error) {
	var events = make([]syscall.EpollEvent, 100)
	n, err := syscall.EpollWait(e.fd, events, 100)
	if err != nil {
		return nil, err
	}
	var connections []*websocket.Conn
	for i := 0; i < n; i++ {
		conn := e.connects[int(events[i].Fd)]
		connections = append(connections, conn)
	}
	return connections, nil
}

func (e *epoll) Remove(conn *websocket.Conn) error {
	// e.fd epoll_create 初始化返回epoll文件描述符
	// syscall.EPOLL_CTL_ADD 对内核epoll实例增加一个描述符
	// websocketSysFd(conn) 获取conn的文件描述符
	// nil 水平触发模式
	fd := websocketSysFd(conn)
	err := syscall.EpollCtl(e.fd, syscall.EPOLL_CTL_DEL, fd, nil)
	if err != nil {
		return err
	}
	e.lock.Lock()
	defer e.lock.Unlock()
	delete(e.connects, fd)
	if len(e.connects)%100 == 0 {
		log.Printf("number of connections: %d", len(e.connects))
	}
	return nil
}

// 这里主要是从websocket.conn中取得文件描述符
func websocketSysFd(conn *websocket.Conn) int {
	connVal := reflect.Indirect(reflect.ValueOf(conn)).FieldByName("conn").Elem()
	tcpConn := reflect.Indirect(connVal).FieldByName("conn")
	fdVal := tcpConn.FieldByName("fd")
	pfdVal := reflect.Indirect(fdVal).FieldByName("pfd")
	return int(pfdVal.FieldByName("Sysfd").Int())
}
```

# 原理

epoll只告知就绪的文件描述符，epoll_wait返回的int数值是已经就绪的文件描述符数量，从events数组中文件描述符取相应的文件描述符即可

**内存映射(mmap)**，省掉了这些文件描述符在系统调用时复制的开销

**就绪通知** eselect/poll，进程只有调用一定方法后，内核才对所有监视的文件描述符遍历，而epoll是通过epoll_ctl注册一个文件描述符，一旦某个文件描述符就绪时，迅速激活这个文件描述符，进程调用epoll_wait会得到通知

# 触发模式

epoll有2种触发模式，水平触发 / 边缘触发，在边缘触发模式中，epoll_wait仅会在新的事件首次被加入epoll队列时返回。在水平触发模式中，在事件状态未变更前将不断触发(epoll_wait时没次都会返回)。

考虑读的情况。假设我们注册了一个读事件到`epoll`实例上，`epoll`实例会通过`epoll_wait`返回值的形式通知我们哪些读事件已经就绪。简单地来说，在水平触发模式下，如果读事件未被处理，该事件对应的内核读缓冲器非空，则每次调用 `epoll_wait` 时返回的事件列表都会包含该事件。直到该事件对应的内核读缓冲器为空为止。而在边缘触发模式下，读事件就绪后只会通知一次，不会反复通知。

考虑写的情况。水平触发模式下，只要文件描述符对应的内核写缓冲器未满，就会一直通知可写事件。而在边沿触发模式下，内核写缓冲器由满变为未满后，只会通知一次可写事件。

举例来说，倘若有一个已经于`epoll`注册接手数据，`epoll_wait`将返回，并发出数据读取的信号。现假设缓冲器的数据仅有部分被读取并处理，在水平触发模式下，任何对`epoll_wait`之调用都将即刻返回，直到缓冲器中的数据全部被读取；然而，在边缘触发的情境下，`epoll_wait`仅会于再次接收到新数据(亦即，新数据被写入管线)时返回。

边缘触发模式，程序可能在用户态缓存I/O状态，nginx就是边缘触发模式，有2种情况时推荐使用边缘触发模式：

- read或者write系统调用返回 EAGAIN
- 非阻塞的文件描述符

边缘触发模式，可能的缺陷：

- 假设某个文件描述符上有大量不间断的输入流，而边缘触发模式只会通知一次，一次是读不完的

# epoll是如何实现高效处理百万句柄的

执行epoll_create时，创建了红黑树和就绪链表，执行epoll_ctl时，如果增加socket句柄，则检查在红黑树中是否存在，存在立即返回，不存在则添加到树干上，然后向内核注册回调函数，用于当中断事件来临时向准备就绪链表中插入数据。执行epoll_wait时立刻返回准备就绪链表里的数据即可。

select/poll 每次调用需要将监听句柄作为参数传递，这样在进程和内核之间数据拷贝很浪费时间

epoll还维护了一个双链表，当调用epoll_wait时，仅需要观察这个链表中有没有就绪的句柄即可，每次需要拷贝的句柄很少，非常高效。

那么，这个准备就绪list链表是怎么维护的呢？当我们执行epoll_ctl时，除了把socket放到epoll文件系统里file对象对应的红黑树上之外，还会给内核中断处理程序注册一个回调函数，告诉内核，如果这个句柄的中断到了，就把它放到准备就绪list链表里。所以，当一个socket上有数据到了，内核在把网卡上的数据copy到内核中后就来把socket插入到准备就绪链表里了。

```c
struct eventpoll {
	/*
	 * This mutex is used to ensure that files are not removed
	 * while epoll is using them. This is held during the event
	 * collection loop, the file cleanup path, the epoll file exit
	 * code and the ctl operations.
	 */
	struct mutex mtx;

	/* Wait queue used by sys_epoll_wait() */
	wait_queue_head_t wq;

	/* Wait queue used by file->poll() */
	wait_queue_head_t poll_wait;

	/* List of ready file descriptors */
	struct list_head rdllist;

	/* Lock which protects rdllist and ovflist */
	rwlock_t lock;

	/* RB tree root used to store monitored fd structs */
	struct rb_root_cached rbr;

	/*
	 * This is a single linked list that chains all the "struct epitem" that
	 * happened while transferring ready events to userspace w/out
	 * holding ->lock.
	 */
	struct epitem *ovflist;

	/* wakeup_source used when ep_scan_ready_list is running */
	struct wakeup_source *ws;

	/* The user that created the eventpoll descriptor */
	struct user_struct *user;

	struct file *file;

	/* used to optimize loop detection check */
	int visited;
	struct list_head visited_list_link;

#ifdef CONFIG_NET_RX_BUSY_POLL
	/* used to track busy poll napi_id */
	unsigned int napi_id;
#endif
};
```



go实现websocket时，使用epoll优化来节省goroutine,这里特地来了解一下

高大上的epoll是如何实现高效处理百万句柄


# fsync,  fdatasync 同步内核的页缓存到磁盘
```c
#include <unistd.h>

int fsync(int fd);
int fdatasync(int fd);
```

- fsync： 文件描述符(fd)在内核中所有的[脏页](/linux/页缓存.md#dirty_page)同步到的磁盘，调用会被阻塞直到磁盘写入完成，能确保被修改过的块立即写入到磁盘
- fdatasync：类似于fysnc，文件属性(st_atime,st_mtime等)不会同步到磁盘，目的是为了减少磁盘交互

# 与fdatasync相比fsync的性能问题#性能
fysnc 除了同步文件的修改内容(脏页)，还会同步文件的描述信息(metadata、包括size、访问时间st_atime、st_mtime等)，因为文件数据和metadata通常存在磁盘不同的地方，所以fsync至少需要两次I/O操作

多余的一次IO操作，有多么昂贵呢？根据Wikipedia的数据，当前硬盘驱动的平均寻道时间（Average seek time）大约是3~15ms，7200RPM硬盘的平均旋转延迟（Average rotational latency）大约为4ms，因此一次IO操作的耗时大约为10ms左右。

文件的尺寸(st_size)如果发生变化，是需要立即同步的否则OS一旦崩溃，即使文件的数据部分已同步，由于metadata没有同步，依然读不到修改的内容，最后的饿访问时间和修改时间是不需要每次同步的

读redis源码-AOF和磁盘I/O造成的延迟

sync_fsync_fdatasync_linux

# gdb 调试工具

调试redis设置:
```c
// 相当于 gcc -g
make CFLAGS="-g -O0"

gdb src/redis-server
```

> gdb 支持tab补全

# 运行程序
- `run` 可指定运行参数
  - `set args` 指定运行是参数
- 运行环境
  - `path` 设定程序的运行路径
  - `set environment varname[=value]` 设置环境变量 ：`set env USER=hchen`

# 设置断点: breakpointer

- 函数断点: `break <function>`
- 行号断点：`break <linenum>`
- 在程序运行内存地址处停止：`break *address`

# 查看断点: info
`info break[n]`

# 设置捕捉点：catchpoint

`cactch event`, event如下:
1. throw 一个 C++抛出的异常(throw 为关键字) ，
2. catch 一个 C++捕捉到的异常(catch 为关键字) ，
3. exec 调用系统调用 exec 时(exec 为关键字， 目前此功能只在HP-UX 下有用) 
4. fork 调用系统调用 fork 时。 (fork 为关键字， 目前此功能只在HP-UX 下有用)
5. vfork 调用系统调用vfork时。(vfork为关键字，目前此功能只在HP-UX下有用)
6. load 或 load <libname> 载入共享库(动态链接库)时。 (load 为关键字，目前此功能只在 HP-UX 下有用)
7. unload 或 unload<libname> 卸载共享库(动态链接库)时。 (unload为关键字，目前此功能只在 HP-UX 下有用)

只设置一次断点，程序停住后，断点自动删除

# 维护断点

- `clear` 清除所有的断点
- `clear <function>` 清除函数断点
- `clear <linenum>` 清除指定行上的断点
- `delete [<breakpointe>][range]` 清除指定断点，范围断点

# 恢复程序运行
- `continue`
- `c`
- `fg`
以上3个是同一个意思

# 单步跟踪
- `step<count>`: 如果有函数会进入函数，count：每次运行几条指令,不加每次运行一条
- `next<count>`: 如果有函数不会进入函数，count：每次运行几条指令,不加每次运行一条
- `finish`: 运行程序，知道函数完成，并打印函数返回时的堆栈地址和返回值及参数值信息
- `until`|`u`:推出循环体

打开单步跟踪模式: `set step-mode [on][off]` 在进行单步跟踪时，程序不会因为没有debug而停住

# 信号
unix定义了很多信号，比如SIGINT表示中断字符信号，可以要求GDB收到你锁指定的信号时，马上挺住正在运行的程序，以供进行调试

`handle <single> <keywords...>`

- single: 信号，all表明要处理的所有信号
- keywords:
  - nostop: 不会停住程序的运行
  - stop: 停住
  - print: 回显示出一条信息
  - noprint: 不会显示信息
  - pass/noignore: GDB不处理信号，交给调试程序处理
  - nopass/ignore: GDB不会让调试程序处理这个信号
  - info singles/info handle: 哪些信号被GDB检测中

# 线程
可以定义断点是否在所有线程上还是某个特定的线程
```gdb
break <linespec> thread <threadno>
break <linespec> thread <threadno> if...

break frik.c:13 thread 28 if bartab>lim
```
- linespec 行号
- threadno 线程id，`info threads`可以查看正在运行中的线程

不指定`threadno`表示断点设在所有的线程上面

# 查看栈信息
当程序被停住了，需要做的第一件事就是查看程序是在哪里停住了，当程序调用了一个函数：函数的地址、参数、局部变量都会被压入“栈中”
- `backtrace<n>`
- `bt<n>`
> n 只打栈顶上n层的信息
> -n 栈底n层的栈信息
打印当前函数调用栈的所有信息

切换当前栈
- `f<n>` | `frame<n>` 打印某一层的栈: 栈的层编号、当前函数名、函数参数值，函数所在的文件及行号
- `up<n>` 向上移动n层
- `down<n>` 移动n层

# 打印函数栈信息

- `info f` 打印更详细的栈层信息，大多是运行内存地址：函数地址、调用函数地址、被调用函数的地址、程序语言、函数参数地址及值、局部变量的地址
- `info args` 打印当前函数的参数名、值
- `info locals` 当前函数中所有局部变量、值
- `info catch` 当前函数中异常处理信息


# 显示源代码
`set listsize <count>` 一次显示源代码的行数

- `list<linenum>` 显示程序第`linenum`行周围的源程序
- `list<function>` 显示函数名为function的函数的源程序
- `list` 当前行后面的源程序
- `list -` 当前行前面的源程序
- `list <first>,<last>` 从first到last行之间的源代码
- `list <last>` 从当前行到last行之间的源代码
- `list +`往后显示源代码

list 后面可以跟的参数:
- `<linenum>`行号。 
- `<+offset>`当前行号的正偏移量。 
- `<-offset>`当前行号的负偏移量。 
- `<filename:linenum>`那个文件的那一行。 
- `<funtion>`函数名 
- `<filename:funtion>`那个文件中的那个函数。 
- `<*address>`程序运行时的语句在内存中的地址。

# 搜索源代码
- 向前搜索
  - `forward-search <regexp>`
  - `search <regexp>` 
- 全部搜索
  - `reverse-search<regexp>`

# 指定源文件的路径
- `directory<dirname...>`加一个源文件路径到当前路径的前面，指定多个路径“:”
- `directory`清除所有的自定义的源文件搜索路径信息
- `show directories`显示定义了的源文件搜索路径

# 打印数据
`print/<f><expr>`

- `@` 一个数组有关的操作符，在后面会有更详细的说明
- `::`指定一个文件中或是一个函数中的变量
- `{<type>}<addr>` 表示一个指向内存地址`<addr>`的类型为type的一个对象

gdb中可以随时查看一下三种变量的值：
- 全局变量（所有文件可见）
- 静态全局变量（当前文件可见）
- 局部变量（当前scope可见的）

数组：
```c
int *array = (int*)malloc(len*sizeof(int))

// 动态数组
(gdb) p *array@len
$1 = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40}

// 静态数组就可以查看
print array
```

# 输出格式
- x 按十六进制格式显示变量。
- d 按十进制格式显示变量。
- u 按十六进制格式显示无符号整型。 o 按八进制格式显示变量。
- t 按二进制格式显示变量。
- a 按十六进制格式显示变量。
- c 按字符格式显示变量。
- f 按浮点数格式显示变量。

# 查看内存
`examine`(简写 x), 查看内存地址中的值

`x<n/f/u><addr>`

n、f、u 是可选参数。
- n 是一个正整数，表示显示内存的长度，也就是说从当前地址向后显示几个地址的内容。 
- f 表示显示格式，参加上面。如果地址所指的是字符串，那么格式是 s，如果地址是指令
地址，那么格式也可以是 i。
- u 表示从当前的地址往后请求的字节数，如果不指定的话，GDB 默认是 4 个 bytes。u 参数可以用下面的字符来代替：
  - b 表示单字节
  - h 表示双字节
  - w 表示四字节
  - g 表示八字节

`x/3uh 0x54320` 表示，从内存地址`0x54320`读取内容

# 自动显示
可以设置一些自动显示的变量，当程序停住时，或是在单步跟踪时，这些变量回自动显示：
- `display<expr>`
- `display<fmt><expr>`
- `display/<fmt><expr>`

> expr: 表达式
> fmt: 显示的格式
> addr: 内存地址

删除自动显示，dnums设置好了的自动显示的编号，同时删除多个，用空格分隔，范围删除，用`-`分隔
- `undisplay<dnums...>`
- `delete display<dnums...>`

`info display` 查看display自动显示的信息

# 设置选项
- `set print address <on/off>` 打开地址输出,系统默认打开，等同于`frame/f`显示地址信息
- `set print array <on/off>` 打开数组显示，每个元素栈占一行，不打开每个以逗号分隔
- `set print elements <on/off>` print elemets的选项信息
- `set print null-stop<on/off>` 显示字符串时，遇到`\0`就停止显示
- `set print pretty <on/off>` gdb显示结构体就比较漂亮
- `set print union <on/off>` 显示结构体时，是否显示其内的联合体数据
- `set listsize <n>` 一次显示源代码的行数
- `set step-mode [on][off]` 在进行单步跟踪时，程序不会因为没有debug而停住
- `set print array-indexes on` 打印数组索引下标


# 修改变量值
`print x=4`

# 跳转执行
`jump<linespect>`执行下一条语句运行点，`file:line`

# 查生信号量
`single 命令`

# 强制函数返回
`return`

# 强制调用函数
`call`

- https://www.kancloud.cn/wizardforcel/gdb-tips-100/146752

# gdb 启动脚本
gdb启动时，会读取HOME目录和当前目录下的的配置文件，执行里面的命令。这个文件通常为“.gdbinit”。

```
# 保存历史命令
set history filename ~/.gdb_history
set history save on

# 退出时不显示提示信息
set confirm off

# 按照派生类型打印对象
set print object on

# 打印数组的索引下标
set print array-indexes on

# 每行打印一个结构体成员
set print pretty on

set step-mode on
```
