X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=miscutils%2Fhdparm.c;h=0bbe6ca100d89800f4c2a3107f23241cd9625e03;hb=72089cf6b4a77214ec4fd21d5ee5bf56958781cb;hp=484c97061542ef1043d2f18c2cd97d785ed695e5;hpb=6ca409e0e4c198fe3081346eebbae3f068fe605a;p=oweals%2Fbusybox.git diff --git a/miscutils/hdparm.c b/miscutils/hdparm.c index 484c97061..0bbe6ca10 100644 --- a/miscutils/hdparm.c +++ b/miscutils/hdparm.c @@ -5,15 +5,132 @@ * Copyright (C) [2003] by [Matteo Croce] <3297627799@wind.it> * Hacked by Tito for size optimization. * - * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. + * Licensed under GPLv2 or later, see file LICENSE in this source tree. * * This program is based on the source code of hdparm: see below... * hdparm.c - Command line interface to get/set hard disk parameters * - by Mark Lord (C) 1994-2002 -- freely distributable */ +//config:config HDPARM +//config: bool "hdparm (23 kb)" +//config: default y +//config: select PLATFORM_LINUX +//config: help +//config: Get/Set hard drive parameters. Primarily intended for ATA +//config: drives. +//config: +//config:config FEATURE_HDPARM_GET_IDENTITY +//config: bool "Support obtaining detailed information directly from drives" +//config: default y +//config: depends on HDPARM +//config: help +//config: Enable the -I and -i options to obtain detailed information +//config: directly from drives about their capabilities and supported ATA +//config: feature set. If no device name is specified, hdparm will read +//config: identify data from stdin. Enabling this option will add about 16k... +//config: +//config:config FEATURE_HDPARM_HDIO_SCAN_HWIF +//config: bool "Register an IDE interface (DANGEROUS)" +//config: default y +//config: depends on HDPARM +//config: help +//config: Enable the 'hdparm -R' option to register an IDE interface. +//config: This is dangerous stuff, so you should probably say N. +//config: +//config:config FEATURE_HDPARM_HDIO_UNREGISTER_HWIF +//config: bool "Un-register an IDE interface (DANGEROUS)" +//config: default y +//config: depends on HDPARM +//config: help +//config: Enable the 'hdparm -U' option to un-register an IDE interface. +//config: This is dangerous stuff, so you should probably say N. +//config: +//config:config FEATURE_HDPARM_HDIO_DRIVE_RESET +//config: bool "Perform device reset (DANGEROUS)" +//config: default y +//config: depends on HDPARM +//config: help +//config: Enable the 'hdparm -w' option to perform a device reset. +//config: This is dangerous stuff, so you should probably say N. +//config: +//config:config FEATURE_HDPARM_HDIO_TRISTATE_HWIF +//config: bool "Tristate device for hotswap (DANGEROUS)" +//config: default y +//config: depends on HDPARM +//config: help +//config: Enable the 'hdparm -x' option to tristate device for hotswap, +//config: and the '-b' option to get/set bus state. This is dangerous +//config: stuff, so you should probably say N. +//config: +//config:config FEATURE_HDPARM_HDIO_GETSET_DMA +//config: bool "Get/set using_dma flag" +//config: default y +//config: depends on HDPARM +//config: help +//config: Enable the 'hdparm -d' option to get/set using_dma flag. + +//applet:IF_HDPARM(APPLET(hdparm, BB_DIR_SBIN, BB_SUID_DROP)) + +//kbuild:lib-$(CONFIG_HDPARM) += hdparm.o + +//usage:#define hdparm_trivial_usage +//usage: "[OPTIONS] [DEVICE]" +//usage:#define hdparm_full_usage "\n\n" +//usage: " -a Get/set fs readahead" +//usage: "\n -A Set drive read-lookahead flag (0/1)" +//usage: "\n -b Get/set bus state (0 == off, 1 == on, 2 == tristate)" +//usage: "\n -B Set Advanced Power Management setting (1-255)" +//usage: "\n -c Get/set IDE 32-bit IO setting" +//usage: "\n -C Check IDE power mode status" +//usage: IF_FEATURE_HDPARM_HDIO_GETSET_DMA( +//usage: "\n -d Get/set using_dma flag") +//usage: "\n -D Enable/disable drive defect-mgmt" +//usage: "\n -f Flush buffer cache for device on exit" +//usage: "\n -g Display drive geometry" +//usage: "\n -h Display terse usage information" +//usage: IF_FEATURE_HDPARM_GET_IDENTITY( +//usage: "\n -i Display drive identification") +//usage: IF_FEATURE_HDPARM_GET_IDENTITY( +//usage: "\n -I Detailed/current information directly from drive") +//usage: "\n -k Get/set keep_settings_over_reset flag (0/1)" +//usage: "\n -K Set drive keep_features_over_reset flag (0/1)" +//usage: "\n -L Set drive doorlock (0/1) (removable harddisks only)" +//usage: "\n -m Get/set multiple sector count" +//usage: "\n -n Get/set ignore-write-errors flag (0/1)" +//usage: "\n -p Set PIO mode on IDE interface chipset (0,1,2,3,4,...)" +//usage: "\n -P Set drive prefetch count" +/* //usage: "\n -q Change next setting quietly" - not supported ib bbox */ +//usage: "\n -Q Get/set DMA tagged-queuing depth (if supported)" +//usage: "\n -r Get/set readonly flag (DANGEROUS to set)" +//usage: IF_FEATURE_HDPARM_HDIO_SCAN_HWIF( +//usage: "\n -R Register an IDE interface (DANGEROUS)") +//usage: "\n -S Set standby (spindown) timeout" +//usage: "\n -t Perform device read timings" +//usage: "\n -T Perform cache read timings" +//usage: "\n -u Get/set unmaskirq flag (0/1)" +//usage: IF_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF( +//usage: "\n -U Unregister an IDE interface (DANGEROUS)") +//usage: "\n -v Defaults; same as -mcudkrag for IDE drives" +//usage: "\n -V Display program version and exit immediately" +//usage: IF_FEATURE_HDPARM_HDIO_DRIVE_RESET( +//usage: "\n -w Perform device reset (DANGEROUS)") +//usage: "\n -W Set drive write-caching flag (0/1) (DANGEROUS)" +//usage: IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( +//usage: "\n -x Tristate device for hotswap (0/1) (DANGEROUS)") +//usage: "\n -X Set IDE xfer mode (DANGEROUS)" +//usage: "\n -y Put IDE drive in standby mode" +//usage: "\n -Y Put IDE drive to sleep" +//usage: "\n -Z Disable Seagate auto-powersaving mode" +//usage: "\n -z Reread partition table" #include "libbb.h" +#include "common_bufsiz.h" +/* must be _after_ libbb.h: */ #include +#include +#if !defined(BLKGETSIZE64) +# define BLKGETSIZE64 _IOR(0x12,114,size_t) +#endif /* device types */ /* ------------ */ @@ -59,7 +176,7 @@ #define ADV_PIO_MODES 64 /* advanced PIO modes supported */ /* multiword DMA xfer cycle time: */ #define DMA_TIME_MIN 65 /* - minimum */ -#define DMA_TIME_NORM 66 /* - manufacturer's recommended */ +#define DMA_TIME_NORM 66 /* - manufacturer's recommended */ /* minimum PIO xfer cycle time: */ #define PIO_NO_FLOW 67 /* - without flow control */ #define PIO_FLOW 68 /* - with IORDY flow control */ @@ -82,7 +199,7 @@ #define ENH_ERASE_TIME 90 /* - enhanced */ #define ADV_PWR 91 /* current advanced power management level in low byte, 0x40 in high byte. */ -#define PSWD_CODE 92 /* master password revision code */ +#define PSWD_CODE 92 /* master password revision code */ #define HWRST_RSLT 93 /* hardware reset result */ #define ACOUSTIC 94 /* acoustic mgmt values ( >= ATA-6) */ #define LBA_LSB 100 /* LBA: maximum. Currently only 48 */ @@ -127,62 +244,6 @@ #define CDROM 0x0005 -#if ENABLE_FEATURE_HDPARM_GET_IDENTITY -static const char *const pkt_str[] = { - "Direct-access device", /* word 0, bits 12-8 = 00 */ - "Sequential-access device", /* word 0, bits 12-8 = 01 */ - "Printer", /* word 0, bits 12-8 = 02 */ - "Processor", /* word 0, bits 12-8 = 03 */ - "Write-once device", /* word 0, bits 12-8 = 04 */ - "CD-ROM", /* word 0, bits 12-8 = 05 */ - "Scanner", /* word 0, bits 12-8 = 06 */ - "Optical memory", /* word 0, bits 12-8 = 07 */ - "Medium changer", /* word 0, bits 12-8 = 08 */ - "Communications device", /* word 0, bits 12-8 = 09 */ - "ACS-IT8 device", /* word 0, bits 12-8 = 0a */ - "ACS-IT8 device", /* word 0, bits 12-8 = 0b */ - "Array controller", /* word 0, bits 12-8 = 0c */ - "Enclosure services", /* word 0, bits 12-8 = 0d */ - "Reduced block command device", /* word 0, bits 12-8 = 0e */ - "Optical card reader/writer", /* word 0, bits 12-8 = 0f */ - "", /* word 0, bits 12-8 = 10 */ - "", /* word 0, bits 12-8 = 11 */ - "", /* word 0, bits 12-8 = 12 */ - "", /* word 0, bits 12-8 = 13 */ - "", /* word 0, bits 12-8 = 14 */ - "", /* word 0, bits 12-8 = 15 */ - "", /* word 0, bits 12-8 = 16 */ - "", /* word 0, bits 12-8 = 17 */ - "", /* word 0, bits 12-8 = 18 */ - "", /* word 0, bits 12-8 = 19 */ - "", /* word 0, bits 12-8 = 1a */ - "", /* word 0, bits 12-8 = 1b */ - "", /* word 0, bits 12-8 = 1c */ - "", /* word 0, bits 12-8 = 1d */ - "", /* word 0, bits 12-8 = 1e */ - "Unknown", /* word 0, bits 12-8 = 1f */ -}; - -static const char *const ata1_cfg_str[] = { /* word 0 in ATA-1 mode */ - "Reserved", /* bit 0 */ - "hard sectored", /* bit 1 */ - "soft sectored", /* bit 2 */ - "not MFM encoded ", /* bit 3 */ - "head switch time > 15us", /* bit 4 */ - "spindle motor control option", /* bit 5 */ - "fixed drive", /* bit 6 */ - "removable drive", /* bit 7 */ - "disk xfer rate <= 5Mbs", /* bit 8 */ - "disk xfer rate > 5Mbs, <= 10Mbs", /* bit 9 */ - "disk xfer rate > 5Mbs", /* bit 10 */ - "rotational speed tol.", /* bit 11 */ - "data strobe offset option", /* bit 12 */ - "track offset option", /* bit 13 */ - "format speed tolerance gap reqd", /* bit 14 */ - "ATAPI" /* bit 14 */ -}; -#endif - /* word 1: number of logical cylinders */ #define LCYLS_MAX 0x3fff /* maximum allowable value */ @@ -238,86 +299,6 @@ static const char *const ata1_cfg_str[] = { /* word 0 in ATA-1 mode */ /* word 81: minor version number */ #define MINOR_MAX 0x22 -#if ENABLE_FEATURE_HDPARM_GET_IDENTITY -static const char *minor_str[MINOR_MAX+2] = { /* word 81 value: */ - "Unspecified", /* 0x0000 */ - "ATA-1 X3T9.2 781D prior to rev.4", /* 0x0001 */ - "ATA-1 published, ANSI X3.221-1994", /* 0x0002 */ - "ATA-1 X3T9.2 781D rev.4", /* 0x0003 */ - "ATA-2 published, ANSI X3.279-1996", /* 0x0004 */ - "ATA-2 X3T10 948D prior to rev.2k", /* 0x0005 */ - "ATA-3 X3T10 2008D rev.1", /* 0x0006 */ - "ATA-2 X3T10 948D rev.2k", /* 0x0007 */ - "ATA-3 X3T10 2008D rev.0", /* 0x0008 */ - "ATA-2 X3T10 948D rev.3", /* 0x0009 */ - "ATA-3 published, ANSI X3.298-199x", /* 0x000a */ - "ATA-3 X3T10 2008D rev.6", /* 0x000b */ - "ATA-3 X3T13 2008D rev.7 and 7a", /* 0x000c */ - "ATA/ATAPI-4 X3T13 1153D rev.6", /* 0x000d */ - "ATA/ATAPI-4 T13 1153D rev.13", /* 0x000e */ - "ATA/ATAPI-4 X3T13 1153D rev.7", /* 0x000f */ - "ATA/ATAPI-4 T13 1153D rev.18", /* 0x0010 */ - "ATA/ATAPI-4 T13 1153D rev.15", /* 0x0011 */ - "ATA/ATAPI-4 published, ANSI INCITS 317-1998", /* 0x0012 */ - "ATA/ATAPI-5 T13 1321D rev.3", - "ATA/ATAPI-4 T13 1153D rev.14", /* 0x0014 */ - "ATA/ATAPI-5 T13 1321D rev.1", /* 0x0015 */ - "ATA/ATAPI-5 published, ANSI INCITS 340-2000", /* 0x0016 */ - "ATA/ATAPI-4 T13 1153D rev.17", /* 0x0017 */ - "ATA/ATAPI-6 T13 1410D rev.0", /* 0x0018 */ - "ATA/ATAPI-6 T13 1410D rev.3a", /* 0x0019 */ - "ATA/ATAPI-7 T13 1532D rev.1", /* 0x001a */ - "ATA/ATAPI-6 T13 1410D rev.2", /* 0x001b */ - "ATA/ATAPI-6 T13 1410D rev.1", /* 0x001c */ - "ATA/ATAPI-7 published, ANSI INCITS 397-2005", /* 0x001d */ - "ATA/ATAPI-7 T13 1532D rev.0", /* 0x001e */ - "Reserved" /* 0x001f */ - "Reserved" /* 0x0020 */ - "ATA/ATAPI-7 T13 1532D rev.4a", /* 0x0021 */ - "ATA/ATAPI-6 published, ANSI INCITS 361-2002", /* 0x0022 */ - "Reserved" /* 0x0023-0xfffe*/ -}; -#endif -static const char actual_ver[MINOR_MAX+2] = { - /* word 81 value: */ - 0, /* 0x0000 WARNING: */ - 1, /* 0x0001 WARNING: */ - 1, /* 0x0002 WARNING: */ - 1, /* 0x0003 WARNING: */ - 2, /* 0x0004 WARNING: This array */ - 2, /* 0x0005 WARNING: corresponds */ - 3, /* 0x0006 WARNING: *exactly* */ - 2, /* 0x0007 WARNING: to the ATA/ */ - 3, /* 0x0008 WARNING: ATAPI version */ - 2, /* 0x0009 WARNING: listed in */ - 3, /* 0x000a WARNING: the */ - 3, /* 0x000b WARNING: minor_str */ - 3, /* 0x000c WARNING: array */ - 4, /* 0x000d WARNING: above. */ - 4, /* 0x000e WARNING: */ - 4, /* 0x000f WARNING: if you change */ - 4, /* 0x0010 WARNING: that one, */ - 4, /* 0x0011 WARNING: change this one */ - 4, /* 0x0012 WARNING: too!!! */ - 5, /* 0x0013 WARNING: */ - 4, /* 0x0014 WARNING: */ - 5, /* 0x0015 WARNING: */ - 5, /* 0x0016 WARNING: */ - 4, /* 0x0017 WARNING: */ - 6, /* 0x0018 WARNING: */ - 6, /* 0x0019 WARNING: */ - 7, /* 0x001a WARNING: */ - 6, /* 0x001b WARNING: */ - 6, /* 0x001c WARNING: */ - 7, /* 0x001d WARNING: */ - 7, /* 0x001e WARNING: */ - 0, /* 0x001f WARNING: */ - 0, /* 0x0020 WARNING: */ - 7, /* 0x0021 WARNING: */ - 6, /* 0x0022 WARNING: */ - 0 /* 0x0023-0xfffe */ -}; - /* words 82-84: cmds/feats supported */ #define CMDS_W82 0x77ff /* word 82: defined command locations*/ #define CMDS_W83 0x3fff /* word 83: defined command locations*/ @@ -325,67 +306,6 @@ static const char actual_ver[MINOR_MAX+2] = { #define SUPPORT_48_BIT 0x0400 #define NUM_CMD_FEAT_STR 48 -#if ENABLE_FEATURE_HDPARM_GET_IDENTITY -static const char *const cmd_feat_str[] = { - "", /* word 82 bit 15: obsolete */ - "NOP cmd", /* word 82 bit 14 */ - "READ BUFFER cmd", /* word 82 bit 13 */ - "WRITE BUFFER cmd", /* word 82 bit 12 */ - "", /* word 82 bit 11: obsolete */ - "Host Protected Area feature set", /* word 82 bit 10 */ - "DEVICE RESET cmd", /* word 82 bit 9 */ - "SERVICE interrupt", /* word 82 bit 8 */ - "Release interrupt", /* word 82 bit 7 */ - "Look-ahead", /* word 82 bit 6 */ - "Write cache", /* word 82 bit 5 */ - "PACKET command feature set", /* word 82 bit 4 */ - "Power Management feature set", /* word 82 bit 3 */ - "Removable Media feature set", /* word 82 bit 2 */ - "Security Mode feature set", /* word 82 bit 1 */ - "SMART feature set", /* word 82 bit 0 */ - /* --------------*/ - "", /* word 83 bit 15: !valid bit */ - "", /* word 83 bit 14: valid bit */ - "FLUSH CACHE EXT cmd", /* word 83 bit 13 */ - "Mandatory FLUSH CACHE cmd ", /* word 83 bit 12 */ - "Device Configuration Overlay feature set ", - "48-bit Address feature set ", /* word 83 bit 10 */ - "", - "SET MAX security extension", /* word 83 bit 8 */ - "Address Offset Reserved Area Boot", /* word 83 bit 7 */ - "SET FEATURES subcommand required to spinup after power up", - "Power-Up In Standby feature set", /* word 83 bit 5 */ - "Removable Media Status Notification feature set", - "Adv. Power Management feature set",/* word 83 bit 3 */ - "CFA feature set", /* word 83 bit 2 */ - "READ/WRITE DMA QUEUED", /* word 83 bit 1 */ - "DOWNLOAD MICROCODE cmd", /* word 83 bit 0 */ - /* --------------*/ - "", /* word 84 bit 15: !valid bit */ - "", /* word 84 bit 14: valid bit */ - "", /* word 84 bit 13: reserved */ - "", /* word 84 bit 12: reserved */ - "", /* word 84 bit 11: reserved */ - "", /* word 84 bit 10: reserved */ - "", /* word 84 bit 9: reserved */ - "", /* word 84 bit 8: reserved */ - "", /* word 84 bit 7: reserved */ - "", /* word 84 bit 6: reserved */ - "General Purpose Logging feature set", /* word 84 bit 5 */ - "", /* word 84 bit 4: reserved */ - "Media Card Pass Through Command feature set ", - "Media serial number ", /* word 84 bit 2 */ - "SMART self-test ", /* word 84 bit 1 */ - "SMART error logging " /* word 84 bit 0 */ -}; - -static void identify(uint16_t *id_supplied) ATTRIBUTE_NORETURN; -static void identify_from_stdin(void) ATTRIBUTE_NORETURN; -#else -void identify_from_stdin(void); -#endif - - /* words 85-87: cmds/feats enabled */ /* use cmd_feat_str[] to display what commands and features have * been enabled with words 85-87 @@ -412,16 +332,6 @@ void identify_from_stdin(void); #define SECU_ENABLED 0x0002 #define SECU_LEVEL 0x0010 #define NUM_SECU_STR 6 -#if ENABLE_FEATURE_HDPARM_GET_IDENTITY -static const char *const secu_str[] = { - "supported", /* word 128, bit 0 */ - "enabled", /* word 128, bit 1 */ - "locked", /* word 128, bit 2 */ - "frozen", /* word 128, bit 3 */ - "expired: security count", /* word 128, bit 4 */ - "supported: enhanced erase" /* word 128, bit 5 */ -}; -#endif /* word 160: CFA power mode */ #define VALID_W160 0x8000 /* 1=word valid */ @@ -433,32 +343,180 @@ static const char *const secu_str[] = { #define SIG 0x00ff /* signature location */ #define SIG_VAL 0x00a5 /* signature value */ -#define TIMING_MB 64 #define TIMING_BUF_MB 1 #define TIMING_BUF_BYTES (TIMING_BUF_MB * 1024 * 1024) -#define BUFCACHE_FACTOR 2 #undef DO_FLUSHCACHE /* under construction: force cache flush on -W0 */ + +#define IS_GET 1 +#define IS_SET 2 + + +enum { fd = 3 }; + + +struct globals { + smallint get_identity, get_geom; + smallint do_flush; + smallint do_ctimings, do_timings; + smallint reread_partn; + smallint set_piomode, noisy_piomode; + smallint getset_readahead; + smallint getset_readonly; + smallint getset_unmask; + smallint getset_mult; +#ifdef HDIO_GET_QDMA + smallint getset_dma_q; +#endif + smallint getset_nowerr; + smallint getset_keep; + smallint getset_io32bit; + int piomode; + unsigned long Xreadahead; + unsigned long readonly; + unsigned long unmask; + unsigned long mult; +#ifdef HDIO_SET_QDMA + unsigned long dma_q; +#endif + unsigned long nowerr; + unsigned long keep; + unsigned long io32bit; +#if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA + unsigned long dma; + smallint getset_dma; +#endif +#ifdef HDIO_DRIVE_CMD + smallint set_xfermode, get_xfermode; + smallint getset_dkeep; + smallint getset_standby; + smallint getset_lookahead; + smallint getset_prefetch; + smallint getset_defects; + smallint getset_wcache; + smallint getset_doorlock; + smallint set_seagate; + smallint set_standbynow; + smallint set_sleepnow; + smallint get_powermode; + smallint getset_apmmode; + int xfermode_requested; + unsigned long dkeep; + unsigned long standby_requested; /* 0..255 */ + unsigned long lookahead; + unsigned long prefetch; + unsigned long defects; + unsigned long wcache; + unsigned long doorlock; + unsigned long apmmode; +#endif + IF_FEATURE_HDPARM_GET_IDENTITY( smallint get_IDentity;) + IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( smallint getset_busstate;) + IF_FEATURE_HDPARM_HDIO_DRIVE_RESET( smallint perform_reset;) + IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( smallint perform_tristate;) + IF_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(smallint unregister_hwif;) + IF_FEATURE_HDPARM_HDIO_SCAN_HWIF( smallint scan_hwif;) + IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( unsigned long busstate;) + IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( unsigned long tristate;) + IF_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(unsigned long hwif;) +#if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF + unsigned long hwif_data; + unsigned long hwif_ctrl; + unsigned long hwif_irq; +#endif +#ifdef DO_FLUSHCACHE + unsigned char flushcache[4] = { WIN_FLUSHCACHE, 0, 0, 0 }; +#endif +} FIX_ALIASING; +#define G (*(struct globals*)bb_common_bufsiz1) +#define get_identity (G.get_identity ) +#define get_geom (G.get_geom ) +#define do_flush (G.do_flush ) +#define do_ctimings (G.do_ctimings ) +#define do_timings (G.do_timings ) +#define reread_partn (G.reread_partn ) +#define set_piomode (G.set_piomode ) +#define noisy_piomode (G.noisy_piomode ) +#define getset_readahead (G.getset_readahead ) +#define getset_readonly (G.getset_readonly ) +#define getset_unmask (G.getset_unmask ) +#define getset_mult (G.getset_mult ) +#define getset_dma_q (G.getset_dma_q ) +#define getset_nowerr (G.getset_nowerr ) +#define getset_keep (G.getset_keep ) +#define getset_io32bit (G.getset_io32bit ) +#define piomode (G.piomode ) +#define Xreadahead (G.Xreadahead ) +#define readonly (G.readonly ) +#define unmask (G.unmask ) +#define mult (G.mult ) +#define dma_q (G.dma_q ) +#define nowerr (G.nowerr ) +#define keep (G.keep ) +#define io32bit (G.io32bit ) +#define dma (G.dma ) +#define getset_dma (G.getset_dma ) +#define set_xfermode (G.set_xfermode ) +#define get_xfermode (G.get_xfermode ) +#define getset_dkeep (G.getset_dkeep ) +#define getset_standby (G.getset_standby ) +#define getset_lookahead (G.getset_lookahead ) +#define getset_prefetch (G.getset_prefetch ) +#define getset_defects (G.getset_defects ) +#define getset_wcache (G.getset_wcache ) +#define getset_doorlock (G.getset_doorlock ) +#define set_seagate (G.set_seagate ) +#define set_standbynow (G.set_standbynow ) +#define set_sleepnow (G.set_sleepnow ) +#define get_powermode (G.get_powermode ) +#define getset_apmmode (G.getset_apmmode ) +#define xfermode_requested (G.xfermode_requested ) +#define dkeep (G.dkeep ) +#define standby_requested (G.standby_requested ) +#define lookahead (G.lookahead ) +#define prefetch (G.prefetch ) +#define defects (G.defects ) +#define wcache (G.wcache ) +#define doorlock (G.doorlock ) +#define apmmode (G.apmmode ) +#define get_IDentity (G.get_IDentity ) +#define getset_busstate (G.getset_busstate ) +#define perform_reset (G.perform_reset ) +#define perform_tristate (G.perform_tristate ) +#define unregister_hwif (G.unregister_hwif ) +#define scan_hwif (G.scan_hwif ) +#define busstate (G.busstate ) +#define tristate (G.tristate ) +#define hwif (G.hwif ) +#define hwif_data (G.hwif_data ) +#define hwif_ctrl (G.hwif_ctrl ) +#define hwif_irq (G.hwif_irq ) +#define INIT_G() do { \ + setup_common_bufsiz(); \ + BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \ +} while (0) + + /* Busybox messages and functions */ #if ENABLE_IOCTL_HEX2STR_ERROR -static int ioctl_alt_func(int fd, int cmd, unsigned char *args, int alt, const char *string) +static int ioctl_alt_func(/*int fd,*/ int cmd, unsigned char *args, int alt, const char *string) { if (!ioctl(fd, cmd, args)) return 0; args[0] = alt; return bb_ioctl_or_warn(fd, cmd, args, string); } -#define ioctl_alt_or_warn(fd,cmd,args,alt) ioctl_alt_func(fd,cmd,args,alt,#cmd) +#define ioctl_alt_or_warn(cmd,args,alt) ioctl_alt_func(cmd,args,alt,#cmd) #else -static int ioctl_alt_func(int fd, int cmd, unsigned char *args, int alt) +static int ioctl_alt_func(/*int fd,*/ int cmd, unsigned char *args, int alt) { if (!ioctl(fd, cmd, args)) return 0; args[0] = alt; return bb_ioctl_or_warn(fd, cmd, args); } -#define ioctl_alt_or_warn(fd,cmd,args,alt) ioctl_alt_func(fd,cmd,args,alt) +#define ioctl_alt_or_warn(cmd,args,alt) ioctl_alt_func(cmd,args,alt) #endif static void on_off(int value) @@ -469,31 +527,55 @@ static void on_off(int value) static void print_flag_on_off(int get_arg, const char *s, unsigned long arg) { if (get_arg) { - printf(" setting %s to %ld", s, arg); + printf(" setting %s to %lu", s, arg); on_off(arg); } } static void print_value_on_off(const char *str, unsigned long argp) { - printf(" %s\t= %2ld", str, argp); + printf(" %s\t= %2lu", str, argp); on_off(argp != 0); } #if ENABLE_FEATURE_HDPARM_GET_IDENTITY -static void print_ascii(uint16_t *p, uint8_t length); +static void print_ascii(const char *p, int length) +{ +#if BB_BIG_ENDIAN +#define LE_ONLY(x) + enum { ofs = 0 }; +#else +#define LE_ONLY(x) x + /* every 16bit word is big-endian (i.e. inverted) */ + /* accessing bytes in 1,0, 3,2, 5,4... sequence */ + int ofs = 1; +#endif + + length *= 2; + /* find first non-space & print it */ + while (length && p[ofs] != ' ') { + p++; + LE_ONLY(ofs = -ofs;) + length--; + } + while (length && p[ofs]) { + bb_putchar(p[ofs]); + p++; + LE_ONLY(ofs = -ofs;) + length--; + } + bb_putchar('\n'); +#undef LE_ONLY +} static void xprint_ascii(uint16_t *val, int i, const char *string, int n) { if (val[i]) { printf("\t%-20s", string); - print_ascii(&val[i], n); + print_ascii((void*)&val[i], n); } } -#endif -/* end of busybox specific stuff */ -#if ENABLE_FEATURE_HDPARM_GET_IDENTITY static uint8_t mode_loop(uint16_t mode_sup, uint16_t mode_sel, int cc, uint8_t *have_mode) { uint16_t ii; @@ -514,41 +596,190 @@ static uint8_t mode_loop(uint16_t mode_sup, uint16_t mode_sel, int cc, uint8_t * return err_dma; } -static void print_ascii(uint16_t *p, uint8_t length) -{ - uint8_t ii; - char cl; +static const char pkt_str[] ALIGN1 = + "Direct-access device" "\0" /* word 0, bits 12-8 = 00 */ + "Sequential-access device" "\0" /* word 0, bits 12-8 = 01 */ + "Printer" "\0" /* word 0, bits 12-8 = 02 */ + "Processor" "\0" /* word 0, bits 12-8 = 03 */ + "Write-once device" "\0" /* word 0, bits 12-8 = 04 */ + "CD-ROM" "\0" /* word 0, bits 12-8 = 05 */ + "Scanner" "\0" /* word 0, bits 12-8 = 06 */ + "Optical memory" "\0" /* word 0, bits 12-8 = 07 */ + "Medium changer" "\0" /* word 0, bits 12-8 = 08 */ + "Communications device" "\0" /* word 0, bits 12-8 = 09 */ + "ACS-IT8 device" "\0" /* word 0, bits 12-8 = 0a */ + "ACS-IT8 device" "\0" /* word 0, bits 12-8 = 0b */ + "Array controller" "\0" /* word 0, bits 12-8 = 0c */ + "Enclosure services" "\0" /* word 0, bits 12-8 = 0d */ + "Reduced block command device" "\0" /* word 0, bits 12-8 = 0e */ + "Optical card reader/writer" "\0" /* word 0, bits 12-8 = 0f */ +; + +static const char ata1_cfg_str[] ALIGN1 = /* word 0 in ATA-1 mode */ + "reserved" "\0" /* bit 0 */ + "hard sectored" "\0" /* bit 1 */ + "soft sectored" "\0" /* bit 2 */ + "not MFM encoded " "\0" /* bit 3 */ + "head switch time > 15us" "\0" /* bit 4 */ + "spindle motor control option" "\0" /* bit 5 */ + "fixed drive" "\0" /* bit 6 */ + "removable drive" "\0" /* bit 7 */ + "disk xfer rate <= 5Mbs" "\0" /* bit 8 */ + "disk xfer rate > 5Mbs, <= 10Mbs" "\0" /* bit 9 */ + "disk xfer rate > 5Mbs" "\0" /* bit 10 */ + "rotational speed tol." "\0" /* bit 11 */ + "data strobe offset option" "\0" /* bit 12 */ + "track offset option" "\0" /* bit 13 */ + "format speed tolerance gap reqd" "\0" /* bit 14 */ + "ATAPI" /* bit 14 */ +; + +static const char minor_str[] ALIGN1 = + /* word 81 value: */ + "Unspecified" "\0" /* 0x0000 */ + "ATA-1 X3T9.2 781D prior to rev.4" "\0" /* 0x0001 */ + "ATA-1 published, ANSI X3.221-1994" "\0" /* 0x0002 */ + "ATA-1 X3T9.2 781D rev.4" "\0" /* 0x0003 */ + "ATA-2 published, ANSI X3.279-1996" "\0" /* 0x0004 */ + "ATA-2 X3T10 948D prior to rev.2k" "\0" /* 0x0005 */ + "ATA-3 X3T10 2008D rev.1" "\0" /* 0x0006 */ + "ATA-2 X3T10 948D rev.2k" "\0" /* 0x0007 */ + "ATA-3 X3T10 2008D rev.0" "\0" /* 0x0008 */ + "ATA-2 X3T10 948D rev.3" "\0" /* 0x0009 */ + "ATA-3 published, ANSI X3.298-199x" "\0" /* 0x000a */ + "ATA-3 X3T10 2008D rev.6" "\0" /* 0x000b */ + "ATA-3 X3T13 2008D rev.7 and 7a" "\0" /* 0x000c */ + "ATA/ATAPI-4 X3T13 1153D rev.6" "\0" /* 0x000d */ + "ATA/ATAPI-4 T13 1153D rev.13" "\0" /* 0x000e */ + "ATA/ATAPI-4 X3T13 1153D rev.7" "\0" /* 0x000f */ + "ATA/ATAPI-4 T13 1153D rev.18" "\0" /* 0x0010 */ + "ATA/ATAPI-4 T13 1153D rev.15" "\0" /* 0x0011 */ + "ATA/ATAPI-4 published, ANSI INCITS 317-1998" "\0" /* 0x0012 */ + "ATA/ATAPI-5 T13 1321D rev.3" "\0" /* 0x0013 */ + "ATA/ATAPI-4 T13 1153D rev.14" "\0" /* 0x0014 */ + "ATA/ATAPI-5 T13 1321D rev.1" "\0" /* 0x0015 */ + "ATA/ATAPI-5 published, ANSI INCITS 340-2000" "\0" /* 0x0016 */ + "ATA/ATAPI-4 T13 1153D rev.17" "\0" /* 0x0017 */ + "ATA/ATAPI-6 T13 1410D rev.0" "\0" /* 0x0018 */ + "ATA/ATAPI-6 T13 1410D rev.3a" "\0" /* 0x0019 */ + "ATA/ATAPI-7 T13 1532D rev.1" "\0" /* 0x001a */ + "ATA/ATAPI-6 T13 1410D rev.2" "\0" /* 0x001b */ + "ATA/ATAPI-6 T13 1410D rev.1" "\0" /* 0x001c */ + "ATA/ATAPI-7 published, ANSI INCITS 397-2005" "\0" /* 0x001d */ + "ATA/ATAPI-7 T13 1532D rev.0" "\0" /* 0x001e */ + "reserved" "\0" /* 0x001f */ + "reserved" "\0" /* 0x0020 */ + "ATA/ATAPI-7 T13 1532D rev.4a" "\0" /* 0x0021 */ + "ATA/ATAPI-6 published, ANSI INCITS 361-2002" "\0" /* 0x0022 */ + "reserved" /* 0x0023-0xfffe */ +; +static const char actual_ver[MINOR_MAX + 2] ALIGN1 = { + /* word 81 value: */ + 0, /* 0x0000 WARNING: actual_ver[] array */ + 1, /* 0x0001 WARNING: corresponds */ + 1, /* 0x0002 WARNING: *exactly* */ + 1, /* 0x0003 WARNING: to the ATA/ */ + 2, /* 0x0004 WARNING: ATAPI version */ + 2, /* 0x0005 WARNING: listed in */ + 3, /* 0x0006 WARNING: the */ + 2, /* 0x0007 WARNING: minor_str */ + 3, /* 0x0008 WARNING: array */ + 2, /* 0x0009 WARNING: above. */ + 3, /* 0x000a WARNING: */ + 3, /* 0x000b WARNING: If you change */ + 3, /* 0x000c WARNING: that one, */ + 4, /* 0x000d WARNING: change this one */ + 4, /* 0x000e WARNING: too!!! */ + 4, /* 0x000f */ + 4, /* 0x0010 */ + 4, /* 0x0011 */ + 4, /* 0x0012 */ + 5, /* 0x0013 */ + 4, /* 0x0014 */ + 5, /* 0x0015 */ + 5, /* 0x0016 */ + 4, /* 0x0017 */ + 6, /* 0x0018 */ + 6, /* 0x0019 */ + 7, /* 0x001a */ + 6, /* 0x001b */ + 6, /* 0x001c */ + 7, /* 0x001d */ + 7, /* 0x001e */ + 0, /* 0x001f */ + 0, /* 0x0020 */ + 7, /* 0x0021 */ + 6, /* 0x0022 */ + 0 /* 0x0023-0xfffe */ +}; - /* find first non-space & print it */ - for (ii = 0; ii < length; ii++) { - if ((char)((*p)>>8) != ' ') - break; - cl = (char)(*p); - if (cl != ' ') { - if (cl != '\0') - printf("%c", cl); - p++; - ii++; - break; - } - p++; - } - /* print the rest */ - for (; ii< length; ii++) { - if (!(*p)) - break; /* some older devices have NULLs */ - printf("%c%c", (char)((*p)>>8), (char)(*p)); - p++; - } - puts(""); -} +static const char cmd_feat_str[] ALIGN1 = + "" "\0" /* word 82 bit 15: obsolete */ + "NOP cmd" "\0" /* word 82 bit 14 */ + "READ BUFFER cmd" "\0" /* word 82 bit 13 */ + "WRITE BUFFER cmd" "\0" /* word 82 bit 12 */ + "" "\0" /* word 82 bit 11: obsolete */ + "Host Protected Area feature set" "\0" /* word 82 bit 10 */ + "DEVICE RESET cmd" "\0" /* word 82 bit 9 */ + "SERVICE interrupt" "\0" /* word 82 bit 8 */ + "Release interrupt" "\0" /* word 82 bit 7 */ + "Look-ahead" "\0" /* word 82 bit 6 */ + "Write cache" "\0" /* word 82 bit 5 */ + "PACKET command feature set" "\0" /* word 82 bit 4 */ + "Power Management feature set" "\0" /* word 82 bit 3 */ + "Removable Media feature set" "\0" /* word 82 bit 2 */ + "Security Mode feature set" "\0" /* word 82 bit 1 */ + "SMART feature set" "\0" /* word 82 bit 0 */ + /* -------------- */ + "" "\0" /* word 83 bit 15: !valid bit */ + "" "\0" /* word 83 bit 14: valid bit */ + "FLUSH CACHE EXT cmd" "\0" /* word 83 bit 13 */ + "Mandatory FLUSH CACHE cmd " "\0" /* word 83 bit 12 */ + "Device Configuration Overlay feature set " "\0" + "48-bit Address feature set " "\0" /* word 83 bit 10 */ + "" "\0" + "SET MAX security extension" "\0" /* word 83 bit 8 */ + "Address Offset Reserved Area Boot" "\0" /* word 83 bit 7 */ + "SET FEATURES subcommand required to spinup after power up" "\0" + "Power-Up In Standby feature set" "\0" /* word 83 bit 5 */ + "Removable Media Status Notification feature set" "\0" + "Adv. Power Management feature set" "\0" /* word 83 bit 3 */ + "CFA feature set" "\0" /* word 83 bit 2 */ + "READ/WRITE DMA QUEUED" "\0" /* word 83 bit 1 */ + "DOWNLOAD MICROCODE cmd" "\0" /* word 83 bit 0 */ + /* -------------- */ + "" "\0" /* word 84 bit 15: !valid bit */ + "" "\0" /* word 84 bit 14: valid bit */ + "" "\0" /* word 84 bit 13: reserved */ + "" "\0" /* word 84 bit 12: reserved */ + "" "\0" /* word 84 bit 11: reserved */ + "" "\0" /* word 84 bit 10: reserved */ + "" "\0" /* word 84 bit 9: reserved */ + "" "\0" /* word 84 bit 8: reserved */ + "" "\0" /* word 84 bit 7: reserved */ + "" "\0" /* word 84 bit 6: reserved */ + "General Purpose Logging feature set" "\0" /* word 84 bit 5 */ + "" "\0" /* word 84 bit 4: reserved */ + "Media Card Pass Through Command feature set " "\0" + "Media serial number " "\0" /* word 84 bit 2 */ + "SMART self-test " "\0" /* word 84 bit 1 */ + "SMART error logging " /* word 84 bit 0 */ +; + +static const char secu_str[] ALIGN1 = + "supported" "\0" /* word 128, bit 0 */ + "enabled" "\0" /* word 128, bit 1 */ + "locked" "\0" /* word 128, bit 2 */ + "frozen" "\0" /* word 128, bit 3 */ + "expired: security count" "\0" /* word 128, bit 4 */ + "supported: enhanced erase" /* word 128, bit 5 */ +; // Parse 512 byte disk identification block and print much crap. - -static void identify(uint16_t *id_supplied) +static void identify(uint16_t *val) NORETURN; +static void identify(uint16_t *val) { - uint16_t buf[256]; - uint16_t *val, ii, jj, kk; + uint16_t ii, jj, kk; uint16_t like_std = 1, std = 0, min_std = 0xffff; uint16_t dev = NO_DEV, eqpt = NO_DEV; uint8_t have_mode = 0, err_dma = 0; @@ -556,19 +787,15 @@ static void identify(uint16_t *id_supplied) uint32_t ll, mm, nn, oo; uint64_t bbbig; /* (:) */ const char *strng; +#if BB_BIG_ENDIAN + uint16_t buf[256]; - // Adjust for endianness if necessary. - - if (BB_BIG_ENDIAN) { - swab(id_supplied, buf, sizeof(buf)); - val = buf; - } else - val = id_supplied; - - chksum &= 0xff; - - /* check if we recognise the device type */ - puts(""); + // Adjust for endianness + swab(val, buf, sizeof(buf)); + val = buf; +#endif + /* check if we recognize the device type */ + bb_putchar('\n'); if (!(val[GEN_CONFIG] & NOT_ATA)) { dev = ATA_DEV; printf("ATA device, with "); @@ -579,10 +806,10 @@ static void identify(uint16_t *id_supplied) } else if (!(val[GEN_CONFIG] & NOT_ATAPI)) { dev = ATAPI_DEV; eqpt = (val[GEN_CONFIG] & EQPT_TYPE) >> SHIFT_EQPT; - printf("ATAPI %s, with ", pkt_str[eqpt]); + printf("ATAPI %s, with ", eqpt <= 0xf ? nth_string(pkt_str, eqpt) : "unknown"); like_std = 3; } else - /*"Unknown device type:\n\tbits 15&14 of general configuration word 0 both set to 1.\n"*/ + /* "Unknown device type:\n\tbits 15&14 of general configuration word 0 both set to 1.\n" */ bb_error_msg_and_die("unknown device type"); printf("%sremovable media\n", !(val[GEN_CONFIG] & MEDIA_REMOVABLE) ? "non-" : ""); @@ -598,9 +825,9 @@ static void identify(uint16_t *id_supplied) ) { like_std = 5; if ((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==STBY_ID_VAL)) - printf("powers-up in standby; SET FEATURES subcmd spins-up.\n"); + puts("powers-up in standby; SET FEATURES subcmd spins-up."); if (((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==PWRD_NID_VAL)) && (val[GEN_CONFIG] & INCOMPLETE)) - printf("\n\tWARNING: ID response incomplete.\n\tFollowing data may be incorrect.\n\n"); + puts("\n\tWARNING: ID response incomplete.\n\tFollowing data may be incorrect.\n"); } /* output the model and serial numbers and the fw revision */ @@ -617,8 +844,8 @@ static void identify(uint16_t *id_supplied) if (val[MINOR] && (val[MINOR] <= MINOR_MAX)) { if (like_std < 3) like_std = 3; std = actual_ver[val[MINOR]]; - if (std) printf("\n\tUsed: %s ", minor_str[val[MINOR]]); - + if (std) + printf("\n\tUsed: %s ", nth_string(minor_str, val[MINOR])); } /* looks like when they up-issue the std, they obsolete one; * thus, only the newest 4 issues need be supported. (That's @@ -685,7 +912,7 @@ static void identify(uint16_t *id_supplied) else if (like_std > std) printf("& some of %u\n", like_std); else - puts(""); + bb_putchar('\n'); } else { /* TBD: do CDROM stuff more thoroughly. For now... */ kk = 0; @@ -702,7 +929,7 @@ static void identify(uint16_t *id_supplied) jj >>= 1; } } - printf("%s\n", kk ? "" : "\n\tLikely used CD-ROM ATAPI-1"); + puts(kk ? "" : "\n\tLikely used CD-ROM ATAPI-1"); /* the cdrom stuff is more like ATA-2 than anything else, so: */ like_std = 2; } @@ -710,13 +937,13 @@ static void identify(uint16_t *id_supplied) if (min_std == 0xffff) min_std = like_std > 4 ? like_std - 3 : 1; - printf("Configuration:\n"); + puts("Configuration:"); /* more info from the general configuration word */ if ((eqpt != CDROM) && (like_std == 1)) { jj = val[GEN_CONFIG] >> 1; for (ii = 1; ii < 15; ii++) { if (jj & 0x0001) - printf("\t%s\n", ata1_cfg_str[ii]); + printf("\t%s\n", nth_string(ata1_cfg_str, ii)); jj >>=1; } } @@ -728,7 +955,7 @@ static void identify(uint16_t *id_supplied) else if ((val[GEN_CONFIG] & DRQ_RESPONSE_TIME) == DRQ_50US_VAL) strng ="50us"; else - strng = "Unknown"; + strng = "unknown"; printf("\tDRQ response: %s\n\tPacket size: ", strng); /* Data Request (DRQ) */ if ((val[GEN_CONFIG] & PKT_SIZE_SUPPORTED) == PKT_SIZE_12_VAL) @@ -736,21 +963,32 @@ static void identify(uint16_t *id_supplied) else if ((val[GEN_CONFIG] & PKT_SIZE_SUPPORTED) == PKT_SIZE_16_VAL) strng = "16 bytes"; else - strng = "Unknown"; + strng = "unknown"; puts(strng); } else { /* addressing...CHS? See section 6.2 of ATA specs 4 or 5 */ ll = (uint32_t)val[LBA_SECTS_MSB] << 16 | val[LBA_SECTS_LSB]; - mm = 0; bbbig = 0; + mm = 0; + bbbig = 0; if ((ll > 0x00FBFC10) && (!val[LCYLS])) - printf("\tCHS addressing not supported\n"); + puts("\tCHS addressing not supported"); else { jj = val[WHATS_VALID] & OK_W54_58; - printf("\tLogical\t\tmax\tcurrent\n\tcylinders\t%u\t%u\n\theads\t\t%u\t%u\n\tsectors/track\t%u\t%u\n\t--\n", - val[LCYLS],jj?val[LCYLS_CUR]:0, val[LHEADS],jj?val[LHEADS_CUR]:0, val[LSECTS],jj?val[LSECTS_CUR]:0); + printf("\tLogical\t\tmax\tcurrent\n" + "\tcylinders\t%u\t%u\n" + "\theads\t\t%u\t%u\n" + "\tsectors/track\t%u\t%u\n" + "\t--\n", + val[LCYLS], + jj ? val[LCYLS_CUR] : 0, + val[LHEADS], + jj ? val[LHEADS_CUR] : 0, + val[LSECTS], + jj ? val[LSECTS_CUR] : 0); if ((min_std == 1) && (val[TRACK_BYTES] || val[SECT_BYTES])) - printf("\tbytes/track: %u\tbytes/sector: %u\n", val[TRACK_BYTES], val[SECT_BYTES]); + printf("\tbytes/track: %u\tbytes/sector: %u\n", + val[TRACK_BYTES], val[SECT_BYTES]); if (jj) { mm = (uint32_t)val[CAPACITY_MSB] << 16 | val[CAPACITY_LSB]; @@ -785,29 +1023,31 @@ static void identify(uint16_t *id_supplied) if (bbbig > 1000) printf("(%"PRIu64" GB)\n", bbbig/1000); else - puts(""); + bb_putchar('\n'); } /* hw support of commands (capabilities) */ printf("Capabilities:\n\t"); if (dev == ATAPI_DEV) { - if (eqpt != CDROM && (val[CAPAB_0] & CMD_Q_SUP)) printf("Cmd queuing, "); - if (val[CAPAB_0] & OVLP_SUP) printf("Cmd overlap, "); + if (eqpt != CDROM && (val[CAPAB_0] & CMD_Q_SUP)) + printf("Cmd queuing, "); + if (val[CAPAB_0] & OVLP_SUP) + printf("Cmd overlap, "); } if (val[CAPAB_0] & LBA_SUP) printf("LBA, "); if (like_std != 1) { printf("IORDY%s(can%s be disabled)\n", - !(val[CAPAB_0] & IORDY_SUP) ? "(may be)" : "", - (val[CAPAB_0] & IORDY_OFF) ? "" :"not"); + !(val[CAPAB_0] & IORDY_SUP) ? "(may be)" : "", + (val[CAPAB_0] & IORDY_OFF) ? "" :"not"); } else - printf("no IORDY\n"); + puts("no IORDY"); if ((like_std == 1) && val[BUF_TYPE]) { printf("\tBuffer type: %04x: %s%s\n", val[BUF_TYPE], - (val[BUF_TYPE] < 2) ? "single port, single-sector" : "dual port, multi-sector", - (val[BUF_TYPE] > 2) ? " with read caching ability" : ""); + (val[BUF_TYPE] < 2) ? "single port, single-sector" : "dual port, multi-sector", + (val[BUF_TYPE] > 2) ? " with read caching ability" : ""); } if ((min_std == 1) && (val[BUFFER__SIZE] && (val[BUFFER__SIZE] != NOVAL_1))) { @@ -824,26 +1064,28 @@ static void identify(uint16_t *id_supplied) if (like_std == 1) printf("\tCan%s perform double-word IO\n", (!val[DWORD_IO]) ? "not" : ""); else { - printf("\tStandby timer values: spec'd by %s", (val[CAPAB_0] & STD_STBY) ? "Standard" : "Vendor"); + printf("\tStandby timer values: spec'd by %s", + (val[CAPAB_0] & STD_STBY) ? "standard" : "vendor"); if ((like_std > 3) && ((val[CAPAB_1] & VALID) == VALID_VAL)) - printf(", %s device specific minimum\n", (val[CAPAB_1] & MIN_STANDBY_TIMER) ? "with" : "no"); + printf(", %s device specific minimum\n", + (val[CAPAB_1] & MIN_STANDBY_TIMER) ? "with" : "no"); else - puts(""); + bb_putchar('\n'); } printf("\tR/W multiple sector transfer: "); if ((like_std < 3) && !(val[SECTOR_XFER_MAX] & SECTOR_XFER)) - printf("not supported\n"); + puts("not supported"); else { printf("Max = %u\tCurrent = ", val[SECTOR_XFER_MAX] & SECTOR_XFER); if (val[SECTOR_XFER_CUR] & MULTIPLE_SETTING_VALID) printf("%u\n", val[SECTOR_XFER_CUR] & SECTOR_XFER); else - printf("?\n"); + puts("?"); } if ((like_std > 3) && (val[CMDS_SUPP_1] & 0x0008)) { /* We print out elsewhere whether the APM feature is enabled or - not. If it's not enabled, let's not repeat the info; just print - nothing here. */ + * not. If it's not enabled, let's not repeat the info; just print + * nothing here. */ printf("\tAdvancedPM level: "); if ((val[ADV_PWR] & 0xFF00) == 0x4000) { uint8_t apm_level = val[ADV_PWR] & 0x00FF; @@ -854,25 +1096,29 @@ static void identify(uint16_t *id_supplied) } if (like_std > 5 && val[ACOUSTIC]) { printf("\tRecommended acoustic management value: %u, current value: %u\n", - (val[ACOUSTIC] >> 8) & 0x00ff, val[ACOUSTIC] & 0x00ff); + (val[ACOUSTIC] >> 8) & 0x00ff, + val[ACOUSTIC] & 0x00ff); } } else { - /* ATAPI */ + /* ATAPI */ if (eqpt != CDROM && (val[CAPAB_0] & SWRST_REQ)) - printf("\tATA sw reset required\n"); + puts("\tATA sw reset required"); if (val[PKT_REL] || val[SVC_NBSY]) { printf("\tOverlap support:"); - if (val[PKT_REL]) printf(" %uus to release bus.", val[PKT_REL]); - if (val[SVC_NBSY]) printf(" %uus to clear BSY after SERVICE cmd.", val[SVC_NBSY]); - puts(""); + if (val[PKT_REL]) + printf(" %uus to release bus.", val[PKT_REL]); + if (val[SVC_NBSY]) + printf(" %uus to clear BSY after SERVICE cmd.", + val[SVC_NBSY]); + bb_putchar('\n'); } } /* DMA stuff. Check that only one DMA mode is selected. */ printf("\tDMA: "); if (!(val[CAPAB_0] & DMA_SUP)) - printf("not supported\n"); + puts("not supported"); else { if (val[DMA_MODE] && !val[SINGLE_DMA] && !val[MULTI_DMA]) printf(" sdma%u\n", (val[DMA_MODE] & MODE) >> 8); @@ -892,10 +1138,10 @@ static void identify(uint16_t *id_supplied) err_dma += mode_loop(jj, kk, 'u', &have_mode); } if (err_dma || !have_mode) printf("(?)"); - puts(""); + bb_putchar('\n'); if ((dev == ATAPI_DEV) && (eqpt != CDROM) && (val[CAPAB_0] & DMA_IL_SUP)) - printf("\t\tInterleaved DMA support\n"); + puts("\t\tInterleaved DMA support"); if ((val[WHATS_VALID] & OK_W64_70) && (val[DMA_TIME_MIN] || val[DMA_TIME_NORM]) @@ -903,7 +1149,7 @@ static void identify(uint16_t *id_supplied) printf("\t\tCycle time:"); if (val[DMA_TIME_MIN]) printf(" min=%uns", val[DMA_TIME_MIN]); if (val[DMA_TIME_NORM]) printf(" recommended=%uns", val[DMA_TIME_NORM]); - puts(""); + bb_putchar('\n'); } } @@ -917,30 +1163,34 @@ static void identify(uint16_t *id_supplied) if (jj & 0x0001) printf("pio%d ", ii); jj >>=1; } - puts(""); + bb_putchar('\n'); } else if (((min_std < 5) || (eqpt == CDROM)) && (val[PIO_MODE] & MODE)) { for (ii = 0; ii <= val[PIO_MODE]>>8; ii++) printf("pio%d ", ii); - puts(""); + bb_putchar('\n'); } else - printf("unknown\n"); + puts("unknown"); if (val[WHATS_VALID] & OK_W64_70) { if (val[PIO_NO_FLOW] || val[PIO_FLOW]) { printf("\t\tCycle time:"); - if (val[PIO_NO_FLOW]) printf(" no flow control=%uns", val[PIO_NO_FLOW]); - if (val[PIO_FLOW]) printf(" IORDY flow control=%uns", val[PIO_FLOW]); - puts(""); + if (val[PIO_NO_FLOW]) + printf(" no flow control=%uns", val[PIO_NO_FLOW]); + if (val[PIO_FLOW]) + printf(" IORDY flow control=%uns", val[PIO_FLOW]); + bb_putchar('\n'); } } if ((val[CMDS_SUPP_1] & VALID) == VALID_VAL) { - printf("Commands/features:\n\tEnabled\tSupported:\n"); + puts("Commands/features:\n" + "\tEnabled\tSupported:"); jj = val[CMDS_SUPP_0]; kk = val[CMDS_EN_0]; for (ii = 0; ii < NUM_CMD_FEAT_STR; ii++) { - if ((jj & 0x8000) && (*cmd_feat_str[ii] != '\0')) { - printf("\t%s\t%s\n", (kk & 0x8000) ? " *" : "", cmd_feat_str[ii]); + const char *feat_str = nth_string(cmd_feat_str, ii); + if ((jj & 0x8000) && (*feat_str != '\0')) { + printf("\t%s\t%s\n", (kk & 0x8000) ? " *" : "", feat_str); } jj <<= 1; kk <<= 1; @@ -956,39 +1206,43 @@ static void identify(uint16_t *id_supplied) } /* Removable Media Status Notification feature set */ if ((val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP) - printf("\t%s supported\n", cmd_feat_str[27]); + printf("\t%s supported\n", nth_string(cmd_feat_str, 27)); /* security */ if ((eqpt != CDROM) && (like_std > 3) && (val[SECU_STATUS] || val[ERASE_TIME] || val[ENH_ERASE_TIME]) ) { - printf("Security:\n"); + puts("Security:"); if (val[PSWD_CODE] && (val[PSWD_CODE] != NOVAL_1)) printf("\tMaster password revision code = %u\n", val[PSWD_CODE]); jj = val[SECU_STATUS]; if (jj) { for (ii = 0; ii < NUM_SECU_STR; ii++) { - printf("\t%s\t%s\n", (!(jj & 0x0001)) ? "not" : "", secu_str[ii]); + printf("\t%s\t%s\n", + (!(jj & 0x0001)) ? "not" : "", + nth_string(secu_str, ii)); jj >>=1; } if (val[SECU_STATUS] & SECU_ENABLED) { - printf("\tSecurity level %s\n", (val[SECU_STATUS] & SECU_LEVEL) ? "maximum" : "high"); + printf("\tSecurity level %s\n", + (val[SECU_STATUS] & SECU_LEVEL) ? "maximum" : "high"); } } jj = val[ERASE_TIME] & ERASE_BITS; kk = val[ENH_ERASE_TIME] & ERASE_BITS; if (jj || kk) { - printf("\t"); + bb_putchar('\t'); if (jj) printf("%umin for %sSECURITY ERASE UNIT. ", jj==ERASE_BITS ? 508 : jj<<1, ""); if (kk) printf("%umin for %sSECURITY ERASE UNIT. ", kk==ERASE_BITS ? 508 : kk<<1, "ENHANCED "); - puts(""); + bb_putchar('\n'); } } /* reset result */ jj = val[HWRST_RSLT]; if ((jj & VALID) == VALID_VAL) { - if (!(oo = (jj & RST0))) + oo = (jj & RST0); + if (!oo) jj >>= 8; if ((jj & DEV_DET) == JUMPER_VAL) strng = " determined by the jumper"; @@ -996,16 +1250,20 @@ static void identify(uint16_t *id_supplied) strng = " determined by CSEL"; else strng = ""; - printf("HW reset results:\n\tCBLID- %s Vih\n\tDevice num = %i%s\n", - (val[HWRST_RSLT] & CBLID) ? "above" : "below", !(oo), strng); + printf("HW reset results:\n" + "\tCBLID- %s Vih\n" + "\tDevice num = %i%s\n", + (val[HWRST_RSLT] & CBLID) ? "above" : "below", + !(oo), strng); } /* more stuff from std 5 */ if ((like_std > 4) && (eqpt != CDROM)) { if (val[CFA_PWR_MODE] & VALID_W160) { - printf("CFA power mode 1:\n\t%s%s\n", (val[CFA_PWR_MODE] & PWR_MODE_OFF) ? "disabled" : "enabled", - (val[CFA_PWR_MODE] & PWR_MODE_REQ) ? " and required by some commands" : ""); - + printf("CFA power mode 1:\n" + "\t%s%s\n", + (val[CFA_PWR_MODE] & PWR_MODE_OFF) ? "disabled" : "enabled", + (val[CFA_PWR_MODE] & PWR_MODE_REQ) ? " and required by some commands" : ""); if (val[CFA_PWR_MODE] & MAX_AMPS) printf("\tMaximum current = %uma\n", val[CFA_PWR_MODE] & MAX_AMPS); } @@ -1018,72 +1276,6 @@ static void identify(uint16_t *id_supplied) } #endif -static smallint get_identity, get_geom; -static smallint do_flush; -static smallint do_ctimings, do_timings; -static smallint reread_partn; - -static smallint set_piomode, noisy_piomode; -static smallint set_readahead, get_readahead; -static smallint set_readonly, get_readonly; -static smallint set_unmask, get_unmask; -static smallint set_mult, get_mult; -static smallint set_dma_q, get_dma_q; -static smallint set_nowerr, get_nowerr; -static smallint set_keep, get_keep; -static smallint set_io32bit, get_io32bit; -static int piomode; -static unsigned long Xreadahead; -static unsigned long readonly; -static unsigned long unmask; -static unsigned long mult; -static unsigned long dma_q; -static unsigned long nowerr; -static unsigned long keep; -static unsigned long io32bit; -#if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA -static unsigned long dma; -static smallint set_dma, get_dma; -#endif -#ifdef HDIO_DRIVE_CMD -static smallint set_xfermode, get_xfermode; -static smallint set_dkeep, get_dkeep; -static smallint set_standby, get_standby; -static smallint set_lookahead, get_lookahead; -static smallint set_prefetch, get_prefetch; -static smallint set_defects, get_defects; -static smallint set_wcache, get_wcache; -static smallint set_doorlock, get_doorlock; -static smallint set_seagate, get_seagate; -static smallint set_standbynow, get_standbynow; -static smallint set_sleepnow, get_sleepnow; -static smallint get_powermode; -static smallint set_apmmode, get_apmmode; -static int xfermode_requested; -static unsigned long dkeep; -static unsigned long standby_requested; -static unsigned long lookahead; -static unsigned long prefetch; -static unsigned long defects; -static unsigned long wcache; -static unsigned long doorlock; -static unsigned long apmmode; -#endif -USE_FEATURE_HDPARM_GET_IDENTITY( static smallint get_IDentity;) -USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( static smallint set_busstate, get_busstate;) -USE_FEATURE_HDPARM_HDIO_DRIVE_RESET( static smallint perform_reset;) -USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( static smallint perform_tristate;) -USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(static smallint unregister_hwif;) -USE_FEATURE_HDPARM_HDIO_SCAN_HWIF( static smallint scan_hwif;) -USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( static unsigned long busstate;) -USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( static unsigned long tristate;) -USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(static unsigned long hwif;) -#if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF -static unsigned long hwif_data; -static unsigned long hwif_ctrl; -static unsigned long hwif_irq; -#endif - // Historically, if there was no HDIO_OBSOLETE_IDENTITY, then // then the HDIO_GET_IDENTITY only returned 142 bytes. // Otherwise, HDIO_OBSOLETE_IDENTITY returns 142 bytes, @@ -1096,34 +1288,35 @@ static unsigned long hwif_irq; // Too bad, really. #if ENABLE_FEATURE_HDPARM_GET_IDENTITY -static const char *const cfg_str[] = { - "", "HardSect", "SoftSect", "NotMFM", - "HdSw>15uSec", "SpinMotCtl", "Fixed", "Removeable", - "DTR<=5Mbs", "DTR>5Mbs", "DTR>10Mbs", "RotSpdTol>.5%", - "dStbOff", "TrkOff", "FmtGapReq", "nonMagnetic" -}; - -static const char *const BuffType[] = { - "Unknown", "1Sect", "DualPort", "DualPortCache" -}; - -static void dump_identity(const struct hd_driveid *id) +static const char cfg_str[] ALIGN1 = + """\0" "HardSect""\0" "SoftSect""\0" "NotMFM""\0" + "HdSw>15uSec""\0" "SpinMotCtl""\0" "Fixed""\0" "Removeable""\0" + "DTR<=5Mbs""\0" "DTR>5Mbs""\0" "DTR>10Mbs""\0" "RotSpdTol>.5%""\0" + "dStbOff""\0" "TrkOff""\0" "FmtGapReq""\0" "nonMagnetic" +; + +static const char BuffType[] ALIGN1 = + "unknown""\0" "1Sect""\0" "DualPort""\0" "DualPortCache" +; + +static NOINLINE void dump_identity(const struct hd_driveid *id) { int i; - const unsigned short int *id_regs = (const void*) id; + const unsigned short *id_regs = (const void*) id; printf("\n Model=%.40s, FwRev=%.8s, SerialNo=%.20s\n Config={", id->model, id->fw_rev, id->serial_no); for (i = 0; i <= 15; i++) { if (id->config & (1<cyls, id->heads, id->sectors, id->track_bytes, - id->sector_bytes, id->ecc_bytes, - id->buf_type, BuffType[(id->buf_type > 3) ? 0 : id->buf_type], - id->buf_size/2, id->max_multsect); + " BuffType=(%u) %s, BuffSize=%ukB, MaxMultSect=%u", + id->cyls, id->heads, id->sectors, id->track_bytes, + id->sector_bytes, id->ecc_bytes, + id->buf_type, + nth_string(BuffType, (id->buf_type > 3) ? 0 : id->buf_type), + id->buf_size/2, id->max_multsect); if (id->max_multsect) { printf(", MultSect="); if (!(id->multsect_valid & 1)) @@ -1133,7 +1326,7 @@ static void dump_identity(const struct hd_driveid *id) else printf("off"); } - puts(""); + bb_putchar('\n'); if (!(id->field_valid & 1)) printf(" (maybe):"); @@ -1148,7 +1341,10 @@ static void dump_identity(const struct hd_driveid *id) if (id->capability & 2) printf(", LBAsects=%u", id->lba_capacity); - printf("\n IORDY=%s", (id->capability & 8) ? (id->capability & 4) ? "on/off" : "yes" : "no"); + printf("\n IORDY=%s", + (id->capability & 8) + ? ((id->capability & 4) ? "on/off" : "yes") + : "no"); if (((id->capability & 8) || (id->field_valid & 2)) && (id->field_valid & 2)) printf(", tPIO={min:%u,w/IORDY:%u}", id->eide_pio, id->eide_pio_iordy); @@ -1163,54 +1359,46 @@ static void dump_identity(const struct hd_driveid *id) if (id->tPIO >= 2) printf("pio2 "); } if (id->field_valid & 2) { - if (id->eide_pio_modes & 1) printf("pio3 "); - if (id->eide_pio_modes & 2) printf("pio4 "); - if (id->eide_pio_modes &~3) printf("pio? "); + static const masks_labels_t pio_modes = { + .masks = { 1, 2, ~3 }, + .labels = "pio3 \0""pio4 \0""pio? \0", + }; + print_flags(&pio_modes, id->eide_pio_modes); } if (id->capability & 1) { if (id->dma_1word | id->dma_mword) { + static const int dma_wmode_masks[] = { 0x100, 1, 0x200, 2, 0x400, 4, 0xf800, 0xf8 }; printf("\n DMA modes: "); - if (id->dma_1word & 0x100) printf("*"); - if (id->dma_1word & 1) printf("sdma0 "); - if (id->dma_1word & 0x200) printf("*"); - if (id->dma_1word & 2) printf("sdma1 "); - if (id->dma_1word & 0x400) printf("*"); - if (id->dma_1word & 4) printf("sdma2 "); - if (id->dma_1word & 0xf800) printf("*"); - if (id->dma_1word & 0xf8) printf("sdma? "); - if (id->dma_mword & 0x100) printf("*"); - if (id->dma_mword & 1) printf("mdma0 "); - if (id->dma_mword & 0x200) printf("*"); - if (id->dma_mword & 2) printf("mdma1 "); - if (id->dma_mword & 0x400) printf("*"); - if (id->dma_mword & 4) printf("mdma2 "); - if (id->dma_mword & 0xf800) printf("*"); - if (id->dma_mword & 0xf8) printf("mdma? "); + print_flags_separated(dma_wmode_masks, + "*\0""sdma0 \0""*\0""sdma1 \0""*\0""sdma2 \0""*\0""sdma? \0", + id->dma_1word, NULL); + print_flags_separated(dma_wmode_masks, + "*\0""mdma0 \0""*\0""mdma1 \0""*\0""mdma2 \0""*\0""mdma? \0", + id->dma_mword, NULL); } } if (((id->capability & 8) || (id->field_valid & 2)) && id->field_valid & 4) { + static const masks_labels_t ultra_modes1 = { + .masks = { 0x100, 0x001, 0x200, 0x002, 0x400, 0x004 }, + .labels = "*\0""udma0 \0""*\0""udma1 \0""*\0""udma2 \0", + }; + printf("\n UDMA modes: "); - if (id->dma_ultra & 0x100) printf("*"); - if (id->dma_ultra & 0x001) printf("udma0 "); - if (id->dma_ultra & 0x200) printf("*"); - if (id->dma_ultra & 0x002) printf("udma1 "); - if (id->dma_ultra & 0x400) printf("*"); - if (id->dma_ultra & 0x004) printf("udma2 "); + print_flags(&ultra_modes1, id->dma_ultra); #ifdef __NEW_HD_DRIVE_ID if (id->hw_config & 0x2000) { #else /* !__NEW_HD_DRIVE_ID */ if (id->word93 & 0x2000) { #endif /* __NEW_HD_DRIVE_ID */ - if (id->dma_ultra & 0x0800) printf("*"); - if (id->dma_ultra & 0x0008) printf("udma3 "); - if (id->dma_ultra & 0x1000) printf("*"); - if (id->dma_ultra & 0x0010) printf("udma4 "); - if (id->dma_ultra & 0x2000) printf("*"); - if (id->dma_ultra & 0x0020) printf("udma5 "); - if (id->dma_ultra & 0x4000) printf("*"); - if (id->dma_ultra & 0x0040) printf("udma6 "); - if (id->dma_ultra & 0x8000) printf("*"); - if (id->dma_ultra & 0x0080) printf("udma7 "); + static const masks_labels_t ultra_modes2 = { + .masks = { 0x0800, 0x0008, 0x1000, 0x0010, + 0x2000, 0x0020, 0x4000, 0x0040, + 0x8000, 0x0080 }, + .labels = "*\0""udma3 \0""*\0""udma4 \0" + "*\0""udma5 \0""*\0""udma6 \0" + "*\0""udma7 \0" + }; + print_flags(&ultra_modes2, id->dma_ultra); } } printf("\n AdvancedPM=%s", (!(id_regs[83] & 8)) ? "no" : "yes"); @@ -1228,21 +1416,23 @@ static void dump_identity(const struct hd_driveid *id) if ((id->minor_rev_num && id->minor_rev_num <= 31) || (id->major_rev_num && id->minor_rev_num <= 31) ) { - printf("\n Drive conforms to: %s: ", (id->minor_rev_num <= 31) ? minor_str[id->minor_rev_num] : "Unknown"); - if (id->major_rev_num != 0x0000 && /* NOVAL_0 */ - id->major_rev_num != 0xFFFF) { /* NOVAL_1 */ + printf("\n Drive conforms to: %s: ", + (id->minor_rev_num <= 31) ? nth_string(minor_str, id->minor_rev_num) : "unknown"); + if (id->major_rev_num != 0x0000 /* NOVAL_0 */ + && id->major_rev_num != 0xFFFF /* NOVAL_1 */ + ) { for (i = 0; i <= 15; i++) { if (id->major_rev_num & (1< UINT_MAX) + return UINT_MAX; + return u.blksize64; } -static void print_timing(unsigned t, double e) +static void print_timing(unsigned m, unsigned elapsed_us) { - if (t >= e) /* more than 1MB/s */ - printf("%4d MB in %.2f seconds = %.2f %cB/sec\n", t, e, t / e, 'M'); - else - printf("%4d MB in %.2f seconds = %.2f %cB/sec\n", t, e, t / e * 1024, 'k'); + unsigned sec = elapsed_us / 1000000; + unsigned hs = (elapsed_us % 1000000) / 10000; + + printf("%5u MB in %u.%02u seconds = %u kB/s\n", + m, sec, hs, + /* "| 1" prevents div-by-0 */ + (unsigned) ((unsigned long long)m * (1024 * 1000000) / (elapsed_us | 1)) + // ~= (m * 1024) / (elapsed_us / 1000000) + // = kb / elapsed_sec + ); } -static void do_time(int flag, int fd) -/* flag = 0 time_cache, 1 time_device */ +static void do_time(int cache /*,int fd*/) +/* cache=1: time cache: repeatedly read N MB at offset 0 + * cache=0: time device: linear read, starting at offset 0 + */ { - static const struct itimerval thousand = {{1000, 0}, {1000, 0}}; - - struct itimerval itv; + unsigned max_iterations, iterations; + unsigned start; /* doesn't need to be long long */ unsigned elapsed, elapsed2; - unsigned max_iterations, total_MB, iterations; - unsigned long long blksize; - RESERVE_CONFIG_BUFFER(buf, TIMING_BUF_BYTES); + unsigned total_MB; + char *buf = xmalloc(TIMING_BUF_BYTES); - if (mlock(buf, TIMING_BUF_BYTES)) { - bb_perror_msg("mlock"); - goto quit2; - } + if (mlock(buf, TIMING_BUF_BYTES)) + bb_perror_msg_and_die("mlock"); - max_iterations = 1024; - if (0 == do_blkgetsize(fd, &blksize)) { - max_iterations = blksize / (2 * 1024) / TIMING_BUF_MB; - } - - /* Clear out the device request queues & give them time to complete */ + /* Clear out the device request queues & give them time to complete. + * NB: *small* delay. User is expected to have a clue and to not run + * heavy io in parallel with measurements. */ sync(); - sleep(2); - if (flag == 0) { /* Time cache */ - if (seek_to_zero(fd)) - goto quit; - if (read_big_block(fd, buf)) - goto quit; - printf(" Timing buffer-cache reads: "); + sleep(1); + if (cache) { /* Time cache */ + seek_to_zero(); + read_big_block(buf); + printf("Timing buffer-cache reads: "); } else { /* Time device */ - printf(" Timing buffered disk reads: "); + printf("Timing buffered disk reads:"); } - fflush(stdout); - iterations = 0; - /* - * getitimer() is used rather than gettimeofday() because - * it is much more consistent (on my machine, at least). - */ - setitimer(ITIMER_REAL, &thousand, NULL); + fflush_all(); + /* Now do the timing */ + iterations = 0; + /* Max time to run (small for cache, avoids getting + * huge total_MB which can overlow unsigned type) */ + elapsed2 = 510000; /* cache */ + max_iterations = UINT_MAX; + if (!cache) { + elapsed2 = 3000000; /* not cache */ + /* Don't want to read past the end! */ + max_iterations = dev_size_mb() / TIMING_BUF_MB; + } + start = monotonic_us(); do { + if (cache) + seek_to_zero(); + read_big_block(buf); + elapsed = (unsigned)monotonic_us() - start; ++iterations; - if ((flag == 0) && seek_to_zero(fd)) - goto quit; - if (read_big_block(fd, buf)) - goto quit; - getitimer(ITIMER_REAL, &itv); - elapsed = (1000 - itv.it_value.tv_sec) * 1000000 - - itv.it_value.tv_usec; - } while (elapsed < 3000000 && iterations < max_iterations); + } while (elapsed < elapsed2 && iterations < max_iterations); total_MB = iterations * TIMING_BUF_MB; - if (flag == 0) { - /* Now remove the lseek() and getitimer() overheads from the elapsed time */ - setitimer(ITIMER_REAL, &thousand, NULL); + //printf(" elapsed:%u iterations:%u ", elapsed, iterations); + if (cache) { + /* Cache: remove lseek() and monotonic_us() overheads + * from elapsed */ + start = monotonic_us(); do { - if (seek_to_zero(fd)) - goto quit; - getitimer(ITIMER_REAL, &itv); - elapsed2 = (1000 - itv.it_value.tv_sec) * 1000000 - - itv.it_value.tv_usec; + seek_to_zero(); + elapsed2 = (unsigned)monotonic_us() - start; } while (--iterations); + //printf(" elapsed2:%u ", elapsed2); elapsed -= elapsed2; - total_MB *= BUFCACHE_FACTOR; - flush_buffer_cache(fd); + total_MB *= 2; // BUFCACHE_FACTOR (why?) + flush_buffer_cache(); } - print_timing(total_MB, elapsed / 1000000.0); - quit: + print_timing(total_MB, elapsed); munlock(buf, TIMING_BUF_BYTES); - quit2: - RELEASE_CONFIG_BUFFER(buf); + free(buf); } #if ENABLE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF @@ -1382,95 +1569,61 @@ static void bus_state_value(unsigned value) else if (value == BUSSTATE_OFF) on_off(0); else if (value == BUSSTATE_TRISTATE) - printf(" (tristate)\n"); + puts(" (tristate)"); else - printf(" (unknown: %d)\n", value); + printf(" (unknown: %u)\n", value); } #endif #ifdef HDIO_DRIVE_CMD -static void interpret_standby(unsigned standby) +static void interpret_standby(uint8_t standby) { - unsigned t; - printf(" ("); - if (standby == 0) + if (standby == 0) { printf("off"); - else if (standby == 252) - printf("21 minutes"); - else if (standby == 253) - printf("vendor-specific"); - else if (standby == 254) - printf("Reserved"); - else if (standby == 255) - printf("21 minutes + 15 seconds"); - else if (standby <= 240) { - t = standby * 5; - printf("%u minutes + %u seconds", t / 60, t % 60); + } else if (standby <= 240 || standby == 252 || standby == 255) { + /* standby is in 5 sec units */ + unsigned t = standby * 5; + printf("%u minutes %u seconds", t / 60, t % 60); } else if (standby <= 251) { - t = (standby - 240) * 30; - printf("%u hours + %u minutes", t / 60, t % 60); - } else - printf("illegal value"); - printf(")\n"); + unsigned t = (standby - 240); /* t is in 30 min units */; + printf("%u.%c hours", t / 2, (t & 1) ? '5' : '0'); + } + if (standby == 253) + printf("vendor-specific"); + if (standby == 254) + printf("reserved"); + puts(")"); } -struct xfermode_entry { - int val; - const char *name; +static const uint8_t xfermode_val[] ALIGN1 = { + 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, + 32, 33, 34, 35, 36, 37, 38, 39, + 64, 65, 66, 67, 68, 69, 70, 71 }; - -static const struct xfermode_entry xfermode_table[] = { - { 8, "pio0" }, - { 9, "pio1" }, - { 10, "pio2" }, - { 11, "pio3" }, - { 12, "pio4" }, - { 13, "pio5" }, - { 14, "pio6" }, - { 15, "pio7" }, - { 16, "sdma0" }, - { 17, "sdma1" }, - { 18, "sdma2" }, - { 19, "sdma3" }, - { 20, "sdma4" }, - { 21, "sdma5" }, - { 22, "sdma6" }, - { 23, "sdma7" }, - { 32, "mdma0" }, - { 33, "mdma1" }, - { 34, "mdma2" }, - { 35, "mdma3" }, - { 36, "mdma4" }, - { 37, "mdma5" }, - { 38, "mdma6" }, - { 39, "mdma7" }, - { 64, "udma0" }, - { 65, "udma1" }, - { 66, "udma2" }, - { 67, "udma3" }, - { 68, "udma4" }, - { 69, "udma5" }, - { 70, "udma6" }, - { 71, "udma7" }, - { 0, NULL } +/* NB: we save size by _not_ storing terninating NUL! */ +static const char xfermode_name[][5] ALIGN1 = { + "pio0", "pio1", "pio2", "pio3", "pio4", "pio5", "pio6", "pio7", + "sdma0","sdma1","sdma2","sdma3","sdma4","sdma5","sdma6","sdma7", + "mdma0","mdma1","mdma2","mdma3","mdma4","mdma5","mdma6","mdma7", + "udma0","udma1","udma2","udma3","udma4","udma5","udma6","udma7" }; -static int translate_xfermode(char * name) +static int translate_xfermode(const char *name) { - const struct xfermode_entry *tmp; - char *endptr; - int val = -1; + int val; + unsigned i; - for (tmp = xfermode_table; tmp->name != NULL; ++tmp) { - if (!strcmp(name, tmp->name)) - return tmp->val; + for (i = 0; i < ARRAY_SIZE(xfermode_val); i++) { + if (!strncmp(name, xfermode_name[i], 5)) + if (strlen(name) <= 5) + return xfermode_val[i]; } - - val = strtol(name, &endptr, 10); - if (*endptr == '\0') + /* Negative numbers are invalid and are caught later */ + val = bb_strtoi(name, NULL, 10); + if (!errno) return val; - return -1; } @@ -1482,28 +1635,28 @@ static void interpret_xfermode(unsigned xfermode) else if (xfermode == 1) printf("default PIO mode, disable IORDY"); else if (xfermode >= 8 && xfermode <= 15) - printf("PIO flow control mode%u", xfermode-8); + printf("PIO flow control mode%u", xfermode - 8); else if (xfermode >= 16 && xfermode <= 23) - printf("singleword DMA mode%u", xfermode-16); + printf("singleword DMA mode%u", xfermode - 16); else if (xfermode >= 32 && xfermode <= 39) - printf("multiword DMA mode%u", xfermode-32); + printf("multiword DMA mode%u", xfermode - 32); else if (xfermode >= 64 && xfermode <= 71) - printf("UltraDMA mode%u", xfermode-64); + printf("UltraDMA mode%u", xfermode - 64); else - printf("Unknown"); - printf(")\n"); + printf("unknown"); + puts(")"); } #endif /* HDIO_DRIVE_CMD */ static void print_flag(int flag, const char *s, unsigned long value) { if (flag) - printf(" setting %s to %ld\n", s, value); + printf(" setting %s to %lu\n", s, value); } static void process_dev(char *devname) { - int fd; + /*int fd;*/ long parm, multcount; #ifndef HDIO_DRIVE_CMD int force_operation = 0; @@ -1513,11 +1666,12 @@ static void process_dev(char *devname) unsigned char args[4] = { WIN_SETFEATURES, 0, 0, 0 }; const char *fmt = " %s\t= %2ld"; - fd = xopen(devname, O_RDONLY|O_NONBLOCK); + /*fd = xopen_nonblocking(devname);*/ + xmove_fd(xopen_nonblocking(devname), fd); printf("\n%s:\n", devname); - if (set_readahead) { - print_flag(get_readahead, "fs readahead", Xreadahead); + if (getset_readahead == IS_SET) { + print_flag(getset_readahead, "fs readahead", Xreadahead); ioctl_or_warn(fd, BLKRASET, (int *)Xreadahead); } #if ENABLE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF @@ -1527,7 +1681,7 @@ static void process_dev(char *devname) } #endif #if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF - if (scan_hwif) { + if (scan_hwif == IS_SET) { printf(" attempting to scan hwif (0x%lx, 0x%lx, %lu)\n", hwif_data, hwif_ctrl, hwif_irq); args[0] = hwif_data; args[1] = hwif_ctrl; @@ -1541,7 +1695,7 @@ static void process_dev(char *devname) if (noisy_piomode) { printf(" attempting to "); if (piomode == 255) - printf("auto-tune PIO mode\n"); + puts("auto-tune PIO mode"); else if (piomode < 100) printf("set PIO mode to %d\n", piomode); else if (piomode < 200) @@ -1551,102 +1705,103 @@ static void process_dev(char *devname) } ioctl_or_warn(fd, HDIO_SET_PIO_MODE, (int *)(unsigned long)piomode); } - if (set_io32bit) { - print_flag(get_io32bit, "32-bit IO_support flag", io32bit); + if (getset_io32bit == IS_SET) { + print_flag(getset_io32bit, "32-bit IO_support flag", io32bit); ioctl_or_warn(fd, HDIO_SET_32BIT, (int *)io32bit); } - if (set_mult) { - print_flag(get_mult, "multcount", mult); + if (getset_mult == IS_SET) { + print_flag(getset_mult, "multcount", mult); #ifdef HDIO_DRIVE_CMD ioctl_or_warn(fd, HDIO_SET_MULTCOUNT, (void *)mult); #else force_operation |= (!ioctl_or_warn(fd, HDIO_SET_MULTCOUNT, (void *)mult)); #endif } - if (set_readonly) { - print_flag_on_off(get_readonly, "readonly", readonly); + if (getset_readonly == IS_SET) { + print_flag_on_off(getset_readonly, "readonly", readonly); ioctl_or_warn(fd, BLKROSET, &readonly); } - if (set_unmask) { - print_flag_on_off(get_unmask, "unmaskirq", unmask); + if (getset_unmask == IS_SET) { + print_flag_on_off(getset_unmask, "unmaskirq", unmask); ioctl_or_warn(fd, HDIO_SET_UNMASKINTR, (int *)unmask); } #if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA - if (set_dma) { - print_flag_on_off(get_dma, "using_dma", dma); + if (getset_dma == IS_SET) { + print_flag_on_off(getset_dma, "using_dma", dma); ioctl_or_warn(fd, HDIO_SET_DMA, (int *)dma); } #endif /* FEATURE_HDPARM_HDIO_GETSET_DMA */ - if (set_dma_q) { - print_flag_on_off(get_dma_q, "DMA queue_depth", dma_q); +#ifdef HDIO_SET_QDMA + if (getset_dma_q == IS_SET) { + print_flag_on_off(getset_dma_q, "DMA queue_depth", dma_q); ioctl_or_warn(fd, HDIO_SET_QDMA, (int *)dma_q); } - if (set_nowerr) { - print_flag_on_off(get_nowerr, "nowerr", nowerr); +#endif + if (getset_nowerr == IS_SET) { + print_flag_on_off(getset_nowerr, "nowerr", nowerr); ioctl_or_warn(fd, HDIO_SET_NOWERR, (int *)nowerr); } - if (set_keep) { - print_flag_on_off(get_keep, "keep_settings", keep); + if (getset_keep == IS_SET) { + print_flag_on_off(getset_keep, "keep_settings", keep); ioctl_or_warn(fd, HDIO_SET_KEEPSETTINGS, (int *)keep); } #ifdef HDIO_DRIVE_CMD - if (set_doorlock) { + if (getset_doorlock == IS_SET) { args[0] = doorlock ? WIN_DOORLOCK : WIN_DOORUNLOCK; args[2] = 0; - print_flag_on_off(get_doorlock, "drive doorlock", doorlock); + print_flag_on_off(getset_doorlock, "drive doorlock", doorlock); ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); args[0] = WIN_SETFEATURES; } - if (set_dkeep) { + if (getset_dkeep == IS_SET) { /* lock/unlock the drive's "feature" settings */ - print_flag_on_off(get_dkeep, "drive keep features", dkeep); + print_flag_on_off(getset_dkeep, "drive keep features", dkeep); args[2] = dkeep ? 0x66 : 0xcc; ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); } - if (set_defects) { + if (getset_defects == IS_SET) { args[2] = defects ? 0x04 : 0x84; - print_flag(get_defects, "drive defect-mgmt", defects); + print_flag(getset_defects, "drive defect-mgmt", defects); ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); } - if (set_prefetch) { + if (getset_prefetch == IS_SET) { args[1] = prefetch; args[2] = 0xab; - print_flag(get_prefetch, "drive prefetch", prefetch); + print_flag(getset_prefetch, "drive prefetch", prefetch); ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); args[1] = 0; } if (set_xfermode) { args[1] = xfermode_requested; args[2] = 3; - if (get_xfermode) { - print_flag(1, "xfermode", xfermode_requested); - interpret_xfermode(xfermode_requested); - } + print_flag(1, "xfermode", xfermode_requested); + interpret_xfermode(xfermode_requested); ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); args[1] = 0; } - if (set_lookahead) { + if (getset_lookahead == IS_SET) { args[2] = lookahead ? 0xaa : 0x55; - print_flag_on_off(get_lookahead, "drive read-lookahead", lookahead); + print_flag_on_off(getset_lookahead, "drive read-lookahead", lookahead); ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); } - if (set_apmmode) { - args[2] = (apmmode == 255) ? 0x85 /* disable */ : 0x05 /* set */; /* feature register */ + if (getset_apmmode == IS_SET) { + /* feature register */ + args[2] = (apmmode == 255) ? 0x85 /* disable */ : 0x05 /* set */; args[1] = apmmode; /* sector count register 1-255 */ - if (get_apmmode) - printf(" setting APM level to %s 0x%02lX (%ld)\n", (apmmode == 255) ? "disabled" : "", apmmode, apmmode); + printf(" setting APM level to %s 0x%02lX (%ld)\n", + (apmmode == 255) ? "disabled" : "", + apmmode, apmmode); ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); args[1] = 0; } - if (set_wcache) { + if (getset_wcache == IS_SET) { #ifdef DO_FLUSHCACHE #ifndef WIN_FLUSHCACHE #define WIN_FLUSHCACHE 0xe7 #endif - static unsigned char flushcache[4] = { WIN_FLUSHCACHE, 0, 0, 0 }; #endif /* DO_FLUSHCACHE */ args[2] = wcache ? 0x02 : 0x82; - print_flag_on_off(get_wcache, "drive write-caching", wcache); + print_flag_on_off(getset_wcache, "drive write-caching", wcache); #ifdef DO_FLUSHCACHE if (!wcache) ioctl_or_warn(fd, HDIO_DRIVE_CMD, &flushcache); @@ -1669,9 +1824,9 @@ static void process_dev(char *devname) #ifndef WIN_STANDBYNOW2 #define WIN_STANDBYNOW2 0x94 #endif - if (get_standbynow) printf(" issuing standby command\n"); + puts(" issuing standby command"); args[0] = WIN_STANDBYNOW1; - ioctl_alt_or_warn(fd, HDIO_DRIVE_CMD, args, WIN_STANDBYNOW2); + ioctl_alt_or_warn(HDIO_DRIVE_CMD, args, WIN_STANDBYNOW2); } if (set_sleepnow) { #ifndef WIN_SLEEPNOW1 @@ -1680,99 +1835,96 @@ static void process_dev(char *devname) #ifndef WIN_SLEEPNOW2 #define WIN_SLEEPNOW2 0x99 #endif - if (get_sleepnow) printf(" issuing sleep command\n"); + puts(" issuing sleep command"); args[0] = WIN_SLEEPNOW1; - ioctl_alt_or_warn(fd, HDIO_DRIVE_CMD, args, WIN_SLEEPNOW2); + ioctl_alt_or_warn(HDIO_DRIVE_CMD, args, WIN_SLEEPNOW2); } if (set_seagate) { args[0] = 0xfb; - if (get_seagate) printf(" disabling Seagate auto powersaving mode\n"); + puts(" disabling Seagate auto powersaving mode"); ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); } - if (set_standby) { + if (getset_standby == IS_SET) { args[0] = WIN_SETIDLE1; args[1] = standby_requested; - if (get_standby) { - print_flag(1, "standby", standby_requested); - interpret_standby(standby_requested); - } + print_flag(1, "standby", standby_requested); + interpret_standby(standby_requested); ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args); args[1] = 0; } #else /* HDIO_DRIVE_CMD */ if (force_operation) { char buf[512]; - flush_buffer_cache(fd); + flush_buffer_cache(); if (-1 == read(fd, buf, sizeof(buf))) - bb_perror_msg("read(%d bytes) failed (rc=%d)", sizeof(buf), -1); + bb_perror_msg("read of 512 bytes failed"); } -#endif /* HDIO_DRIVE_CMD */ - - if (get_mult || get_identity) { +#endif /* HDIO_DRIVE_CMD */ + if (getset_mult || get_identity) { multcount = -1; if (ioctl(fd, HDIO_GET_MULTCOUNT, &multcount)) { - if (get_mult && ENABLE_IOCTL_HEX2STR_ERROR) /* To be coherent with ioctl_or_warn. */ + /* To be coherent with ioctl_or_warn. */ + if (getset_mult && ENABLE_IOCTL_HEX2STR_ERROR) bb_perror_msg("HDIO_GET_MULTCOUNT"); else bb_perror_msg("ioctl %#x failed", HDIO_GET_MULTCOUNT); - } else if (get_mult) { + } else if (getset_mult) { printf(fmt, "multcount", multcount); on_off(multcount != 0); } } - if (get_io32bit) { + if (getset_io32bit) { if (!ioctl_or_warn(fd, HDIO_GET_32BIT, &parm)) { printf(" IO_support\t=%3ld (", parm); if (parm == 0) - printf("default 16-bit)\n"); + puts("default 16-bit)"); else if (parm == 2) - printf("16-bit)\n"); + puts("16-bit)"); else if (parm == 1) - printf("32-bit)\n"); + puts("32-bit)"); else if (parm == 3) - printf("32-bit w/sync)\n"); + puts("32-bit w/sync)"); else if (parm == 8) - printf("Request-Queue-Bypass)\n"); + puts("Request-Queue-Bypass)"); else - printf("\?\?\?)\n"); + puts("\?\?\?)"); } } - if (get_unmask) { - if(!ioctl_or_warn(fd, HDIO_GET_UNMASKINTR, (unsigned long *)parm)) + if (getset_unmask) { + if (!ioctl_or_warn(fd, HDIO_GET_UNMASKINTR, &parm)) print_value_on_off("unmaskirq", parm); } - - #if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA - if (get_dma) { + if (getset_dma) { if (!ioctl_or_warn(fd, HDIO_GET_DMA, &parm)) { printf(fmt, "using_dma", parm); if (parm == 8) - printf(" (DMA-Assisted-PIO)\n"); + puts(" (DMA-Assisted-PIO)"); else on_off(parm != 0); } } #endif - if (get_dma_q) { - if(!ioctl_or_warn(fd, HDIO_GET_QDMA, (unsigned long *)parm)) +#ifdef HDIO_GET_QDMA + if (getset_dma_q) { + if (!ioctl_or_warn(fd, HDIO_GET_QDMA, &parm)) print_value_on_off("queue_depth", parm); } - if (get_keep) { - if(!ioctl_or_warn(fd, HDIO_GET_KEEPSETTINGS, (unsigned long *)parm)) +#endif + if (getset_keep) { + if (!ioctl_or_warn(fd, HDIO_GET_KEEPSETTINGS, &parm)) print_value_on_off("keepsettings", parm); } - - if (get_nowerr) { - if(!ioctl_or_warn(fd, HDIO_GET_NOWERR, (unsigned long *)parm)) + if (getset_nowerr) { + if (!ioctl_or_warn(fd, HDIO_GET_NOWERR, &parm)) print_value_on_off("nowerr", parm); } - if (get_readonly) { - if(!ioctl_or_warn(fd, BLKROGET, (unsigned long *)parm)) + if (getset_readonly) { + if (!ioctl_or_warn(fd, BLKROGET, &parm)) print_value_on_off("readonly", parm); } - if (get_readahead) { - if(!ioctl_or_warn(fd, BLKRAGET, (unsigned long *)parm)) + if (getset_readahead) { + if (!ioctl_or_warn(fd, BLKRAGET, &parm)) print_value_on_off("readahead", parm); } if (get_geom) { @@ -1781,7 +1933,7 @@ static void process_dev(char *devname) if (!ioctl_or_warn(fd, HDIO_GETGEO, &g)) printf(" geometry\t= %u/%u/%u, sectors = %ld, start = %ld\n", - g.cylinders, g.heads, g.sectors, parm, g.start); + g.cylinders, g.heads, g.sectors, parm, g.start); } } #ifdef HDIO_DRIVE_CMD @@ -1795,7 +1947,7 @@ static void process_dev(char *devname) const char *state; args[0] = WIN_CHECKPOWERMODE1; - if (ioctl_alt_or_warn(fd, HDIO_DRIVE_CMD, args, WIN_CHECKPOWERMODE2)) { + if (ioctl_alt_or_warn(HDIO_DRIVE_CMD, args, WIN_CHECKPOWERMODE2)) { if (errno != EIO || args[0] != 0 || args[1] != 0) state = "unknown"; else @@ -1831,7 +1983,7 @@ static void process_dev(char *devname) id.multsect_valid &= ~1; dump_identity(&id); } else if (errno == -ENOMSG) - printf(" no identification info available\n"); + puts(" no identification info available"); else if (ENABLE_IOCTL_HEX2STR_ERROR) /* To be coherent with ioctl_or_warn */ bb_perror_msg("HDIO_GET_IDENTITY"); else @@ -1844,19 +1996,17 @@ static void process_dev(char *devname) memset(args1, 0, sizeof(args1)); args1[0] = WIN_IDENTIFY; args1[3] = 1; - if (!ioctl_alt_or_warn(fd, HDIO_DRIVE_CMD, args1, WIN_PIDENTIFY)) + if (!ioctl_alt_or_warn(HDIO_DRIVE_CMD, args1, WIN_PIDENTIFY)) identify((void *)(args1 + 4)); } #endif #if ENABLE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF - if (set_busstate) { - if (get_busstate) { - print_flag(1, "bus state", busstate); - bus_state_value(busstate); - } + if (getset_busstate == IS_SET) { + print_flag(1, "bus state", busstate); + bus_state_value(busstate); ioctl_or_warn(fd, HDIO_SET_BUSSTATE, (int *)(unsigned long)busstate); } - if (get_busstate) { + if (getset_busstate) { if (!ioctl_or_warn(fd, HDIO_GET_BUSSTATE, &parm)) { printf(fmt, "bus state", parm); bus_state_value(parm); @@ -1867,11 +2017,11 @@ static void process_dev(char *devname) ioctl_or_warn(fd, BLKRRPART, NULL); if (do_ctimings) - do_time(0, fd); /* time cache */ + do_time(1 /*,fd*/); /* time cache */ if (do_timings) - do_time(1, fd); /* time device */ + do_time(0 /*,fd*/); /* time device */ if (do_flush) - flush_buffer_cache(fd); + flush_buffer_cache(); close(fd); } @@ -1885,6 +2035,7 @@ static int fromhex(unsigned char c) bb_error_msg_and_die("bad char: '%c' 0x%02x", c, c); } +static void identify_from_stdin(void) NORETURN; static void identify_from_stdin(void) { uint16_t sbuf[256]; @@ -1892,7 +2043,7 @@ static void identify_from_stdin(void) unsigned char *b = (unsigned char *)buf; int i; - xread(0, buf, 1280); + xread(STDIN_FILENO, buf, 1280); // Convert the newline-separated hex data into an identify block. @@ -1906,24 +2057,36 @@ static void identify_from_stdin(void) identify(sbuf); } +#else +void identify_from_stdin(void); #endif /* busybox specific stuff */ -static void parse_opts(smallint *get, smallint *set, unsigned long *value, int min, int max) +static int parse_opts(unsigned long *value, int min, int max) { - if (get) { - *get = 1; - } if (optarg) { - *set = 1; *value = xatol_range(optarg, min, max); + return IS_SET; } + return IS_GET; +} +static int parse_opts_0_max(unsigned long *value, int max) +{ + return parse_opts(value, 0, max); +} +static int parse_opts_0_1(unsigned long *value) +{ + return parse_opts(value, 0, 1); +} +static int parse_opts_0_INTMAX(unsigned long *value) +{ + return parse_opts(value, 0, INT_MAX); } static void parse_xfermode(int flag, smallint *get, smallint *set, int *value) { if (flag) { - *get = 1; + *get = IS_GET; if (optarg) { *value = translate_xfermode(optarg); *set = (*value > -1); @@ -1933,13 +2096,13 @@ static void parse_xfermode(int flag, smallint *get, smallint *set, int *value) /*------- getopt short options --------*/ static const char hdparm_options[] ALIGN1 = - "gfu::n::p:r::m::c::k::a::B:tTh" - USE_FEATURE_HDPARM_GET_IDENTITY("iI") - USE_FEATURE_HDPARM_HDIO_GETSET_DMA("d::") + "gfu::n::p:r::m::c::k::a::B:tT" + IF_FEATURE_HDPARM_GET_IDENTITY("iI") + IF_FEATURE_HDPARM_HDIO_GETSET_DMA("d::") #ifdef HDIO_DRIVE_CMD "S:D:P:X:K:A:L:W:CyYzZ" #endif - USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF("U:") + IF_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF("U:") #ifdef HDIO_GET_QDMA #ifdef HDIO_SET_QDMA "Q:" @@ -1947,70 +2110,69 @@ static const char hdparm_options[] ALIGN1 = "Q" #endif #endif - USE_FEATURE_HDPARM_HDIO_DRIVE_RESET("w") - USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF("x::b:") - USE_FEATURE_HDPARM_HDIO_SCAN_HWIF("R:"); + IF_FEATURE_HDPARM_HDIO_DRIVE_RESET("w") + IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF("x::b:") + IF_FEATURE_HDPARM_HDIO_SCAN_HWIF("R:"); /*-------------------------------------*/ /* our main() routine: */ -int hdparm_main(int argc, char **argv); +int hdparm_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; int hdparm_main(int argc, char **argv) { int c; int flagcount = 0; + INIT_G(); + while ((c = getopt(argc, argv, hdparm_options)) >= 0) { flagcount++; - if (c == 'h') bb_show_usage(); /* EXIT */ - USE_FEATURE_HDPARM_GET_IDENTITY(get_IDentity |= (c == 'I')); - USE_FEATURE_HDPARM_GET_IDENTITY(get_identity |= (c == 'i')); + IF_FEATURE_HDPARM_GET_IDENTITY(get_IDentity |= (c == 'I')); + IF_FEATURE_HDPARM_GET_IDENTITY(get_identity |= (c == 'i')); get_geom |= (c == 'g'); do_flush |= (c == 'f'); - if (c == 'u') parse_opts(&get_unmask, &set_unmask, &unmask, 0, 1); - USE_FEATURE_HDPARM_HDIO_GETSET_DMA(if (c == 'd') parse_opts(&get_dma, &set_dma, &dma, 0, 9)); - if (c == 'n') parse_opts(&get_nowerr, &set_nowerr, &nowerr, 0, 1); + if (c == 'u') getset_unmask = parse_opts_0_1(&unmask); + IF_FEATURE_HDPARM_HDIO_GETSET_DMA( + if (c == 'd') getset_dma = parse_opts_0_max(&dma, 9); + ) + if (c == 'n') getset_nowerr = parse_opts_0_1(&nowerr); parse_xfermode((c == 'p'), &noisy_piomode, &set_piomode, &piomode); - if (c == 'r') parse_opts(&get_readonly, &set_readonly, &readonly, 0, 1); - if (c == 'm') parse_opts(&get_mult, &set_mult, &mult, 0, INT_MAX /*32*/); - if (c == 'c') parse_opts(&get_io32bit, &set_io32bit, &io32bit, 0, INT_MAX /*8*/); - if (c == 'k') parse_opts(&get_keep, &set_keep, &keep, 0, 1); - if (c == 'a') parse_opts(&get_readahead, &set_readahead, &Xreadahead, 0, INT_MAX); - if (c == 'B') parse_opts(&get_apmmode, &set_apmmode, &apmmode, 1, 255); + if (c == 'r') getset_readonly = parse_opts_0_1(&readonly); + if (c == 'm') getset_mult = parse_opts_0_INTMAX(&mult /*32*/); + if (c == 'c') getset_io32bit = parse_opts_0_INTMAX(&io32bit /*8*/); + if (c == 'k') getset_keep = parse_opts_0_1(&keep); + if (c == 'a') getset_readahead = parse_opts_0_INTMAX(&Xreadahead); + if (c == 'B') getset_apmmode = parse_opts(&apmmode, 1, 255); do_flush |= do_timings |= (c == 't'); do_flush |= do_ctimings |= (c == 'T'); #ifdef HDIO_DRIVE_CMD - if (c == 'S') parse_opts(&get_standby, &set_standby, &standby_requested, 0, INT_MAX); - if (c == 'D') parse_opts(&get_defects, &set_defects, &defects, 0, INT_MAX); - if (c == 'P') parse_opts(&get_prefetch, &set_prefetch, &prefetch, 0, INT_MAX); + if (c == 'S') getset_standby = parse_opts_0_max(&standby_requested, 255); + if (c == 'D') getset_defects = parse_opts_0_INTMAX(&defects); + if (c == 'P') getset_prefetch = parse_opts_0_INTMAX(&prefetch); parse_xfermode((c == 'X'), &get_xfermode, &set_xfermode, &xfermode_requested); - if (c == 'K') parse_opts(&get_dkeep, &set_dkeep, &prefetch, 0, 1); - if (c == 'A') parse_opts(&get_lookahead, &set_lookahead, &lookahead, 0, 1); - if (c == 'L') parse_opts(&get_doorlock, &set_doorlock, &doorlock, 0, 1); - if (c == 'W') parse_opts(&get_wcache, &set_wcache, &wcache, 0, 1); + if (c == 'K') getset_dkeep = parse_opts_0_1(&prefetch); + if (c == 'A') getset_lookahead = parse_opts_0_1(&lookahead); + if (c == 'L') getset_doorlock = parse_opts_0_1(&doorlock); + if (c == 'W') getset_wcache = parse_opts_0_1(&wcache); get_powermode |= (c == 'C'); - get_standbynow = set_standbynow |= (c == 'y'); - get_sleepnow = set_sleepnow |= (c == 'Y'); + set_standbynow |= (c == 'y'); + set_sleepnow |= (c == 'Y'); reread_partn |= (c == 'z'); - get_seagate = set_seagate |= (c == 'Z'); + set_seagate |= (c == 'Z'); #endif - USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(if (c == 'U') parse_opts(NULL, &unregister_hwif, &hwif, 0, INT_MAX)); + IF_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(if (c == 'U') unregister_hwif = parse_opts_0_INTMAX(&hwif)); #ifdef HDIO_GET_QDMA if (c == 'Q') { -#ifdef HDIO_SET_QDMA - parse_opts(&get_dma_q, &set_dma_q, &dma_q, 0, INT_MAX); -#else - parse_opts(&get_dma_q, NULL, NULL, 0, 0); -#endif + getset_dma_q = parse_opts_0_INTMAX(&dma_q); } #endif - USE_FEATURE_HDPARM_HDIO_DRIVE_RESET(perform_reset = (c == 'r')); - USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'x') parse_opts(NULL, &perform_tristate, &tristate, 0, 1)); - USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'b') parse_opts(&get_busstate, &set_busstate, &busstate, 0, 2)); + IF_FEATURE_HDPARM_HDIO_DRIVE_RESET(perform_reset = (c == 'r')); + IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'x') perform_tristate = parse_opts_0_1(&tristate)); + IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'b') getset_busstate = parse_opts_0_max(&busstate, 2)); #if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF if (c == 'R') { - parse_opts(NULL, &scan_hwif, &hwif_data, 0, INT_MAX); - hwif_ctrl = xatoi_u((argv[optind]) ? argv[optind] : ""); - hwif_irq = xatoi_u((argv[optind+1]) ? argv[optind+1] : ""); + scan_hwif = parse_opts_0_INTMAX(&hwif_data); + hwif_ctrl = xatoi_positive((argv[optind]) ? argv[optind] : ""); + hwif_irq = xatoi_positive((argv[optind+1]) ? argv[optind+1] : ""); /* Move past the 2 additional arguments */ argv += 2; argc -= 2; @@ -2019,15 +2181,15 @@ int hdparm_main(int argc, char **argv) } /* When no flags are given (flagcount = 0), -acdgkmnru is assumed. */ if (!flagcount) { - get_mult = get_io32bit = get_unmask = get_keep = get_readonly = get_readahead = get_geom = 1; - USE_FEATURE_HDPARM_HDIO_GETSET_DMA(get_dma = 1); + getset_mult = getset_io32bit = getset_unmask = getset_keep = getset_readonly = getset_readahead = get_geom = IS_GET; + IF_FEATURE_HDPARM_HDIO_GETSET_DMA(getset_dma = IS_GET); } argv += optind; if (!*argv) { if (ENABLE_FEATURE_HDPARM_GET_IDENTITY && !isatty(STDIN_FILENO)) identify_from_stdin(); /* EXIT */ - else bb_show_usage(); + bb_show_usage(); } do {