[HELP] reading S.M.A.R.T. data

BlitzMax Forums/BlitzMax Programming/[HELP] reading S.M.A.R.T. data

Fielder

(Posted 2016) [#1]

i found some code.. (2013)

http://www.know24.net/blog/C+WMI+HDD+SMART+Information.aspx

but no idea on how to "port" this to Bmax.

grable

(Posted 2016) [#2]

In short, you cant. .NET Has abstracted the whole thing into multiple layers of crud which is .NET specific.
In the bottom all this probably comes from WMI but youd have to call into WMI yourself, implementing all the COM objects and whatnot.

EDIT:
Heres the list of WMI COM Interfaces, you probably wont need all of them though.
https://msdn.microsoft.com/en-us/library/aa389276%28VS.85%29.aspx

Looking over that list, i can see you got your work cut out for ya ;)

grable

(Posted 2016) [#3]

Did some more searching, and there is another way to get SMART data without having to resort to WMI.

The below uses DeviceIoControl to send commands directly to the driver/disk and the source is VB so shouldnt be too hard to port :)

http://vbnet.mvps.org/index.html?code/disk/smartide.htm

EDIT: Seems that sample isnt complete, it doesnt get the actual SMART data...

grable

(Posted 2016) [#4]

There was very little info on how to do this via DeviceIoControl, and i found nothing about how to decode the SMART data after getting it either.

But after looking at smartmontools output, i figured out its structure :)
Btw, dont bother looking at the source of smartmontools, its HORRIBLE and you will gleam very little from it.

Getting meaningful data from SMART isnt easy im afraid, its all pretty much vendor specific.
So getting the values yourself wont help much in determining whats up with the drive without doing specific calculations for each vendors values.

At least i managed to get the data and decode it somewhat. Note the below is C as it has everything one needs already defined.
Though it is possible to port, i suggest using mingw instead.

/*
  * smart.c - reads S.M.A.R.T data from disks
  *
  * usage: smart driveid [--raw]
  *
  * !!! ADMIN privilidges is needed to read s.m.a.r.t data !!!
  *
  * for list of attributes and their ids: <a href="https://en.wikipedia.org/wiki/S.M.A.R.T." target="_blank">https://en.wikipedia.org/wiki/S.M.A.R.T.</a>
  */
#include <windows.h>
#include <ntdddisk.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <inttypes.h>

#if READ_ATTRIBUTE_BUFFER_SIZE != READ_THRESHOLD_BUFFER_SIZE
	#error "This code assumes READ_ATTRIBUTE_BUFFER_SIZE == READ_THRESHOLD_BUFFER_SIZE"
#endif

// only meant to read ATTRIBUTES and THRESHOLDS
static SENDCMDOUTPARAMS* read_smart_data( int drive, int smartcmd) {
	char path[32];
	sprintf( path, "\\\\.\\PhysicalDrive%d", drive);
	HANDLE handle = CreateFile( path, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
	if(handle == INVALID_HANDLE_VALUE) return NULL;
	SENDCMDINPARAMS cmd = {
		.cBufferSize = sizeof(SENDCMDINPARAMS) - 1,
		.irDriveRegs = {
			.bFeaturesReg = smartcmd,
			.bSectorCountReg = 1,
			.bSectorNumberReg = 0,
			.bCylLowReg = SMART_CYL_LOW,
			.bCylHighReg = SMART_CYL_HI,
			.bDriveHeadReg = 0xA0,
			.bCommandReg = SMART_CMD,
		},
		.bDriveNumber = drive,
	};
	DWORD datasz = (sizeof(SENDCMDOUTPARAMS) - 1) + READ_ATTRIBUTE_BUFFER_SIZE;
	SENDCMDOUTPARAMS* data = malloc(datasz);
	DWORD writesz = 0;
	if(!DeviceIoControl( handle, SMART_RCV_DRIVE_DATA, &cmd, sizeof(cmd) - 1, data, datasz, &writesz, NULL)) {
		free(data);
		CloseHandle(handle);
		return NULL;
	}
	CloseHandle(handle);
	return data;
}

static bool check_smart( const char* name, SENDCMDOUTPARAMS* data) {
	if(data->DriverStatus.bDriverError || data->DriverStatus.bIDEError) {
		printf( "Error while reading S.M.A.R.T. %s...\n", name);
		printf( "DriverError = %d\n", data->DriverStatus.bDriverError);
		printf( "IDEError = %d\n", data->DriverStatus.bIDEError);
		return false;
	}
	return true;
}

static void print_raw( const char* name, void* attrs) {
	printf("\n------------- RAW %9s DATA --------------\n", name);
	for( uint8_t *p = attrs, *end = attrs + READ_ATTRIBUTE_BUFFER_SIZE; p < end; p += 16) {
		printf(	"%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
					p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]
				);
	}	
}

/*
  * format of S.M.A.R.T attribute/threshold data:
  *
  * 	size of attribute/threshold data is normally 512 bytes (1 sector).
  *		READ_ATTRIBUTE_BUFFER_SIZE and READ_THRESHOLD_BUFFER_SIZE holds actual size if it ever changes.
  *
  *
  *		OFFS	SIZE		DESC
  *		0			2			?
  *		2			12			attribute/threshold
  *		...
  *		  all attributes/thresholds from here
  *
  *
  * format of S.M.A.R.T attribute:
  *
  *		OFFS	SIZE		DESC
  *		0			1			type
  *		1			2			flags
  *		3			1			value
  *		4			1			worst
  *		5			6			raw value	(48-bits big-endian)
  *		11			1			?
  *
  *	if type==0 no attribute in that slot
  *
  * the raw value is vendor specific, and for certain attributes that denote time or temperature further calculations are needed  to display correctly.
  *
  *
    * format of S.M.A.R.T threshold:
  *
  *		OFFS	SIZE		DESC
  *		0			1			type
  *		1			1			threshold
  *		2			10			?
  *
  *	if type==0 no threshold in that slot
  *
  */
static void print_smart( void* attrs, void* thresh) {
	printf( "\nID  FLAG    VALUE WORST THRESH RAW\n");
	uint8_t* aend = attrs + READ_ATTRIBUTE_BUFFER_SIZE;
	uint8_t* t = thresh;
	for( uint8_t *a = attrs + 2; a < aend; a += 12) {
		if(*a) {
			uint8_t id = *a;
			uint16_t flags = *(uint16_t*)(a+1);
			uint8_t value = a[3];
			uint8_t worst = a[4];
			uint8_t threshold = t ? (t[a - (uint8_t*)attrs] ? t[(a - (uint8_t*)attrs) + 1] : 0) : 0;
			uint8_t raw[8] = {0};
			
			// reverse byte order
			for( int i=5; i<11; i++) raw[i-5] = a[i];
			
			printf( "%3d 0x%04x  %03d   %03d   %03d    %" PRIu64 "\n", id, flags, value, worst, threshold, *((uint64_t*)raw) & 0xFFFFFFFFFFFFL);
		}
	}
}


int main( int argc, const char* argv[argc]) {
	if(argc == 1) {
		printf( "usage: smart driveid [--raw]\n");
		return 0;
	}	
	
	int drive = -1;
	bool showraw = false;
	for( int i=1; i<argc; i++) {
		if(!strcmp( argv[i], "--raw"))
			showraw = true;
		else {
			drive = strtol( argv[1], NULL, 10);
			if(drive < 0) {
				fprintf( stderr, "error: invalid drive id (%d)\n", drive);
				return 1;
			}
		}
	}
	if(drive == -1) {
		fprintf( stderr, "error: no drive id specified\n");
		return 1;		
	}
	
	SENDCMDOUTPARAMS* adata = read_smart_data( drive, READ_ATTRIBUTES);
	SENDCMDOUTPARAMS* tdata = read_smart_data( drive, READ_THRESHOLDS);
	if(!adata) {
		fprintf( stderr, "error: unable to read S.M.A.R.T ATTRIBUTES of drive %d\n", drive);
		return 1;
	}
	if(!check_smart( "ATTRIBUTES", adata) || (tdata && !check_smart( "THRESHOLDS", tdata))) {
		free(adata);
		free(tdata);
		return 1;
	}	
	
	if(showraw) {
		print_raw( "ATTRIBUTE", adata->bBuffer);
		if(tdata) print_raw( "THRESHOLD", tdata->bBuffer);
	}
	
	print_smart( adata->bBuffer, tdata ? tdata->bBuffer : NULL);
	
	free(adata);
	free(tdata);
	return 0;
}

The tool above outputs data like this (similar to smartmontools), i didnt bother to scrape the wikipedia page for attribute names, so only IDs are used.

ID  FLAG    VALUE WORST THRESH RAW
  5 0x0033  100   100   010    0
  9 0x0032  099   099   000    1960
 12 0x0032  099   099   000    52
177 0x0013  099   099   000    12
179 0x0013  100   100   010    0
181 0x0032  100   100   010    0
182 0x0032  100   100   010    0
183 0x0013  100   100   010    0
187 0x0032  100   100   000    0
190 0x0032  069   054   000    31
195 0x001a  200   200   000    0
199 0x003e  100   100   000    0
235 0x0012  099   099   000    27
241 0x0032  099   099   000    3686144883

Fielder

(Posted 2016) [#5]

Very thank you for your interest Grable!

grable

(Posted 2016) [#6]

hehe, no problem.

It was actually quite fun to figure out, even though i hade to wade through some pretty arcane stuff ;)

EDIT: Maybe later il look into how some of the attributes that are not just simple counters are encoded. To get proper temperature, time etc.