HDD Health

Renovatio · Beitrag von **Renovatio** » 29.07.2011 14:29

Moin,

kennt jemand das Tool "HDD Health"?
Wenn nicht, hier gibt's n' schnellen Durchblick auf YouTube dazu.

http://www.youtube.com/watch?v=doJABgaEfdU

Meine passende Frage dazu, wie könnte man soetwas mit PB realisieren?

Danke an alle Beteiligungen !

STARGÅTE · Beitrag von **STARGÅTE** » 29.07.2011 14:39

Mit hilfe von API die LOGs der HDD auslesen: Sowas wie: Lesevorgänge, Lesefehler, Scheibfehler ...

Anhand dieser Daten kann man dann eine Art "Gesundheitszustand" errechnen.
Allerdings kann man daraus nicht wirklich Rückschlüsse auf den Hardwarezustand machen.

Eine "gesunde" HDD kann genauso plötzlich kaput gehen, wie eine die schon vermehrt zugriffsfehler hat.

Thorium · Beitrag von **Thorium** » 29.07.2011 15:26

Nennt sich SMART: http://en.wikipedia.org/wiki/S.M.A.R.T.
Hab mich aber nie damit beschäftigt. Kommt man bestimmt per WMI drann.

Dark · Beitrag von **Dark** » 02.08.2011 02:46

Hallo,

ich hatte mich bis jetzt auch noch nicht mit dem auslesen von S.M.A.R.T Werten beschäftigt und es einfach mal versucht. Dabei kam dann der gleich folgende Code raus, aber erst ein mal ein paar Anmerkungen:
Der Code sollte mit normalen (S)ATA Festplatten funktionieren, so lange sie für Windows als einzelne Laufwerke erkennbar sind. Hardware RAIDs würden folglich nicht funktionieren. Wie sollte der RAID Controller auch wissen von welcher Festplatte ich den Wert auslesen will ?
Festplatten die über USB angeschlossen sind, können auch nicht ausgelesen werden. Der Grund steht im Source Code oder kann alternativ auch im deutschen Wikipedia Artikel über S.M.A.R.T nachgelesen werden. Es wäre zwar nicht ganz unmöglich auch die Unterstützung für USB Festplatten einzubauen, jedoch ist dies recht schwierig, da es hierfür keinen offenen Standard gibt. Die Ansteuerung wäre recht komplex, lang und wird auch nur von sehr wenigen USB-IDE/SATA Adaptern unterstützt.
SCSI Festplatten werden ebenfalls nicht unterstützt.
Festplatten die über FireWire angeschlossen sind, sollten aber funktionieren.

Der Code brauch Admin Rechte, da ich direkt Befehle an den Festplattencontroller sende und funktioniert erst ab Windows XP.
Die Ausgabe der Daten erfolgt über ein Konsolen Fenster.

Code: Alles auswählen

EnableExplicit

Structure SP_DEVICE_INTERFACE_DETAIL_DATA
  cbSize.l
  DevicePath.c[1]
EndStructure

Structure GETVERSIONINPARAMS
  bVersion.a
  bRevision.a
  bReserved.a
  bIDEDeviceMap.a
  fCapabilities.l
  dwReserved.l[4]
EndStructure

Structure STORAGE_PROPERTY_QUERY 
  PropertyId.i
  QueryType.i
  AdditionalParameters.l[1]
EndStructure

Structure STORAGE_DEVICE_DESCRIPTOR
  Version.l
  Size.l
  DeviceType.a
  DeviceTypeModifier.a
  RemovableMedia.a
  CommandQueueing.a
  VendorIdOffset.l
  ProductIdOffset.l
  ProductRevisionOffset.l
  SerialNumberOffset.l
  BusType.i
  RawPropertiesLength.l
  RawDeviceProperties.a[0]
EndStructure

Structure STORAGE_DESCRIPTOR_HEADER
  Version.l
  Size.l
EndStructure

Enumeration
  #BusTypeUnknown             = $00
  #BusTypeScsi                = $01
  #BusTypeAtapi               = $02
  #BusTypeAta                 = $03
  #BusType1394                = $04
  #BusTypeSsa                 = $05
  #BusTypeFibre               = $06
  #BusTypeUsb                 = $07
  #BusTypeRAID                = $08
  #BusTypeiScsi               = $09
  #BusTypeSas                 = $0A
  #BusTypeSata                = $0B
  #BusTypeSd                  = $0C
  #BusTypeMmc                 = $0D
  #BusTypeVirtual             = $0E
  #BusTypeFileBackedVirtual   = $0F
  #BusTypeMax                 = $10
  #BusTypeMaxReserved         = $7F 
EndEnumeration

Structure IDEREGS
  bFeaturesReg.a
  bSectorCountReg.a
  bSectorNumberReg.a
  bCylLowReg.a
  bCylHighReg.a
  bDriveHeadReg.a
  bCommandReg.a
  bReserved.a  
EndStructure

Structure SENDCMDINPARAMS
  cBufferSize.l
  irDriveRegs.IDEREGS
  bDriveNumber.a  ;ignored by the system, the device is specified by its handle
  bReserved.a[3]
  dwReserved.l[4]
  bBuffer.a[0]
EndStructure

Structure DRIVERSTATUS
  bDriverError.a
  bIDEError.a
  bReserved.a[2]
  dwReserved.l[2]
EndStructure

Structure SENDCMDOUTPARAMS
  cBufferSize.l
  DriverStatus.DRIVERSTATUS
  bBuffer.a[512]
EndStructure

Structure ATTRTHRESHOLD
  bAttrID.a
  bWarrantyThreshold.a
  bReserved.a[10]
EndStructure

Structure DRIVEATTRIBUTE
  bAttrID.a
  wStatusFlags.w
  bAttrValue.a
  bWorstValue.a
  bRawValue.a[6]
  bReserved.a
EndStructure

Macro CTL_CODE(DeviceType, Function, Method, Access) 
  ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method)
EndMacro

#FILE_ANY_ACCESS          = 0
#FILE_DEVICE_MASS_STORAGE = 45

#IOCTL_STORAGE_BASE = #FILE_DEVICE_MASS_STORAGE

#FILE_DEVICE_DISK = $7
#IOCTL_DISK_BASE  = #FILE_DEVICE_DISK

#FILE_READ_ACCESS  = $1
#FILE_WRITE_ACCESS = $2

#METHOD_BUFFERED   = $0

#SMART_GET_VERSION        = CTL_CODE(#IOCTL_DISK_BASE, $0020, #METHOD_BUFFERED, #FILE_READ_ACCESS)
#SMART_SEND_DRIVE_COMMAND = CTL_CODE(#IOCTL_DISK_BASE, $0021, #METHOD_BUFFERED, #FILE_READ_ACCESS | #FILE_WRITE_ACCESS)
#SMART_RCV_DRIVE_DATA     = CTL_CODE(#IOCTL_DISK_BASE, $0022, #METHOD_BUFFERED, #FILE_READ_ACCESS | #FILE_WRITE_ACCESS)

#IOCTL_STORAGE_QUERY_PROPERTY = CTL_CODE(#IOCTL_STORAGE_BASE, $0500, #METHOD_BUFFERED, #FILE_ANY_ACCESS)

#CAP_SMART_CMD = 4

#READ_ATTRIBUTES  = $d0 
#READ_THRESHOLDS  = $d1 

#SMART_CYL_LOW  = $4F
#SMART_CYL_HI   = $C2

#IDE_EXECUTE_SMART_FUNCTION = $B0

Macro DEFINE_GUID(Name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8)
  Global Name.GUID
  
  Name\Data1    = l
  Name\Data2    = w1
  Name\Data3    = w2
  Name\Data4[0] = b1
  Name\Data4[1] = b2
  Name\Data4[2] = b3
  Name\Data4[3] = b4
  Name\Data4[4] = b5
  Name\Data4[5] = b6
  Name\Data4[6] = b7
  Name\Data4[7] = b8
EndMacro

DEFINE_GUID(DiskDrive, $4d36e967, $e325, $11ce, $bf, $c1, $08, $00, $2b, $e1, $03, $18)

DEFINE_GUID(GUID_DEVINTERFACE_DISK, $53F56307, $B6BF, $11D0, $94, $F2, $00, $A0, $C9, $1E, $FB, $8B)

;--- own Structures:

Structure THRESH_RESULT
  Version.w
  index.ATTRTHRESHOLD[0]
EndStructure

Structure ATTRIBUTE_RESULT
  Version.w
  index.DRIVEATTRIBUTE[0]
EndStructure

Structure SmartValue
  Threshold.a
  Value.a
  Worst.a
  Raw.q
  used.a
EndStructure

Structure DescStrings
  Pointer.i[256]
EndStructure

Procedure DebugSmart(Path.s)

  Dim SmartsValues.SmartValue(255)
  
  Protected DeviceHandle =  CreateFile_(Path, #GENERIC_READ | #GENERIC_WRITE, #FILE_SHARE_READ | #FILE_SHARE_WRITE, 0, #OPEN_EXISTING, 0, 0)
  
  If DeviceHandle <> #INVALID_HANDLE_VALUE

    Protected PQuery.STORAGE_PROPERTY_QUERY
    PQuery\PropertyId = 0
    PQuery\QueryType  = 0
    
    Protected PSize.STORAGE_DESCRIPTOR_HEADER
    Protected ReturnSize.i
    
    If DeviceIoControl_(DeviceHandle, #IOCTL_STORAGE_QUERY_PROPERTY, @PQuery, SizeOf(STORAGE_PROPERTY_QUERY), @PSize, SizeOf(STORAGE_DESCRIPTOR_HEADER), @ReturnSize, 0)
    
      If PSize\Size >= SizeOf(STORAGE_DEVICE_DESCRIPTOR)
                 
        Protected *Property.STORAGE_DEVICE_DESCRIPTOR
        
        *Property = AllocateMemory(PSize\Size)
        
        If *Property
              
          If DeviceIoControl_(DeviceHandle, #IOCTL_STORAGE_QUERY_PROPERTY, @PQuery, SizeOf(STORAGE_PROPERTY_QUERY), *Property, PSize\Size, @ReturnSize, 0)
            
            Protected DeviceName.s
            
            If *Property\VendorIdOffset
              DeviceName + PeekS(*Property + *Property\VendorIdOffset, -1, #PB_Ascii)
            EndIf
            
            If *Property\ProductIdOffset
              DeviceName + PeekS(*Property + *Property\ProductIdOffset, -1, #PB_Ascii)
            EndIf     
                        
            If DeviceName = ""
              DeviceName = Path
            EndIf
            
            
            PrintN("-----------")
            PrintN(DeviceName)
            PrintN("")
            
            If *Property\BusType <> #BusTypeUsb And *Property\BusType <> #BusTypeScsi And *Property\BusType <> #BusTypeRAID      
      
              Protected Version.GETVERSIONINPARAMS
                  
              If DeviceIoControl_(DeviceHandle, #SMART_GET_VERSION, 0, 0, @Version, SizeOf(GETVERSIONINPARAMS), @ReturnSize, 0)    
                
                If Version\fCapabilities & #CAP_SMART_CMD
                  PrintN(" The drive supports S.M.A.R.T")
                  
                  
                  
                  Protected InTresh.SENDCMDINPARAMS
                  
                  With InTresh
                    \cBufferSize  = 0
                    \bDriveNumber = 0
                    \irDriveRegs\bFeaturesReg     = #READ_THRESHOLDS
                    \irDriveRegs\bSectorCountReg  = 1
                    \irDriveRegs\bSectorNumberReg = 1
                    \irDriveRegs\bCylLowReg       = #SMART_CYL_LOW
                    \irDriveRegs\bCylHighReg      = #SMART_CYL_HI
                    \irDriveRegs\bDriveHeadReg    = $A0
                    \irDriveRegs\bCommandReg      = #IDE_EXECUTE_SMART_FUNCTION
                  EndWith
                  
                  Protected OutTresh.SENDCMDOUTPARAMS
                             
                  If DeviceIoControl_(DeviceHandle, #SMART_RCV_DRIVE_DATA, @InTresh, SizeOf(SENDCMDINPARAMS), @OutTresh, SizeOf(SENDCMDOUTPARAMS), @ReturnSize, 0)
                                
                    Protected *TResult.THRESH_RESULT = @OutTresh\bBuffer
                    Protected i.i
                    
                    While *TResult\index[i]\bAttrID <> 0 And i < ((OutTresh\cBufferSize - 2)/ SizeOf(ATTRTHRESHOLD))
                      SmartsValues(*TResult\index[i]\bAttrID)\Threshold = *TResult\index[i]\bWarrantyThreshold  
                      i+1  
                    Wend
                    
                  EndIf
                  
                              
                  With InTresh
                    \cBufferSize  = 0
                    \bDriveNumber = 0
                    \irDriveRegs\bFeaturesReg     = #READ_ATTRIBUTES
                    \irDriveRegs\bSectorCountReg  = 1
                    \irDriveRegs\bSectorNumberReg = 1
                    \irDriveRegs\bCylLowReg       = #SMART_CYL_LOW
                    \irDriveRegs\bCylHighReg      = #SMART_CYL_HI
                    \irDriveRegs\bDriveHeadReg    = $A0
                    \irDriveRegs\bCommandReg      = #IDE_EXECUTE_SMART_FUNCTION
                  EndWith
                                         
                  If DeviceIoControl_(DeviceHandle, #SMART_RCV_DRIVE_DATA, @InTresh, SizeOf(SENDCMDINPARAMS), @OutTresh, SizeOf(SENDCMDOUTPARAMS), @ReturnSize, 0)
      
                    
                    Protected *AResult.ATTRIBUTE_RESULT = @OutTresh\bBuffer
                    i = 0
                    
                    While *AResult\index[i]\bAttrID <> 0 And i < ((OutTresh\cBufferSize - 2)/ SizeOf(DRIVEATTRIBUTE))
                      SmartsValues(*TResult\index[i]\bAttrID)\used  = #True
                      SmartsValues(*TResult\index[i]\bAttrID)\Value = *AResult\index[i]\bAttrValue
                      SmartsValues(*TResult\index[i]\bAttrID)\Worst = *AResult\index[i]\bWorstValue
                      CopyMemory(@*AResult\index[i]\bRawValue, @SmartsValues(*TResult\index[i]\bAttrID)\Raw, 6)
                      i+1  
                    Wend
                    
                    PrintN("")
                    PrintN("           Description              Value  Worst  Threshold  Raw:   ")
                    PrintN(" ------------------------------------------------------------------------")
                    
                    Protected *Desc.DescStrings = ?Desc
                    
                    For i = 1 To 255
                      If SmartsValues(i)\used
                      
                        If *Desc\Pointer[i]
                          Print(" "+ PeekS(*Desc\Pointer[i]))
                        Else
                          Print(" Unknown                          ")
                        EndIf
                                          
                        Print("  " + LSet(Str(SmartsValues(i)\Value),5))
                                          
                        Print("  " + LSet(Str(SmartsValues(i)\Worst),5))
                        
                        Print("  " + LSet(Str(SmartsValues(i)\Threshold),9)) 
                                         
                        Print("  " + Str(SmartsValues(i)\Raw))
                        
                        PrintN("")
                        
                      EndIf
                    Next
                  EndIf
                                          
                Else
                
                  PrintN(" The drive does not support S.M.A.R.T")
                  
                EndIf
                          
              Else   
                PrintN(" Error: Could not test if the device supports S.M.A.R.T, aborting ...")      
              EndIf
              
            Else
              
              If *Property\BusType = #BusTypeUsb 
                PrintN(" This Device is connected via USB!")
                PrintN("")
                PrintN(" USB uses SCSI commands to talk to the device.")
                PrintN(" Your device is most probably a (S)ATA device and the USB-IDE/SATA adapter")
                PrintN(" translates between SCSI and ATA. The SCSI and ATA S.M.A.R.T standards are")
                PrintN(" not compatible. The device would not understand a SCSI S.M.A.R.T command ")
                PrintN(" and you can not send an ATA S.M.A.R.T command through a SCSI interface.  ") 
                PrintN(" Some USB-IDE/SATA adapters implement a proprietary command to tunnel ATA ")
                PrintN(" requests, but the default Windows driver does not support these commands.")
                PrintN(" Sorry.")
              Else
                PrintN(" RAID/SCSI Devices are not supported.")
                PrintN(" Sorry.")
              EndIf
              
            EndIf
            
            PrintN("")
            
          EndIf 
          
          FreeMemory(*Property)
          
        EndIf
        
      EndIf
    
    EndIf
    CloseHandle_(DeviceHandle)
  EndIf
  
EndProcedure

OpenConsole()

Define Handle.i = SetupDiGetClassDevs_(@GUID_DEVINTERFACE_DISK, 0, 0, #DIGCF_PRESENT | #DIGCF_DEVICEINTERFACE) 

If Handle <> #INVALID_HANDLE_VALUE
  
  Define Index.i = 0
  Define DevInterface.SP_DEVICE_INTERFACE_DATA
  
  DevInterface\cbSize = SizeOf(SP_DEVICE_INTERFACE_DATA)
  
  
  While SetupDiEnumDeviceInterfaces_(Handle, 0, @GUID_DEVINTERFACE_DISK, Index, @DevInterface)              
    
    Define Length.l = 0
        
    SetupDiGetDeviceInterfaceDetail_(Handle, @DevInterface, 0, 0, @Length, 0)
    
    If Length > 0
      
      Define *DetailData.SP_DEVICE_INTERFACE_DETAIL_DATA
      
      *DetailData = AllocateMemory(Length)
      
      If *DetailData
        
        *DetailData\cbSize = SizeOf(SP_DEVICE_INTERFACE_DETAIL_DATA)
        
        If SetupDiGetDeviceInterfaceDetail_(Handle, @DevInterface, *DetailData, Length, 0, 0)
        
          Define DevicePath.s = PeekS(@*DetailData\DevicePath)
        
          DebugSmart(DevicePath)
        
        EndIf
        
        FreeMemory(*DetailData)
      
      EndIf
      
    EndIf
    
    Index+1
  Wend
  
  PrintN("Press Enter to quit.")
  Input()
  
  SetupDiDestroyDeviceInfoList_(Handle)
  
EndIf 


DataSection
  ;Source: http://www.t13.org/documents/UploadedDocuments/docs2005/e05148r0-ACS-SMARTAttributesAnnex.pdf              
  
  D_001: Data.s "Raw Read error rate              "
  D_002: Data.s "Throughput performance           "
  D_003: Data.s "Spinup time                      "
  D_004: Data.s "Start/Stop count                 "
  D_005: Data.s "Reallocated sector count         "
  D_006: Data.s "Read channel margin              "
  D_007: Data.s "Seek error rate                  "
  D_008: Data.s "Seek timer performance           "
  D_009: Data.s "Power-on hours count             "
  D_010: Data.s "Spinup retry count               "
  D_011: Data.s "Calibration retry count          "
  D_012: Data.s "Power cycle count                "
  D_013: Data.s "Soft read error rate             "
  
  D_191: Data.s "G-sense error rate               "
  D_192: Data.s "Power-off retract count          "
  D_193: Data.s "Load/Unload cycle count          "
  D_194: Data.s "HDA temperature                  "
  D_195: Data.s "Hardware ECC recovered           "
  D_196: Data.s "Reallocation count               "
  D_197: Data.s "Current pending sector count     "
  D_198: Data.s "Offline scan uncorrectable count "
  D_199: Data.s "UDMA CRC error rate              "
  D_200: Data.s "Write error rate                 "
  D_201: Data.s "Soft read error rate             "
  D_202: Data.s "Data Address Mark errors         "
  D_203: Data.s "Run out cancel                   "
  D_204: Data.s "Soft ECC correction              "
  D_205: Data.s "Thermal asperity rate (TAR)      "
  D_206: Data.s "Flying height                    "
  D_207: Data.s "Spin high current                "
  D_208: Data.s "Spin buzz                        "
  D_209: Data.s "Offline seek performance         "
  
  D_220: Data.s "Disk shift                       "
  D_221: Data.s "G-sense error rate               "
  D_222: Data.s "Loaded hours                     "
  D_223: Data.s "Load/unload retry count          "
  D_224: Data.s "Load friction                    "
  D_225: Data.s "Load/Unload cycle count          "
  D_226: Data.s "Load-in time                     "
  D_227: Data.s "Torque amplification count       "
  D_228: Data.s "Power-off retract count          "
  
  D_230: Data.s "GMR head amplitude               "
  D_231: Data.s "Temperature                      "
  
  D_240: Data.s "Head flying hours                "
  D_250: Data.s "Read error retry rate            "
  
  
  Desc:   
  ; ----------- Pointer to Desc Strings -----------
    Data.i 0,      ?D_001, ?D_002, ?D_003, ?D_004, ?D_005, ?D_006, ?D_007, ?D_008, ?D_009, ?D_010, ?D_011, ?D_012, ?D_013, 0,      0
    Data.i 0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0
    Data.i 0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0
    Data.i 0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0
    Data.i 0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0
    Data.i 0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0
    Data.i 0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0
    Data.i 0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0
    Data.i 0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0
    Data.i 0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0
    Data.i 0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0
    Data.i 0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      ?D_191
    Data.i ?D_192, ?D_193, ?D_194, ?D_195, ?D_196, ?D_197, ?D_198, ?D_199, ?D_200, ?D_201, ?D_202, ?D_203, ?D_204, ?D_205, ?D_206, ?D_207
    Data.i ?D_208, ?D_209, 0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      ?D_220, ?D_221, ?D_222, ?D_223
    Data.i ?D_224, ?D_225, ?D_226, ?D_227, ?D_228, 0,      ?D_230, ?D_231, 0,      0,      0,      0,      0,      0,      0,      0
    Data.i ?D_240,  0,     0,      0,      0,      0,      0,      0,      0,      0,      ?D_250, 0,      0,      0,      0,      0
  ; ----------------------------------------------- 
    
EndDataSection

Man könnte noch einbauen, das S.M.A.R.T aktiviert wird, wenn es abgeschaltet ist oder auch das Auslesen der Log.

mfg,
Dark

c4s · Beitrag von **c4s** » 02.08.2011 10:27

Bei mir sind alle Werte über dem Schwellenwert. Ich glaube die sinkende Performance meines System (siehe http://www.purebasic.fr/german/viewtopi ... =2&t=24571) hängt damit zusammen.
Naja bis zum bitteren Ende werde ich meinen Rechner noch verwenden... natürlich mit mehreren Backups täglich.

Dark · Beitrag von **Dark** » 02.08.2011 12:57

c4s hat geschrieben:Bei mir sind alle Werte über dem Schwellenwert. Ich glaube die sinkende Performance meines System (siehe http://www.purebasic.fr/german/viewtopi ... =2&t=24571) hängt damit zusammen.
Naja bis zum bitteren Ende werde ich meinen Rechner noch verwenden... natürlich mit mehreren Backups täglich.

Das ist super, das deine Werte über den Schwellenwerten liegen, denn:

http://de.wikipedia.org/wiki/Self-Monitoring,_Analysis_and_Reporting_Technology#.C3.9Cbliche_Parameter hat geschrieben:Jeder Wert wird zuerst als Raw-Data gespeichert. Dieser wird dann zum besseren Verständnis auf einer Werteskala von 0 bis 100, 200 oder 255 einsortiert. Die unterschiedlichen Skalen dienen dabei einer feineren Abstufung, wo der Hersteller sie für sinnvoll erachtet. Mit dem Skalenmaximum startend, nähert sich der Wert (Value) bei Fehlern oder zunehmendem Alter Null. Häufig ist die kritische Grenze (Threshold) aber schon weit darüber angesiedelt.

Der Wert sollte also möglichst weit über dem Threshold Wert liegen.

MfG,
Dark

c4s · Beitrag von **c4s** » 02.08.2011 13:31

Dennoch kann ich feststellen, dass meine Festplatte ...:
1) seit neustem manchmal ein einzelnes "klacken" von sich gibt.
2) langsamer ist?! Jedenfalls dauert z.B. das Kopieren auf eine externe Festplatte gefühlte fünfmal länger.
3) von einem anderen Diagnose-Tool als gefährdet eingestuft wurde.
4) 6,5 Jahre nahezu im Dauerbetrieb ist.

Scheinbar ist die S.M.A.R.T.-Information also nicht allzu verlässlich.

Dark · Beitrag von **Dark** » 02.08.2011 13:48

c4s hat geschrieben:3) von einem anderen Diagnose-Tool als gefährdet eingestuft wurde.
4) 6,5 Jahre nahezu im Dauerbetrieb ist.

Wahrscheinlich hat das andere Programm die S.M.A.R.T Werte ausgelesen, dabei die lange Laufzeit bemerkt und sie deshalb als Gefährdet eingestuft

.

Danilo · Beitrag von **Danilo** » 03.08.2011 06:39

c4s hat geschrieben:Dennoch kann ich feststellen, dass meine Festplatte ...:
1) seit neustem manchmal ein einzelnes "klacken" von sich gibt.
2) langsamer ist?! Jedenfalls dauert z.B. das Kopieren auf eine externe Festplatte gefühlte fünfmal länger.

Das hatte ich auch schon einige male, und das war immer kurz
vorm Tod der Platten.
Das klacken wird sicherlich immer schlimmer, so als wenn etwas
nicht mehr in Gang kommt. Lese-/Schreibkopf oder Motor oder so.
Dann klackt es immer wieder beim "anfahren/hochfahren", und nach
mehreren Anläufen gehts dann am Anfang wieder. Irgendwann geht
es dann nicht mehr und das war es dann.

Da Platten heutzutage eh spottbillig sind, solltest Du Dir vielleicht
langsam mal eine Neue zulegen. 1500-2000MB für 50 bis 75,-Euro.

c4s · Beitrag von **c4s** » 03.08.2011 09:43

Danilo hat geschrieben:Da Platten heutzutage eh spottbillig sind, solltest Du Dir vielleicht
langsam mal eine Neue zulegen. 1500-2000MB für 50 bis 75,-Euro.

Ich glaube solche Preise gab es vor gut 15 Jahren.

Inspiriert durch deinen Kommentar werde ich mir wohl demnächst wirklich eine neue Festplatte zulegen. Weißt du auf welche "Qualitätsmerkmale" man heutzutage bei Festplatten achten muss?

PureBoard

HDD Health

HDD Health

Re: HDD Health

Re: HDD Health

Re: HDD Health

Re: HDD Health

Re: HDD Health

Re: HDD Health

Re: HDD Health

Re: HDD Health

Re: HDD Health