Linux使用dd命令测试硬盘读写速度

测试磁盘IO速度的方法

测试磁盘IO速度的⽅法读取速度可以使⽤命令：hdparm –t 设备名（/dev/sda1）写⼊速度使⽤命令：time dd if=/dev/zero of=/tmp/test.dat bs=1G count=1测试磁盘的读写IO速度有时候我们在做维护的时候，总会遇到类似于IO特别⾼，但不能判定是IO瓶颈还是软件参数设置不当导致热盘的问题.这时候通常希望能知道磁盘的读写速度，来进⾏下⼀步的决策.下⾯是两种测试⽅法：(1)使⽤hdparm命令这是⼀个是⽤来获取ATA/IDE硬盘的参数的命令,是由早期Linux IDE驱动的开发和维护⼈员 Mark Lord开发编写的( hdparm has been written by Mark Lord <>, the primary developer and maintainer of the (E)IDE driver for Linux, with suggestions from many netfolk).该命令应该也是仅⽤于Linux系统,对于UNIX系统，ATA/IDE硬盘⽤的可能⽐较少，⼀般⼤型的系统都是使⽤磁盘阵列的.使⽤⽅法很简单# hdparm -Tt /dev/sda/dev/sda:Timing cached reads: 6676 MB in 2.00 seconds = 3340.18 MB/secTiming buffered disk reads: 218 MB in 3.11 seconds = 70.11 MB/sec可以看到,2秒钟读取了6676MB的缓存,约合3340.18 MB/sec;在3.11秒中读取了218MB磁盘(物理读),读取速度约合70.11 MB/sec(2)使⽤dd命令这不是⼀个专业的测试⼯具，不过如果对于测试结果的要求不是很苛刻的话,平时可以使⽤来对磁盘的读写速度作⼀个简单的评估.另外由于这是⼀个免费软件,基本上×NIX系统上都有安装,对于Oracle裸设备的复制迁移,dd⼯具⼀般都是⾸选.在使⽤前⾸先了解两个特殊设备/dev/null 伪设备,回收站.写该⽂件不会产⽣IO/dev/zero 伪设备,会产⽣空字符流,对它不会产⽣IO测试⽅法:a.测试磁盘的IO写速度# time dd if=/dev/zero of=/test.dbf bs=8k count=300000300000+0 records in300000+0 records out10.59s real 0.43s user 9.40s system# du -sm /test.dbf2347 /test.dbf可以看到,在10.59秒的时间⾥，⽣成2347M的⼀个⽂件,IO写的速度约为221.6MB/sec;当然这个速度可以多测试⼏遍取⼀个平均值,符合概率统计.b.测试磁盘的IO读速度# df -mFilesystem 1M-blocks Used Available Use% Mounted on/dev/mapper/VolGroup00-LogVol0019214 9545 8693 53% //dev/sda1 99 13 82 14% /bootnone 506 0 506 0% /dev/shm# time dd if=/dev/mapper/VolGroup00-LogVol00 of=/dev/null bs=8k2498560+0 records in2498560+0 records out247.99s real 1.92s user 48.64s system上⾯的试验在247.99秒的时间⾥读取了19214MB的⽂件,计算下来平均速度为77.48MB/secc.测试IO同时读和写的速度# time dd if=/dev/sda1 of=test.dbf bs=8k13048+1 records in13048+1 records out3.73s real 0.04s user 2.39s system# du -sm test.dbf103 test.dbf上⾯测试的数据量⽐较⼩，仅作为参考.相⽐两种⽅法:前者是linux上专业的测试IDE/ATA磁盘的⼯具,但是使⽤范围有局限性;(此试验仅仅使⽤了测试磁盘IO的参数,对于其他参数及解释参考man⼿册)后者可以通⽤,但不够专业,也没有考虑到缓存和物理读的区分，测试的数据也是仅作参考，不能算是权威.。

dd测试硬盘读写性能

1.dd介绍dd是UNIX和Linux系统自带的工具，能够以操纵裸设备的方式完成本地磁盘之间的高速复制，跨网络数据复制，以及制作磁盘镜像等功能。

另外dd还能生产固定大小的文件，以很高的速度写入磁盘。

这就为存储测试提供了一个较好的手段，我们可以利用dd生成许多小文件来测试存储的吞吐量（IOPS）指标，而利用dd生成数个大文件来测量存储系统带宽（MB/s）。

2.参数1.if=file 输入文件名，缺省为标准输入。

即指定源文件。

<if=inputfile>2.of=file 输出文件名，缺省为标准输出。

3.ibs=bytes 一次读入bytes个字节，即指定一个块大小为bytes个字节。

4.obs=bytes 一次输出bytes个字节，即指定一个块大小为bytes个字节。

5.bs=bytes 同时设置读入/输出的块大小为bytes个字节。

6.cbs=bytes 一次转换bytes个字节，即指定转换缓冲区大小。

7.skip=blocks 从输入文件开头跳过blocks 个块后再开始复制。

8.seek=blocks 从输出文件开头跳过blocks 个块后再开始复制。

(通常只有当输出文件是磁盘或磁带时才有效,即备份到磁盘或磁带时才有效)。

9.count=blocks 仅拷贝blocks 个块，块大小等于ibs指定的字节数。

10.conv=conversion[,conversion...] 用指定的参数转换文件。

转换参数:ascii 转换EBCDIC 为ASCII。

ebcdic 转换ASCII 为EBCDIC。

ibm 转换ASCII 为alternate EBCDIC.block 把每一行转换为长度为cbs的记录，不足部分用空格填充。

unblock 使每一行的长度都为cbs，不足部分用空格填充。

lcase 把大写字符转换为小写字符。

ucase 把小写字符转换为大写字符。

swab 交换输入的每对字节。

Linux中DD命令详解

2.4.6.将文件sfile拷贝到文件 dfile中。
$ dd if=sfile of=dfile
虚拟机技术 - 把Linux安装在一个文件中（用dd生成虚拟块设备文件）
第一个问题是：什么是虚拟块设备文件？虚拟块设备文件是本人杜撰的一个名称，该类文件在主机操作系统上是普通文件，在虚拟机中作为一个虚拟块设备，也就是虚拟机中的硬盘。在虚拟机中对虚拟块设备的读写，实际都是对主机上该文件的操作。
虚拟块设备文件更通用的名称是硬盘镜像文件(Hard Disk Image)，但不是所有的硬盘镜像文件都是虚拟块设备文件，例如，目前Ghost的GHO格式的镜像文件就不能成为虚拟机中的硬盘。
LInux的dd命令，可以用于生成虚拟块设备文件。既可以用于创建空镜像文件，也可以用于创建物理硬盘的镜像。先看一个实际例子：
一般来说设备文件有两种，一种是块设备，一种是字符设备。块设备的特点是可以随机读写（Random Access），比如内存、硬盘等。字符设备的特点是顺序读写（Sequential Access），比如鼠标，键盘，麦克风等。
前面说了如何生成物理硬盘的镜像，如果想生成空镜像文件（本文的主要目的），还需要一个特殊的设备。/dev/zero是Linux提供的一个特殊的字符设备，它的特点是可以永远读该文件，每次读取的结果都是二进制0。下面的命令可以生成一个100M的空镜像文件：
0+0 records in
0+0 records out
0 bytes (0 B) copied, 3.3e-05 seconds, 0.0 kB/s
# ls -l 1G.img
-rw-r–r– 1 root root 1048576000 Mar 25 15:32 1G.img

Linux下用dd命令测试硬盘的读写速度

Linux下⽤dd命令测试硬盘的读写速度⼀、测试写速度：time dd if=/dev/zero of=/tmp/test bs=8k count=1000000测试结果：565 MB/s⼆、测试读速度：time dd if=/tmp/test of=/dev/null bs=8k测试结果：4.7GB/s三、测试读写速度：time dd if=/tmp/test of=/var/test bs=64k测试结果：387MB/s四、参数说明①、time有计时作⽤，dd⽤于复制，从if读出，写到of；②、if=/dev/zero不产⽣IO，因此可以⽤来测试纯写速度；③、同理of=/dev/null不产⽣IO，可以⽤来测试纯读速度；④、将/tmp/test拷贝到/var则同时测试了读写速度；⑤、bs是每次读或写的⼤⼩，即⼀个块的⼤⼩，count是读写块的数量。

实例测试：[root@gpu-server-003 tmp]# time dd if=/dev/zero of=/mnt2/test bs=8k count=10000001000000+0 records in1000000+0 records out8192000000 bytes (8.2 GB) copied, 5.60322 s, 1.5 GB/sreal 0m5.620suser 0m0.078ssys 0m5.525s[root@gpu-server-003 tmp]#[root@gpu-server-003 tmp]# time dd if=/dev/zero of=/mnt/test bs=8k count=10000001000000+0 records in1000000+0 records out8192000000 bytes (8.2 GB) copied, 6.41214 s, 1.3 GB/sreal 0m6.414suser 0m0.097ssys 0m6.318s[root@gpu-server-003 tmp]#You have new mail in /var/spool/mail/root[root@gpu-server-003 tmp]#[root@gpu-server-003 tmp]# time dd if=/mnt2/test of=/dev/null bs=8k1000000+0 records in1000000+0 records out8192000000 bytes (8.2 GB) copied, 1.62227 s, 5.0 GB/sreal 0m1.624suser 0m0.082ssys 0m1.541s[root@gpu-server-003 tmp]#[root@gpu-server-003 tmp]# time dd if=/mnt/test of=/dev/null bs=8k 1000000+0 records in1000000+0 records out8192000000 bytes (8.2 GB) copied, 1.81242 s, 4.5 GB/sreal 0m1.814suser 0m0.073ssys 0m1.739s。

Linux命令高级技巧使用df和du查看磁盘使用情况

Linux命令高级技巧使用df和du查看磁盘使用情况在Linux系统中，了解磁盘的使用情况对于系统管理员和开发人员来说是非常重要的。

df（disk free）和du（disk usage）是两个常用的命令，可以帮助我们查看磁盘的使用情况。

本文将介绍如何使用df和du命令以及一些高级技巧来更好地管理磁盘空间。

一、使用df命令查看磁盘使用情况df命令用于显示文件系统的磁盘空间使用情况。

它提供了有关磁盘分区的信息，包括总空间、已用空间和可用空间等。

以下是一些常用的df命令选项：1. df -h：以易读的方式显示磁盘使用情况，以G、M等单位显示磁盘空间大小。

2. df -T：显示文件系统的类型，如ext4、ntfs等。

3. df -i：显示inode的使用情况，inode是Linux文件系统中的数据结构，用于存储文件元数据。

4. df -a：显示所有文件系统，包括特殊的系统文件系统。

5. df -x <文件系统类型>：排除指定类型的文件系统。

二、使用du命令查看磁盘使用情况du命令用于显示目录或文件的磁盘空间使用情况。

它可以递归地计算目录中所有文件和子目录的总大小。

以下是一些常用的du命令选项：1. du -h：以易读的方式显示目录或文件的磁盘空间使用情况。

2. du -s：只显示目录或文件的总大小，不显示每个子目录的详细情况。

3. du -c：显示目录或文件的总大小，并在最后显示总和。

4. du -a：显示目录或文件的大小，包括隐藏文件和目录。

5. du -x：仅计算指定文件系统内的磁盘空间使用情况。

三、高级技巧：使用管道和重定向使用管道和重定向可以将df和du命令与其他命令结合使用，可以更好地管理磁盘空间。

以下是一些常见的用法：1. 使用管道将df的输出传递给du命令：df -h | du -sh这个命令将df的输出作为du的输入，并以易读的方式显示总磁盘使用情况。

2. 使用重定向将du的结果保存到文件中：du -h > disk_usage.txt这个命令将du的输出保存到名为disk_usage.txt的文件中，您可以随时查看该文件以了解磁盘的使用情况。

Linux命令高级技巧使用dd命令进行磁盘读写测试

Linux命令高级技巧使用dd命令进行磁盘读写测试在 Linux 系统中，dd 命令是个非常强大的工具，它可以用来进行磁盘读写测试。

磁盘读写测试对于确保磁盘的稳定性和性能至关重要。

在本文中，我们将了解如何使用 dd 命令进行磁盘读写测试，并介绍一些高级技巧，以满足不同的需求。

一、dd 命令的基本用法dd 命令是用来进行数据转换和复制的工具，它可以在不同的输入和输出之间进行数据转换。

在进行磁盘读写测试时，我们可以使用 dd 命令来模拟读取和写入大量数据的情况，以便测试磁盘的性能和稳定性。

以下是 dd 命令的基本语法：```dd if=input_file of=output_file bs=block_size count=number_of_blocks ```参数说明：- if：表示输入文件，即要读取的数据源文件。

- of：表示输出文件，即写入的目标文件。

- bs：表示块大小，用来控制数据块的大小。

- count：表示要读取或写入的数据块数量。

例如，要创建一个大小为 1GB 的测试文件，可以使用以下命令：```dd if=/dev/zero of=testfile bs=1M count=1024```这个命令会将 `/dev/zero` 中的数据写入到 `testfile` 文件中，每次写入 1MB 的数据，共计写入 1024 个数据块。

二、使用 dd 命令进行磁盘读写测试在进行磁盘读写测试之前，确保您有足够的空间来存储测试数据，同时也要小心，避免在错误的位置进行读写操作。

1. 磁盘读取测试要进行磁盘读取测试，使用以下命令：```dd if=input_file of=/dev/null bs=block_size count=number_of_blocks ```其中，`/dev/null` 是一个特殊的设备文件，写入到该文件的数据将会被丢弃。

为了更准确地测试磁盘读取速度，我们可以使用 `time` 命令来测量耗时，例如：```time dd if=input_file of=/dev/null bs=block_sizecount=number_of_blocks```这样可以获取到读取所耗费的时间。

Linux命令高级技巧使用dd命令进行磁盘备份和恢复

Linux命令高级技巧使用dd命令进行磁盘备份和恢复Linux命令高级技巧：使用dd命令进行磁盘备份和恢复Linux作为一个功能强大的操作系统，提供了众多强大的命令工具，其中dd命令是一个备受关注和广泛应用的工具。

dd命令不仅可以用于创建映像文件，还可以用于磁盘备份和恢复。

本文将介绍如何使用dd命令进行磁盘备份和恢复，以及一些高级技巧的使用。

一、磁盘备份1.1 备份整个磁盘要备份整个磁盘，可以使用以下命令：```sudo dd if=/dev/sda of=/path/to/backup.img```其中，if参数指定输入文件，即待备份的磁盘设备；of参数指定输出文件，即备份的映像文件，可以自定义路径。

1.2 备份指定分区如果只需要备份某个分区，可以使用以下命令：```sudo dd if=/dev/sda1 of=/path/to/backup.img```其中，if参数指定输入文件，即待备份的分区设备；of参数指定输出文件，即备份的映像文件。

二、磁盘恢复2.1 恢复整个磁盘要恢复整个磁盘，可以使用以下命令：```sudo dd if=/path/to/backup.img of=/dev/sda```其中，if参数指定输入文件，即备份的映像文件；of参数指定输出文件，即待恢复的磁盘设备。

2.2 恢复指定分区如果只需要恢复某个分区，可以使用以下命令：```sudo dd if=/path/to/backup.img of=/dev/sda1```其中，if参数指定输入文件，即备份的映像文件；of参数指定输出文件，即待恢复的分区设备。

三、dd命令高级技巧3.1 显示进度dd命令默认情况下不会显示进度，如果想要查看备份或恢复的进度，可以使用pv命令结合dd命令：```sudo dd if=/dev/sda | pv -s 100G | dd of=/path/to/backup.img```其中，-s参数指定了待备份设备的大小，pv命令会显示进度，便于查看备份进度。

18_Linux固态硬盘读写性能测试脚本（fio）

18_Linux固态硬盘读写性能测试脚本（fio）18_Linux 固态硬盘读写性能测试脚本（fio）18.1、配置⽂件{"para_ssd": {"ssd_cpu": {"cpu_enable": 0,"core_num": 3,"time_num": 1,"time_unit": "d"},"ssd_cycle": 3,"ssd_dd": {"dd_bs": "M","dd_init": 500,"dd_step": 50,"dd_fins": 500},"ssd_fio": {"fio_bs": 128,"fio_direct": 1,"fio_iodepth": 1,"fio_ioengine": "libaio","fio_runtime": 60,"fio_size": "500M"},"ssd_mem": {"mem_enable": 0,"mem_proportion": 0.95,"mem_total": 1840},"ssd_png": {"display_interval": 20,"add_yrange": 50,"set_ytics": 20},"ssd_mounted": "/opt/blackbox/data","ssd_temp": "25C","ssd_type": "/dev/nvme0n1"}}18.2、测试脚本#!/bin/bashfunction ssd_function_template(){{fio -ioengine=${fio_ioengine} -bs=$1KB -direct=${fio_direct} -thread -rw=$2 -filename=${ssd_type} -name="BS-$1KB-$2-test" -iodepth=${fio_iodepth} -runtime=${fio_runtime} -size=${fio_size} -group_reporting} |tee /tmp/ssd_$2.loggrep $3 /tmp/ssd_$2.log |grep runt >> ${dir_path}/ssd_$2_$1.log}function ssd_function(){ssd_function_template $1 "read" "read"ssd_function_template $1 "randread" "read"ssd_function_template $1 "write" "write"ssd_function_template $1 "randwrite" "write"}function result_ssd_template(){local ssd_log=$1if [ -f "${ssd_log}" ]thensed -i 's/=/,/g' ${ssd_log}sed -i 's/KB\/s/,KB\/s/' ${ssd_log}local log_bw=/tmp/bw_$2.loglocal bw_sum=0local bw_avg=0{awk -F ',' '{print $4}' ${ssd_log} |awk -F '.' '{print $1}'} > ${log_bw}local count_line=$(wc -l ${log_bw} |awk '{print $1}')while read linedolet bw_sum=bw_sum+$linedone < ${log_bw}let bw_avg=$bw_sum/$count_linelocal log_iops=/tmp/iops_$2.loglocal iops_sum=0local iops_avg=0{awk -F ',' '{print $7}' ${ssd_log}} > ${log_iops}local count_line=$(wc -l ${log_iops} |awk '{print $1}')while read line1dolet iops_sum=iops_sum+$line1done < ${log_iops}let iops_avg=$iops_sum/$count_lineecho "$1,bw_avg,$bw_avg KB/S,iops_avg,$iops_avg"fi}function result_ssd(){{result_ssd_template "${dir_path}/ssd_read_$1.log" "read"result_ssd_template "${dir_path}/ssd_randread_$1.log" "randread"result_ssd_template "${dir_path}/ssd_write_$1.log" "write"result_ssd_template "${dir_path}/ssd_randwrite_$1.log" "randwrite"echo} |tee -a ${dir_path}/ssd_result.logcat ${dir_path}/ssd_result.log >> ${source_path}/log/ssd_result.log}function ssd_size_setting(){if [ "${mem_enable}" -eq 1 ]thenlocal bigfile=${ssd_path}/bigfile[ -f "${bigfile}" ] && rm ${bigfile}local mem_total=$(jq -r '.para_ssd.ssd_mem.mem_total' config.json)local mem_threshold=$(jq -r '.para_ssd.ssd_mem.mem_proportion' config.json) local mem_actual_per=$(df /dev/nvme0n1 |awk '{print $5}'|tail -1)local mem_actual=0.$(echo "$mem_actual_per" |awk -F "%" '{print $1}')local mem_compare=$(echo "${mem_actual} < ${mem_threshold}" |bc)if [ "${mem_compare}" -eq 1 ]thenlocal mem_diff=$(echo "${mem_threshold} - ${mem_actual}" |bc)local mem_diff_size=$(echo "${mem_total} * ${mem_diff}" |bc)fallocate -l ${mem_diff_size}G ${ssd_path}/bigfilefifimem_actual_use=$(df /dev/nvme0n1 |awk '{print $5}'|tail -1)}function ssd_depend_package(){which bc > /dev/nullif [ "$?" -ne 0 ]thenlocal platform=$(uname -m)if [ "${platform}" == "armv7l" ]thendpkg -i ${source_path}/lib/deb_package/bb_bc/bc_1.06.95-9build1_armhf.deb fifi}function ssd_config_check(){# ssd type and ssd mount path detectionif [ -b "${ssd_type}" ]thenlocal mounted_path=$(df -h |grep "${ssd_type}" |awk '{print $6}')if [ -d "${mounted_path}" ]thenumount -l ${mounted_path}fielseprintf "${source_path}/config.json \"para_ssd.ssd_type\" error or not exist\n"exit 1fi}function ssd_cpu_stress(){# cpu N core stressif [ "${cpu_enable}" -eq 1 ]thenlocal cpu_time_num=$(jq -r ".para_ssd.ssd_cpu.time_num" ${source_path}/config.json) local cpu_time_unit=$(jq -r ".para_ssd.ssd_cpu.time_unit" ${source_path}/config.json) stress-ng -c ${cpu_num} -t ${cpu_time_num}${cpu_time_unit}fi}function ssd_cpu_stress_ctrlc(){local pid_stress=$(pgrep stress-ng)local pid_num=$(echo "${pid_stress}" |wc -l)if [ "${pid_num}" -gt 0 ]thenlocal platform=$(uname -m)if [ "${platform}" == "armv7l" ]thenfor i in $(echo "$pid_stress")dokill -9 $idoneelif [ "${platform}" == "aarch64" ]thensudo killall stress-ng &> ${c_d_null}fifiprintf "$$\n" |xargs kill -9}function ssd_test_condition(){cat <<-eof[$(date "+%T")] platform : $(uname -m)[$(date "+%T")] ssd type : ${ssd_type}[$(date "+%T")] cpu enable : ${cpu_enable}[$(date "+%T")] cpu num : ${cpu_num}00%[$(date "+%T")] mem enable : ${mem_enable}[$(date "+%T")] mem use : ${mem_actual_use}[$(date "+%T")] fio bs : ${fio_bs}KB[$(date "+%T")] fio direct : ${fio_direct}[$(date "+%T")] fio iodepth : ${fio_iodepth}[$(date "+%T")] fio ioengine: ${fio_ioengine}[$(date "+%T")] fio runtime : ${fio_runtime}[$(date "+%T")] fio size : ${fio_size}[$(date "+%T")] test temp : ${ssd_temp}eofsleep 2}function ssd_png_set(){which gnuplot > /dev/nullif [ "$?" -eq 0 ]thenecho "set terminal png size 1280,720set output \"${dir_path}/ssd_speed_fio.png\"set border lc rgb \"orange\"set multiplot layout 1,2set grid x,y lc rgb \"orange\"set datafile sep ','set key box reverseset xlabel \"${fio_bs}KB\" font \",15\"set xrange [-1:$ssd_cycle]set ytics $ssd_png_yticsset origin 0,0set title \"FIO Sequential $$ssd_type$\n$Temp: $ssd_temp; CPU: $cpu_enable-$cpu_num; Disk-Use: $mem_actual_use$\" font \",16\" set ylabel \"KB/s\" font \",15\"plot \"$dir_path/ssd_read_$1.log\" u 4 smooth csplines w l lc 1 lw 2 t \"Read\",\\"$dir_path/ssd_write_$1.log\" u 4 smooth csplines w l lc 6 lw 2 t \"Write\"set origin 0.5,0set title \"FIO Random $$ssd_type$\n$Temp: $ssd_temp; CPU: $cpu_enable-$cpu_num; Disk-Use: $mem_actual_use$\" font \",16\" set ylabel \"IOps\" font \",15\"plot \"$dir_path/ssd_randread_$1.log\" u 7 smooth csplines w l lc 1 lw 2 t \"Read\",\\"$dir_path/ssd_randwrite_$1.log\" u 7 smooth csplines w l lc 6 lw 2 t \"Write\" " |gnuplotfi}function ssd_stress_excute(){for ((i=1;i<=${ssd_cycle};i++))dossd_function ${fio_bs} && echodoneresult_ssd ${fio_bs}ssd_png_set ${fio_bs}}function main(){local source_path=$(pwd)local c_d_null=/dev/nulllocal c_d_zero=/dev/zerolocal cpu_enable=$(jq -r ".para_ssd.ssd_cpu.cpu_enable" ${source_path}/config.json)local cpu_num=$(jq -r ".para_ssd.ssd_cpu.core_num" ${source_path}/config.json)local fio_bs=$(jq -r ".para_ssd.ssd_fio.fio_bs" ${source_path}/config.json)local fio_direct=$(jq -r ".para_ssd.ssd_fio.fio_direct" ${source_path}/config.json)local fio_iodepth=$(jq -r ".para_ssd.ssd_fio.fio_iodepth" ${source_path}/config.json)local fio_ioengine=$(jq -r ".para_ssd.ssd_fio.fio_ioengine" ${source_path}/config.json)local fio_runtime=$(jq -r ".para_ssd.ssd_fio.fio_runtime" ${source_path}/config.json)local fio_size=$(jq -r ".para_ssd.ssd_fio.fio_size" ${source_path}/config.json)local mem_enable=$(jq -r ".para_ssd.ssd_mem.mem_enable" ${source_path}/config.json)local ssd_cycle=$(jq -r ".para_ssd.ssd_cycle" ${source_path}/config.json)local ssd_path=$(jq -r ".para_ssd.ssd_mounted" ${source_path}/config.json)local ssd_temp=$(jq -r ".para_ssd.ssd_temp" ${source_path}/config.json)local ssd_type=$(jq -r ".para_ssd.ssd_type" ${source_path}/config.json)local dir_date=$(date "+%Y-%m-%d-%H-%M-%S")local dir_path=${source_path}/log/ssd_speed_${fio_bs}kb_cpu_${cpu_enable}_${cpu_num}00/${dir_date} trap "ssd_cpu_stress_ctrlc" HUP INT QUITtrap "ssd_cpu_stress_ctrlc" EXIT[ ! -d ${dir_path} ] && mkdir -p ${dir_path}ssd_config_checkssd_depend_packagessd_size_settingssd_test_conditionssd_cpu_stress &ssd_stress_excute}main。

linux命令--磁盘命令dd

linux命令--磁盘命令dd⽹上dd命令的⽂章有很多，这⾥只是⾃⼰做下简单的记录。

dd命令介绍作⽤是⽤指定⼤⼩的块拷贝⼀个⽂件，并在拷贝的同时进⾏指定的转换。

可以⽤于测试磁盘命令、数据备份或恢复等。

dd命令⽤于复制⽂件并对原⽂件的内容进⾏转换和格式化处理。

⽤的⽐较多的还是⽤dd来备份裸设备。

但是不推荐，如果需要备份oracle裸设备，可以使⽤rman备份，或使⽤第三⽅软件备份，使⽤dd的话，管理起来不太⽅便。

建议在有需要的时候使⽤dd 对物理磁盘操作，如果是⽂件系统的话还是使⽤ backup 等其他命令更加⽅便。

另外，使⽤dd对磁盘操作时，最好使⽤块设备⽂件。

dd --help 打印帮助dd 命令通⽤语法格式如下：dd [bs=<字节数>][cbs=<字节数>][conv=<关键字>][count=<区块数>][ibs=<字节数>][if=<⽂件>][obs=<字节数>][of=<⽂件>][seek=<区块数>][skip=<区块数>][--help][--version]dd if=path/to/input_file of=/path/to/output_file bs=block_size count=number_of_blocks命令简介主要选项（指定数字的地⽅若以下列字符结尾乘以相应的数字: b=512, c=1, k=1024, w=2, xm=number m）：if=file 输⼊⽂件名，缺省为标准输⼊。

从file读取，如if=/dev/zero,该设备⽆穷尽地提供0,（不产⽣读磁盘IO）of=file 输出⽂件名，缺省为标准输出。

向file写出，可以写⽂件，可以写裸设备。

如of=/dev/null，"⿊洞"，它等价于⼀个只写⽂件. 所有写⼊它的内容都会永远丢失. （不产⽣写磁盘IO）ibs=bytes ⼀次读⼊ bytes 个字节(即⼀个块⼤⼩为 bytes 个字节)。

linux检测磁盘读写速度

linux检测磁盘读写速度环境：centos71、查看当前系统读写情况yum -y install iotop #安装iotop⼯具[root@demod ~]# iotopTotal DISK READ : 0.00 B/s | Total DISK WRITE : 0.00 B/sActual DISK READ: 0.00 B/s | Actual DISK WRITE: 0.00 B/sTID PRIO USER DISK READ DISK WRITE SWAPIN IO> COMMAND1 be/4 root 0.00 B/s 0.00 B/s 0.00 % 0.00 % systemd --switched-root --system --deserialize 212 be/4 root 0.00 B/s 0.00 B/s 0.00 % 0.00 % [kthreadd]3 be/4 root 0.00 B/s 0.00 B/s 0.00 % 0.00 % [ksoftirqd/0]注：DISK TEAD:n=磁盘读/每秒 DISK WRITE:n=磁盘写/每秒。

2、dd命令解析Usage: dd [OPERAND]... #⽤指定⼤⼩的块拷贝⼀个⽂件，并在拷贝的同时进⾏指定的转换。

if=⽂件名：输⼊⽂件名，缺省为标准输⼊。

即指定源⽂件。

< if=input file >of=⽂件名：输出⽂件名，缺省为标准输出。

即指定⽬的⽂件。

< of=output file >ibs=bytes：⼀次读⼊bytes个字节，即指定⼀个块⼤⼩为bytes个字节。

obs=bytes：⼀次输出bytes个字节，即指定⼀个块⼤⼩为bytes个字节。

bs=bytes：同时设置读⼊/输出的块⼤⼩为bytes个字节。

cbs=bytes：⼀次转换bytes个字节，即指定转换缓冲区⼤⼩。

Linux下使用 dd测试硬盘性能

dd测试硬盘性能下面直接介绍几种常见的DD命令，先看一下他的区别~dd bs=64k count=4k if=/dev/zero of=testdd bs=64k count=4k if=/dev/zero of=test; syncdd bs=64k count=4k if=/dev/zero of=test conv=fdatasyncdd bs=64k count=4k if=/dev/zero of=test oflag=dsync这四条DD命令区别在于内存中写缓存的处理方式。

1.dd bs=64k count=4k if=/dev/zero of=test没有加任何参数，dd默认的方式不包括“同步(sync)”命令。

也就是说，dd命令完成前并没有让系统真正把文件写到磁盘上。

所以以上命令只是单纯地把这128MB的数据读到内存缓冲当中（写缓存[write cache]）。

所以你得到的将是一个超级快的速度。

因为其实dd给你的只是读取速度，直到dd完成后系统才开始真正往磁盘上写数据，但这个速度你是看不到了。

所以如果这个速度很快，没有什么作用。

实际运行结果：268435456 bytes (268 MB) copied, 1.3529 seconds, 198 MB/s2.dd bs=64k count=4k if=/dev/zero of=test; sync和前面1中的完全一样。

分号隔开的只是先后两个独立的命令。

当sync命令准备开始往磁盘上真正写入数据的时候，前面dd命令已经把错误的“写入速度”值显示在屏幕上了。

所以你还是得不到真正的写入速度。

实际运行结果：268435456 bytes (268 MB) copied, 0.522815 seconds, 513 MB/s3.dd bs=64k count=4k if=/dev/zero of=test conv=fdatasync加入这个参数后，dd命令执行到最后会真正执行一次“同步(sync)”操作，所以这时候你得到的是读取这128M数据到内存并写入到磁盘上所需的时间，这样算出来的时间才是比较符合实际使用结果的。

dd测试硬盘读写速度

因为/dev/sdb1是一个物理分区，对它的读取会产生IO，/dev/null是伪设备，相当于黑洞，of到该设备不会产生IO，所以，这个命令的IO只发生在/dev/sdb1上，也相当于测试磁盘的读能力
输出的结果类似：
448494+0 records in
448494+0 records out
300000+0 records in
300000+0 records out
real 0m36.669s
user 0m0.185s
sys 0m9.340s
所以写速度为：8*300000/1024/36.669=63.916M/s
读速度：
time dd if=/dev/sda1 of=/dev/null bs=8k
real 0m51.070s
user 0m0.054s
sys 0m10.028s
所以sda1上的读取速度为：8*448494/1024/51.070=68.61M/s
补充：Windows下安装Cygwin也可以使用time和dd命令，而且输出结果中直接包含IO的时间和速度，有兴趣的朋友可以试一下，不过我测试下来的速度读写都只有40多M每秒，不知道是否是平台的原因，可能Cygwin的机制和Linux下还是有所不同吧。
写速ห้องสมุดไป่ตู้：
time dd if=/dev/zero of=test.dbf bs=8k count=300000
其中/dev/zero是一个伪设备，它只产生空字符流，对它不会产生IO，所以，IO都会集中在of文件中，of文件只用于写，所以这个命令相当于测试磁盘的写能力。
输出的结果类似(因为一般更长测试时间更准确，所以可以设置count大一些)：

linux硬盘测试与测速

1.测/目录所在磁盘的纯写速度：time dd if=/dev/zero bs=1024 count=1000000 of=/1Gb.file从空介质产生一个1G文件放在根目录下文件名为1Gb.file。

2.测/目录所在磁盘的纯读速度：time dd if=/1Gb.file bs=64k |dd of=/dev/null将刚才产生那个文件复制到空介质里，等于纯读抛空。

3.测读写速度：time dd if=/1Gb.file of=/data0/1Gb2.file bs=64k从根下将1G文件复制为1Gb2.file这个文件，相当于读写。

注意：测试的目录要能放下这两个文件，测试完删除1GB.file和1Gb2.file 文件，否则浪费2G空间。

在Linux下可以使用hdparm对硬盘进行测试或者查看硬盘的相关信息。

这样你就知道了硬盘读写速度。

hdparm参数：-a 表示是否关闭磁盘预读取功能。

对于大文件读取，这个显然能提高性能。

-A设置硬盘驱动器缓存读取特性。

可能就是硬盘缓存开关-g 显示硬盘的磁轨，磁头，磁区等参数。

-i 显示硬盘的硬件规格信息，这些信息是在开机时由硬盘本身所提供。

-I 直接读取硬盘所提供的硬件规格信息。

-p 设定硬盘的PIO模式。

-Tt 评估硬盘的读取效率和硬盘快取的读取效率。

-u; 在硬盘存取时，允许其他中断要求同时执行。

-v 显示硬盘的相关设定。

1）直接硬盘读测试[root@apktv ~]# hdparm -tT --direct /dev/sda1/dev/sda1:Timing O_DIRECT cached reads: 704 MB in 2.00 seconds = 351.50 MB/sec HDIO_DRIVE_CMD(null) (wait for flush complete) failed: Inappropriate ioctl for deviceTiming O_DIRECT disk reads: 546 MB in 3.01 seconds = 181.43 MB/sec HDIO_DRIVE_CMD(null) (wait for flush complete) failed: Inappropriate ioctl for device使用DMA方式传输数据可以占用更少的CPU资源，因此与其它操作系统一样，Linux支持硬盘以DMA方式转输数据，但在安装Red Hat7.0时关于DMA的默认选项是Disable的，当然你可以在安装时就enable它。

ddif=devzeroof=的含义是什么linux下的dd命令使用详解

dd if=devzero of=的含义是什么？Linux 下的dd命令使用详解一、dd命令的解释dd：用指定大小的块拷贝一个文件，并在拷贝的同时进行指定的转换。

注意：指定数字的地方若以下列字符结尾，则乘以相应的数字：b=512；c=1；k=1024；w=2参数注释：1. if=文件名：输入文件名，缺省为标准输入。

即指定源文件。

< if=input file>2. of=文件名：输出文件名，缺省为标准输出。

即指定目的文件。

< of=output file>3. ibs=bytes：一次读入bytes个字节，即指定一个块大小为bytes个字节。

obs=bytes：一次输出bytes个字节，即指定一个块大小为bytes个字节。

bs=bytes：同时设置读入/输出的块大小为bytes个字节。

4. cbs=bytes：一次转换bytes个字节，即指定转换缓冲区大小。

5. skip=blocks：从输入文件开头跳过blocks个块后再开始复制。

6. seek=blocks：从输出文件开头跳过blocks个块后再开始复制。

注意：通常只用当输出文件是磁盘或磁带时才有效，即备份到磁盘或磁带时才有效。

7. count=blocks：仅拷贝blocks个块，块大小等于ibs指定的字节数。

8. conv=conversion：用指定的参数转换文件。

ascii：转换ebcdic为asciiebcdic：转换ascii为ebcdicibm：转换ascii为alternate ebcdicblock：把每一行转换为长度为cbs，不足部分用空格填充unblock：使每一行的长度都为cbs，不足部分用空格填充lcase：把大写字符转换为小写字符ucase：把小写字符转换为大写字符swab：交换输入的每对字节noerror：出错时不停止notrunc：不截短输出文件sync：将每个输入块填充到ibs个字节，不足部分用空（NUL）字符补齐。

Linux中ramdisk,tmpfs,ramfs的介绍与读写速度测试

测试手段：1dd if=/dev/zero of=tmp bs=1M count=10用dd命令测试瞬间写的能力。

新增利用iozone命令测试内存盘性能：1iozone -a -i 1 -i 0 -c -g 5M -n 1M测试项包括写入，重复写入，读出，重复读出横坐标是测试的时候写入读出的快文件大小，纵坐标是每秒的写入读出的字节数RamDisk有三种实现方式:在Linux中可以将一部分内存mount为分区来使用，通常称之为RamDisk，分为:Ramdisk, ramfs, tmpfs.①第一种就是传统意义上的，可以格式化，然后加载。

这在Linux内核2.0/2.2就已经支持，其不足之处是大小固定，之后不能改变。

为了能够使用Ramdisk，我们在编译内核时须将block device中的Ramdisk支持选上，它下面还有两个选项，一个是设定Ramdisk的大小，默认是4096k;另一个是initrd的支持。

如果对Ramdisk的支持已经编译进内核，我们就可以使用它了:首先查看一下可用的RamDisk，使用ls /dev/ram*首先创建一个目录，比如test，运行mkdir /mnt/test;然后对/dev/ram0 创建文件系统，运行mke2fs /dev/ram0;最后挂载/dev/ram0，运行mount /dev/ram /mnt/test，就可以象对普通硬盘一样对它进行操作了。

装载后写入速度在700M/S-800M/S之间，如果umount再加载，只要不重启linux，那文件依然会保存在/dev/ramX中。

②另两种则是内核2.4才支持的，通过Ramfs或者Tmpfs来实现:它们不需经过格式化，用起来灵活，其大小随所需要的空间而增加或减少。

Ramfs顾名思义是内存文件系统，它处于虚拟文件系统(VFS)层，而不像ramdisk那样基于虚拟在内存中的其他文件系统(ex2fs)。

因而，它无需格式化，可以创建多个，只要内存足够，在创建时可以指定其最大能使用的内存大小。

dd命令进行硬盘IO性能检测讲述

dd 命令进行硬盘I/O 性能检测如何使用dd命令测试我的硬盘性能？如何在linux操作系统下检测硬盘的读写速度？你可以使用以下命令在一个Linux或类Unix操作系统上进行简单的I/O性能测试。

•dd命令：它被用来在Linux和类Unix系统下对硬盘设备进行写性能的检测。

•hparm命令：它用来在基于Linux 的系统上获取或设置硬盘参数，包括测试读性能以及缓存性能等。

在这篇指南中，你将会学到如何使用dd命令来测试硬盘性能。

使用dd命令来监控硬盘的读写性能：•打开shell终端。

•或者通过ssh登录到远程服务器。

•使用dd命令来测量服务器的吞吐率（写速度) dd if=/dev/zero of=/tmp/test1.img bs=1G count=1 oflag=dsync•使用dd命令测量服务器延迟dd if=/dev/zero of=/tmp/test2.img bs=512 count=1000 oflag=dsync理解dd命令的选项在这个例子当中，我将使用搭载Ubuntu Linux 14.04 LTS系统的RAID-10（配有SAS SSD的Adaptec 5405Z）服务器阵列来运行。

基本语法为：1.dd if=/dev/input.file of=/path/to/output.file bs=block-sizecount=number-of-blocks oflag=dsync2.## GNU dd语法##3.dd if=/dev/zero of=/tmp/test1.img bs=1G count=1 oflag=dsync4.##另外一种GNU dd的语法##5.dd if=/dev/zero of=/tmp/testALT.img bs=1G count=1 conv=fdatasync输出样例：图01: 使用dd命令获取的服务器吞吐率请各位注意在这个实验中，我们写入一个G的数据，可以发现，服务器的吞吐率是135 MB/s，这其中•if=/dev/zero (if=/dev/input.file) ：用来设置dd命令读取的输入文件名。

使用dd命令在Linux系统中进行磁盘和分区操作

使用dd命令在Linux系统中进行磁盘和分区操作在Linux系统中，磁盘和分区操作是系统管理的重要一环。

使用dd命令，我们可以进行磁盘镜像、分区备份和数据恢复等操作。

本文将详细介绍dd命令的使用方法和相关技巧。

一、磁盘镜像磁盘镜像是将整个磁盘的数据完全复制到一个文件中，以便在需要时进行还原或备份。

使用dd命令可以方便地进行磁盘镜像操作。

以下是dd命令进行磁盘镜像的基本格式：```dd if=/dev/sda of=/path/to/image.img```其中，if代表输入文件（源磁盘），of代表输出文件（目标文件）。

我们需要根据实际情况替换这些路径。

执行该命令后，dd将会逐扇区地复制磁盘的数据到目标文件中。

如果你希望显示dd命令的进度，可以添加progress参数：```dd if=/dev/sda of=/path/to/image.img status=progress```二、分区备份和恢复除了整个磁盘镜像，我们还可以使用dd命令备份和恢复单个分区。

以下是使用dd命令进行分区备份和恢复的基本格式：备份分区：```dd if=/dev/sda1 of=/path/to/partition.img```恢复分区：```dd if=/path/to/partition.img of=/dev/sda1```其中，if代表输入文件（源分区），of代表输出文件（目标分区）。

需要注意的是，恢复分区时应谨慎操作，以免覆盖重要数据。

三、填充磁盘空间在某些情况下，我们可能需要填充磁盘空间以保护隐私或提高磁盘性能。

dd命令可以帮助我们生成指定大小的随机数据，并将其写入磁盘中。

以下是填充磁盘空间的dd命令示例：```dd if=/dev/urandom of=/path/to/file bs=1M count=1024```上述命令将生成一个1GB大小的随机数据文件，并将其写入指定路径的文件中。

我们可以根据需要调整文件的大小（count参数）和写入的位置（of参数）。

dd 的用法详解

linux下dd命令详解名称: dd使用权限: 所有使用者dd 这个指令在 manual 里的定义是 convert and copy a file使用方式:dd [option]如果你想要在线看 manual, 可以试试:dd --help或是info dd如果你想要看看这个版本如何:dd --version输入或输出dd if=[STDIN] of=[STDOUT]强迫输入或输出的Size为多少Bytesbs: dd -ibs=[BYTE] -obs=[SIZE]强迫一次只做多少个 Bytescbs=BYTES跳过一段以后才输出seek=BLOCKS跳过一段以后才输入skip=BLOCKS当然你可以拿这个来方便的拷贝光碟(注意，你的光碟是标准的 iso9660格式才可以这么做唷！)dd if=/dev/cdrom of=cdrom.iso其中 if 后面以及 of 后面的内容依你的需求调整。

然后给系统这个指令就可以烧了:cdrecord -v cdrom.iso这篇不是在讲 cdrecord 的，所以上面的指令是最为简单但是不一定能符合您的硬件环境...功能：把指定的输入文件拷贝到指定的输出文件中，并且在拷贝过程中可以进行格式转换。

可以用该命令实现DOS下的diskcopy命令的作用。

先用dd命令把软盘上的数据写成硬盘的一个寄存文件，再把这个寄存文件写入第二张软盘上，完成diskcopy的功能。

需要注意的是，应该将硬盘上的寄存文件用rm命令删除掉。

系统默认使用标准输入文件和标准输出文件。

语法：dd [选项]if =输入文件（或设备名称）。

of =输出文件（或设备名称）。

ibs = bytes 一次读取bytes字节，即读入缓冲区的字节数。

skip = blocks 跳过读入缓冲区开头的ibs*blocks块。

obs = bytes 一次写入bytes字节，即写入缓冲区的字节数。

bs = bytes 同时设置读/写缓冲区的字节数（等于设置ibs和obs）。

dd命令详解及实例

dd if=/dev/zero of=的含义是什么？Linux 下的dd命令使用详解(2012-07-25 18:08:36)分类： linux标签：it一、dd命令的解释dd：用指定大小的块拷贝一个文件，并在拷贝的同时进行指定的转换。

注意：指定数字的地方若以下列字符结尾，则乘以相应的数字：b=512；c=1；k=1024；w=2 参数注释：1. if=文件名：输入文件名，缺省为标准输入。

即指定源文件。

< if=input file >2. of=文件名：输出文件名，缺省为标准输出。

即指定目的文件。

< of=output file >3. ibs=bytes：一次读入bytes个字节，即指定一个块大小为bytes个字节。

obs=bytes：一次输出bytes个字节，即指定一个块大小为bytes个字节。

bs=bytes：同时设置读入/输出的块大小为bytes个字节。

4. cbs=bytes：一次转换bytes个字节，即指定转换缓冲区大小。

5. skip=blocks：从输入文件开头跳过blocks个块后再开始复制。

6. seek=blocks：从输出文件开头跳过blocks个块后再开始复制。

注意：通常只用当输出文件是磁盘或磁带时才有效，即备份到磁盘或磁带时才有效。

7. count=blocks：仅拷贝blocks个块，块大小等于ibs指定的字节数。

8. conv=conversion：用指定的参数转换文件。

ascii：转换ebcdic为asciiebcdic：转换ascii为ebcdicibm：转换ascii为alternate ebcdicblock：把每一行转换为长度为cbs，不足部分用空格填充unblock：使每一行的长度都为cbs，不足部分用空格填充lcase：把大写字符转换为小写字符ucase：把小写字符转换为大写字符swab：交换输入的每对字节noerror：出错时不停止notrunc：不截短输出文件sync：将每个输入块填充到ibs个字节，不足部分用空（NUL）字符补齐。

linux 硬盘dd 最后一段

linux 硬盘dd 最后一段-概述说明以及解释1.引言1.1 概述概述Linux操作系统是一个开源的自由操作系统，被广泛应用于服务器、个人电脑和嵌入式设备等各种平台。

在Linux系统中，DD命令是一种非常强大且常用的工具，它可以对硬盘或其他设备进行直接读写操作。

DD命令的全称是“数据传输”。

它能够以块为单位进行数据传输，并且能够以多种形式读取和写入数据。

因为其灵活性和高效性，DD命令在Linux的系统管理、数据恢复、系统备份和硬盘克隆等方面具有重要的应用价值。

本篇文章旨在介绍DD命令的基本信息和常用参数，探讨其在Linux 硬盘克隆中的应用，以及需要注意的事项。

同时，还将总结DD命令的优点和缺点，并提出推荐和建议。

最后，还将探讨DD命令在Linux系统中的重要性，并对其未来发展进行展望。

通过本文的阅读，读者将能够了解DD命令的基础知识，掌握其常用参数的用法，并了解其在Linux硬盘克隆中的实际应用。

同时，读者还将对DD命令的优缺点有清晰的认识，并能够根据实际需求给出相应的推荐和建议。

最后，读者将认识到DD命令在Linux系统中的重要性，并对其未来的发展方向有一定的了解。

希望通过本文的撰写和阅读能够提高读者对DD命令的理解和运用能力，进一步推动Linux系统的发展和应用。

文章结构部分的内容如下：文章结构本文将分为三个主要部分，每个部分都包含多个小节，具体结构如下：1. 引言1.1 概述1.2 文章结构1.3 目的1.4 总结2. 正文2.1 DD命令的基本介绍2.2 DD命令的常用参数2.3 DD命令在Linux硬盘克隆中的应用2.4 DD命令的注意事项3. 结论3.1 总结DD命令的优点和缺点3.2 对DD命令的推荐和建议3.3 DD命令在Linux系统中的重要性3.4 展望DD命令的未来发展在引言部分，我们将首先对整篇文章进行概述，介绍本文的主要内容和目的。

然后，我们将详细介绍文章的结构，包括各个部分和各个小节的内容，以便读者能够更好地理解文章的框架。