ssd_status.sh

SUBMITTED BY: Guest

DATE: Dec. 5, 2013, 7:16 a.m.

FORMAT: Bash

SIZE: 9.3 kB

Raw Download

HITS: 683

Report
  1. #!/bin/bash
  3. ######################################################
  4. ##### #####
  5. ##### Configuration section #####
  6. ##### #####
  7. ######################################################
  9. ## Path to smartctl binary of smartmontools (version has to be >= 5.39)
  10. ## If unset systemwide smartctl is used if found.
  11. SMARTCTL="./smartctl"
  13. ## Path to logfile. Leave empty or comment out to disable logging.
  14. LOGFILE="./ssdlog.csv"
  16. ## Unit used for logging of read/written data.
  17. ## Possible values: B, KB, MB, GB, KiB, MiB, GiB, b, Kb, Mb, Gb, Kib, Mib, Gib
  18. ## Small "b" refers to bit, capital "B" to Byte.
  19. ## Units with an "i" are binary based (1 KiB = 1024 Byte)
  20. ## whereas units without are decimal based (1 KB = 1000 Byte)
  21. LOG_SIZE_UNIT="MiB"
  23. ## Number of decimals used for logging of read/written data.
  24. LOG_SIZE_DEZIMALS=0
  28. ######################################################
  29. ##### #####
  30. ##### END OF #####
  31. ##### Configuration section #####
  32. ##### #####
  33. ######################################################
  37. check_root() {
  38. if [[ $EUID -ne 0 ]]; then
  39. echo "This script must be run as root" 1>&2
  40. exit 1
  41. fi
  42. }
  45. check_device() {
  46. if [[ -z "$1" ]]
  47. then
  48. DEVICE="/dev/sda"
  49. else
  50. DEVICE="$1"
  51. fi
  53. if [ ! -b "${DEVICE}" ]
  54. then
  55. if [ ! -b "/dev/${DEVICE}" ]
  56. then
  57. echo "No device given or given device not a block device."
  58. echo "Call this script with the devicename of the SSD."
  59. echo "E.g.: ./ssd.sh /dev/sda"
  60. exit 1
  61. else
  62. DEVICE="/dev/${DEVICE}"
  63. fi
  64. fi
  65. }
  68. change_path() {
  69. OLDDIR=`pwd`
  70. abspath="$(cd "${0%/*}" 2>/dev/null; echo "$PWD"/"${0##*/}")"
  71. path_only=`dirname "$abspath"`
  72. cd ${path_only}
  73. }
  76. check_smartctl() {
  77. if [[ ! -e "${SMARTCTL}" ]]
  78. then
  79. SMARTCTL=`which smartctl`
  80. if [[ "$?" == "1" ]]
  81. then
  82. echo "Path to smartctl not set and smartctl not found in PATH."
  83. echo "ssd_status.sh requires smartctl from smartmontools to run."
  84. exit 1
  85. fi
  86. fi
  87. SMARTCTL_VERSION=`${SMARTCTL} --version | grep "smartctl [0-9]\.[0-9][0-9]" | cut -d\ -f2`
  88. NEWER_539=`echo "${SMARTCTL_VERSION} >= 5.39" | bc -l`
  89. if [[ "${NEWER_539}" == 0 ]]
  90. then
  91. echo "smartctl binary is older than 5.39 (${SMARTCTL} is ${SMARTCTL_VERSION})."
  92. echo "ssd_status.sh requires smartctl to be at least version 5.39 to run."
  93. exit 1
  94. fi
  95. }
  98. get_timedate() {
  99. DATE=`date "+%Y-%m-%d"`
  100. TIME=`date "+%H:%M"`
  101. }
  105. gather_smartinfo() {
  106. SMARTINFO=`${SMARTCTL} ${DEVICE} -i | grep ": " | sed -r 's/ +/*/g'`
  107. for LINE in ${SMARTINFO}
  108. do
  109. if [[ -n `echo ${LINE} | grep -i "device\*model"` ]]
  110. then
  111. MODEL=`echo ${LINE} | cut -d* -f3`
  112. fi
  114. if [[ -n `echo ${LINE} | grep -i "serial\*number"` ]]
  115. then
  116. SERIAL=`echo ${LINE} | cut -d* -f3`
  117. fi
  119. if [[ -n `echo ${LINE} | grep -i "firmware\*version"` ]]
  120. then
  121. FIRMWARE=`echo ${LINE} | cut -d* -f3`
  122. fi
  124. if [[ -n `echo ${LINE} | grep -i "user\*capacity"` ]]
  125. then
  126. SIZE=`echo ${LINE} | cut -d* -f3 | sed 's/\.//g' | sed 's/,//g'`
  127. fi
  128. done
  130. SERIAL_PUBLIC=`echo ${SERIAL} | sed -r "s/.{5}$/*****/"`
  131. }
  135. gather_smartvalues() {
  136. SMARTVALUES=`${SMARTCTL} ${DEVICE} -A -v N,raw64 | grep 0x0000 | sed 's/0x0000.*-//' | sed -r 's/^ +//' | sed -r 's/ +/*/g'`
  137. for LINE in ${SMARTVALUES}
  138. do
  139. ID=`echo ${LINE} | cut -d* -f1`
  140. VALUE=`echo ${LINE} | cut -d* -f3`
  142. if [ "${ID}" = "1" ]; then
  143. RAW_READ_ERROR_RATE=${VALUE}
  144. fi
  146. if [ "${ID}" = "9" ]; then
  147. POWER_ON_HOURS=${VALUE}
  148. fi
  150. if [ "${ID}" = "12" ]; then
  151. POWER_CYCLE_COUNT=${VALUE}
  152. fi
  154. if [ "${ID}" = "184" ]; then
  155. INITIAL_BAD_BLOCK_COUNT=${VALUE}
  156. fi
  158. if [ "${ID}" = "195" ]; then
  159. PROGRAM_FAILURE_BLK_CT=${VALUE}
  160. fi
  162. if [ "${ID}" = "196" ]; then
  163. ERASE_FAILURE_BLK_CT=${VALUE}
  164. fi
  166. if [ "${ID}" = "197" ]; then
  167. READ_FAILURE_BLK_CT=${VALUE}
  168. fi
  170. if [ "${ID}" = "198" ]; then
  171. READ_SECTORS_TOT_CT=${VALUE}
  172. fi
  174. if [ "${ID}" = "199" ]; then
  175. WRITE_SECTORS_TOT_CT=${VALUE}
  176. fi
  178. if [ "${ID}" = "200" ]; then
  179. READ_COMMANDS_TOT_CT=${VALUE}
  180. fi
  182. if [ "${ID}" = "201" ]; then
  183. WRITE_COMMANDS_TOT_CT=${VALUE}
  184. fi
  186. if [ "${ID}" = "202" ]; then
  187. ERROR_BITS_FLASH_TOT_CT=${VALUE}
  188. fi
  190. if [ "${ID}" = "203" ]; then
  191. CORR_READ_ERRORS_TOT_CT=${VALUE}
  192. fi
  194. if [ "${ID}" = "204" ]; then
  195. BAD_BLOCK_FULL_FLAG=${VALUE}
  196. fi
  198. if [ "${ID}" = "205" ]; then
  199. MAX_PE_COUNT_SPEC=${VALUE}
  200. fi
  202. if [ "${ID}" = "206" ]; then
  203. MIN_ERASE_COUNT=${VALUE}
  204. fi
  206. if [ "${ID}" = "207" ]; then
  207. MAX_ERASE_COUNT=${VALUE}
  208. fi
  210. if [ "${ID}" = "208" ]; then
  211. AVERAGE_ERASE_COUNT=${VALUE}
  212. fi
  214. if [ "${ID}" = "209" ]; then
  215. REMAINING_LIFE_TIME=${VALUE}
  216. fi
  217. done
  219. SIZE_B=${SIZE}
  220. SIZE_GiB=`echo "scale=3; ${SIZE_B}/1024/1024/1024" | bc -l`
  221. READ_B=`echo "scale=0; ${READ_SECTORS_TOT_CT}*512" | bc -l`
  222. WRITTEN_B=`echo "scale=0; ${WRITE_SECTORS_TOT_CT}*512" | bc -l`
  223. READ_GiB=`echo "scale=3; ${READ_B}/1024/1024/1024" | bc -l`
  224. WRITTEN_GiB=`echo "scale=3; ${WRITTEN_B}/1024/1024/1024" | bc -l`
  225. }
  229. gather_triminfo() {
  230. TRIMINFO=`hdparm -I ${DEVICE} | grep TRIM`
  231. if [[ -n "${TRIMINFO}" ]]
  232. then
  233. TRIM="Yes"
  234. else
  235. TRIM="No"
  236. fi
  237. }
  241. console_print() {
  242. echo "Model: ${MODEL}"
  243. echo "Serialnumber: ${SERIAL_PUBLIC}"
  244. echo "Firmware / TRIM: ${FIRMWARE} / ${TRIM}"
  245. echo "Size: ${SIZE_GiB} GiB"
  246. echo "Status: ${REMAINING_LIFE_TIME}%"
  247. echo "Power on time: ${POWER_ON_HOURS} hours"
  248. echo "Power cycles: ${POWER_CYCLE_COUNT}"
  249. echo "Cell wear level: ${AVERAGE_ERASE_COUNT} (${MIN_ERASE_COUNT} / ${MAX_ERASE_COUNT}) [avg (min / max)]"
  250. echo "Read: ${READ_GiB} GiB"
  251. echo "Written: ${WRITTEN_GiB} GiB"
  252. }
  255. file_writeheader() {
  256. # echo "SSD status logfile" > ${LOGFILE}
  257. # echo "Generic information:;Model;Serial;Firmware;TRIM;Size" >> ${LOGFILE}
  258. # echo ";${MODEL};${SERIAL_PUBLIC};${FIRMWARE};${TRIM};${SIZE_B}" >> ${LOGFILE}
  259. # echo "" >> ${LOGFILE}
  260. # echo "Log information:" >> ${LOGFILE}
  261. echo "Date;Time;Read;Write;Erase cnt;;;Remaining;Power on;Power;Raw read;Program failure;Erase failure;Read failure;Sectors;;Read;Write;Error bits;Corrected" >> ${LOGFILE}
  262. echo ";;(${LOG_SIZE_UNIT});(${LOG_SIZE_UNIT});Avg;Min;Max;life time;time (hours);cycle cnt;error rate;block count;block count;block count;read;written;commands;commands;flash;read errors" >> ${LOGFILE}
  263. }
  266. file_calculatedatasize() {
  267. case "${LOG_SIZE_UNIT}" in
  268. "B" )
  269. LOG_SIZE_CALC="";;
  270. "KiB" )
  271. LOG_SIZE_CALC="/1024";;
  272. "MiB" )
  273. LOG_SIZE_CALC="/1024/1024";;
  274. "GiB" )
  275. LOG_SIZE_CALC="/1024/1024/1024";;
  276. "KB" )
  277. LOG_SIZE_CALC="/1000";;
  278. "MB" )
  279. LOG_SIZE_CALC="/1000/1000";;
  280. "GB" )
  281. LOG_SIZE_CALC="/1000/1000/1000";;
  282. "b" )
  283. LOG_SIZE_CALC="*8";;
  284. "Kib" )
  285. LOG_SIZE_CALC="*8/1024";;
  286. "Mib" )
  287. LOG_SIZE_CALC="*8/1024/1024";;
  288. "Gib" )
  289. LOG_SIZE_CALC="*8/1024/1024/1024";;
  290. "Kb" )
  291. LOG_SIZE_CALC="*8/1000";;
  292. "Mb" )
  293. LOG_SIZE_CALC="*8/1000/1000";;
  294. "Gb" )
  295. LOG_SIZE_CALC="*8/1000/1000/1000";;
  296. esac
  298. READ=`echo "scale=${LOG_SIZE_DEZIMALS}; ${READ_B}${LOG_SIZE_CALC}" | bc -l`
  299. WRITTEN=`echo "scale=${LOG_SIZE_DEZIMALS}; ${WRITTEN_B}${LOG_SIZE_CALC}" | bc -l`
  300. }
  303. file_writelogentry() {
  304. echo "${DATE};${TIME};${READ};${WRITTEN};${AVERAGE_ERASE_COUNT};${MIN_ERASE_COUNT};${MAX_ERASE_COUNT};${REMAINING_LIFE_TIME};${POWER_ON_HOURS};${POWER_CYCLE_COUNT};${RAW_READ_ERROR_RATE};${PROGRAM_FAILURE_BLK_CT};${ERASE_FAILURE_BLK_CT};${READ_FAILURE_BLK_CT};${READ_SECTORS_TOT_CT};${WRITE_SECTORS_TOT_CT};${READ_COMMANDS_TOT_CT};${WRITE_COMMANDS_TOT_CT};${ERROR_BITS_FLASH_TOT_CT};${CORR_READ_ERRORS_TOT_CT}" >> ${LOGFILE}
  305. }
  307. file_log() {
  308. if [[ ! -e "${LOGFILE}" ]]
  309. then
  310. file_writeheader
  311. fi
  312. file_writelogentry
  313. }
  317. check_root
  318. check_device
  319. change_path
  320. check_smartctl
  322. get_timedate
  324. gather_smartinfo
  325. gather_smartvalues
  326. gather_triminfo
  327. file_calculatedatasize
  329. console_print
  330. if [[ -n "${LOGFILE}" ]]
  331. then
  332. file_log
  333. fi
  335. cd ${OLDDIR}
comments powered by Disqus