chiark - git - ian - stressapptest/blob - src/error_diag.cc

   1 // Copyright 2008 Google Inc. All Rights Reserved.
   2
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6
   7 //      http://www.apache.org/licenses/LICENSE-2.0
   8
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 // error_diag.cc: Collects device errors for analysis to more accurately
  16 //                pin-point failed component.
  17
  18 #include <set>
  19 #include <list>
  20 #include <map>
  21
  22 // This file must work with autoconf on its public version,
  23 // so these includes are correct.
  24 #include "error_diag.h"
  25 #include "sattypes.h"
  26
  27
  28 // DeviceTree constructor.
  29 DeviceTree::DeviceTree(string name)
  30   : parent_(0), name_(name) {
  31   pthread_mutex_init(&device_tree_mutex_, NULL);
  32 }
  33
  34 // DeviceTree destructor.
  35 DeviceTree::~DeviceTree() {
  36   // Deallocate subtree devices.
  37   for (std::map<string, DeviceTree*>::iterator itr = subdevices_.begin();
  38       itr != subdevices_.end();
  39       ++itr) {
  40     delete itr->second;
  41   }
  42   // Deallocate device errors.
  43   for (std::list<ErrorInstance*>::iterator itr = errors_.begin();
  44       itr != errors_.end();
  45       ++itr) {
  46     delete (*itr);
  47   }
  48   pthread_mutex_destroy(&device_tree_mutex_);
  49 }
  50
  51 // Atomically find named device in sub device tree.
  52 // Returns 0 if not found
  53 DeviceTree *DeviceTree::FindInSubTree(string name) {
  54   DeviceTree *ret;
  55   pthread_mutex_lock(&device_tree_mutex_);
  56   ret = UnlockedFindInSubTree(name);
  57   pthread_mutex_unlock(&device_tree_mutex_);
  58   return ret;
  59 }
  60
  61 // Find named device in sub device tree (Non-atomic).
  62 // Returns 0 if not found
  63 DeviceTree *DeviceTree::UnlockedFindInSubTree(string name) {
  64   std::map<string, DeviceTree*>::iterator itr = subdevices_.find(name);
  65   if (itr != subdevices_.end()) {
  66     return itr->second;
  67   } else {
  68     // Search sub-tree.
  69     for (std::map<string, DeviceTree*>::iterator itr = subdevices_.begin();
  70         itr != subdevices_.end();
  71         ++itr) {
  72       DeviceTree *result = itr->second->UnlockedFindInSubTree(name);
  73       if (result != 0)
  74         return result;
  75     }
  76     return 0;
  77   }
  78 }
  79
  80 // Atomically add error instance to device.
  81 void DeviceTree::AddErrorInstance(ErrorInstance *error_instance) {
  82   pthread_mutex_lock(&device_tree_mutex_);
  83   errors_.push_back(error_instance);
  84   pthread_mutex_unlock(&device_tree_mutex_);
  85 }
  86
  87 // Find or add queried device as necessary.
  88 DeviceTree *DeviceTree::FindOrAddDevice(string name) {
  89   // Assume named device does not exist and try to insert the device anyway.
  90   // No-op if named device already exists.
  91   InsertSubDevice(name);
  92   // Find and return sub device pointer.
  93   return FindInSubTree(name);
  94 }
  95
  96 // Pretty prints device tree.
  97 void DeviceTree::PrettyPrint(string spacer) {
  98   for (std::map<string, DeviceTree*>::iterator itr = subdevices_.begin();
  99       itr != subdevices_.end();
 100       ++itr) {
 101     printf("%s%s\n", spacer.c_str(), itr->first.c_str());
 102     itr->second->PrettyPrint(spacer+spacer);
 103   }
 104 }
 105
 106 // Atomically add sub device.
 107 // No-op if named device already exists.
 108 void DeviceTree::InsertSubDevice(string name) {
 109   pthread_mutex_lock(&device_tree_mutex_);
 110   if (UnlockedFindInSubTree(name) != 0) {
 111     pthread_mutex_unlock(&device_tree_mutex_);
 112     return;
 113   }
 114   subdevices_[name] = new DeviceTree(name);
 115   subdevices_[name]->parent_ = this;
 116   pthread_mutex_unlock(&device_tree_mutex_);
 117 }
 118
 119
 120 // Returns true of any error associated with this device is fatal.
 121 bool DeviceTree::KnownBad() {
 122   pthread_mutex_lock(&device_tree_mutex_);
 123   for (std::list<ErrorInstance*>::iterator itr = errors_.begin();
 124       itr != errors_.end();
 125       ++itr) {
 126     if ((*itr)->severity_ == SAT_ERROR_FATAL) {
 127       pthread_mutex_unlock(&device_tree_mutex_);
 128       return true;
 129     }
 130   }
 131   pthread_mutex_unlock(&device_tree_mutex_);
 132   return false;
 133 }
 134
 135
 136 // ErrorDiag constructor.
 137 ErrorDiag::ErrorDiag() {
 138   os_ = 0;
 139   system_tree_root_ = 0;
 140 }
 141
 142 // ErrorDiag destructor.
 143 ErrorDiag::~ErrorDiag() {
 144   if (system_tree_root_)
 145     delete system_tree_root_;
 146 }
 147
 148 // Set platform specific handle and initialize device tree.
 149 // Returns false on error. true otherwise.
 150 bool ErrorDiag::set_os(OsLayer *os) {
 151   os_ = os;
 152   return(InitializeDeviceTree());
 153 }
 154
 155 // Create and initialize system device tree.
 156 // Returns false on error. true otherwise.
 157 bool ErrorDiag::InitializeDeviceTree() {
 158   system_tree_root_ = new DeviceTree("system_root");
 159   if (!system_tree_root_)
 160     return false;
 161   return true;
 162 }
 163
 164 // Logs info about a CECC.
 165 // Returns -1 on error, 1 if diagnoser reports error externally; 0 otherwise.
 166 int ErrorDiag::AddCeccError(string dimm_string) {
 167   DeviceTree *dimm_device = system_tree_root_->FindOrAddDevice(dimm_string);
 168   ECCErrorInstance *error = new ECCErrorInstance;
 169   if (!error)
 170     return -1;
 171   error->severity_ = SAT_ERROR_CORRECTABLE;
 172   dimm_device->AddErrorInstance(error);
 173   return 0;
 174 }
 175
 176 // Logs info about a UECC.
 177 // Returns -1 on error, 1 if diagnoser reports error externally; 0 otherwise.
 178 int ErrorDiag::AddUeccError(string dimm_string) {
 179   DeviceTree *dimm_device = system_tree_root_->FindOrAddDevice(dimm_string);
 180   ECCErrorInstance *error = new ECCErrorInstance;
 181   if (!error)
 182     return -1;
 183   error->severity_ = SAT_ERROR_FATAL;
 184   dimm_device->AddErrorInstance(error);
 185   return 0;
 186 }
 187
 188 // Logs info about a miscompare.
 189 // Returns -1 on error, 1 if diagnoser reports error externally; 0 otherwise.
 190 int ErrorDiag::AddMiscompareError(string dimm_string, uint64 addr, int count) {
 191   DeviceTree *dimm_device = system_tree_root_->FindOrAddDevice(dimm_string);
 192   MiscompareErrorInstance *error = new MiscompareErrorInstance;
 193   if (!error)
 194     return -1;
 195   error->severity_ = SAT_ERROR_FATAL;
 196   error->addr_ = addr;
 197   dimm_device->AddErrorInstance(error);
 198   os_->ErrorReport(dimm_string.c_str(), "miscompare", count);
 199   return 1;
 200 }
 201
 202 // Utility Function to translate a virtual address to DIMM number.
 203 // Returns -1 on error, 1 if diagnoser reports error externally; 0 otherwise.
 204 string ErrorDiag::AddressToDimmString(OsLayer *os, void *addr, int offset) {
 205   char dimm_string[256] = "";
 206   char *vbyteaddr = reinterpret_cast<char*>(addr) + offset;
 207   uint64 paddr = os->VirtualToPhysical(vbyteaddr);
 208   os->FindDimm(paddr, dimm_string, sizeof(dimm_string));
 209   return string(dimm_string);
 210 }
 211
 212 // Info about a miscompare from a drive.
 213 // Returns -1 on error, 1 if diagnoser reports error externally; 0 otherwise.
 214 int ErrorDiag::AddHDDMiscompareError(string devicename, int block, int offset,
 215                                      void *src_addr, void *dst_addr) {
 216   bool mask_hdd_error = false;
 217
 218   HDDMiscompareErrorInstance *error = new HDDMiscompareErrorInstance;
 219   if (!error)
 220     return -1;
 221
 222   error->addr_ = reinterpret_cast<uint64>(src_addr);
 223   error->addr2_ = reinterpret_cast<uint64>(dst_addr);
 224   error->offset_ = offset;
 225   error->block_ = block;
 226
 227   string src_dimm = AddressToDimmString(os_, src_addr, offset);
 228   string dst_dimm = AddressToDimmString(os_, dst_addr, offset);
 229
 230   // DIMM name look up success
 231   if (src_dimm.compare("DIMM Unknown")) {
 232     // Add src DIMM as possible miscompare cause.
 233     DeviceTree *src_dimm_dev = system_tree_root_->FindOrAddDevice(src_dimm);
 234     error->causes_.insert(src_dimm_dev);
 235     if (src_dimm_dev->KnownBad()) {
 236       mask_hdd_error = true;
 237       logprintf(5, "Log: supressed %s miscompare report: "
 238                 "known bad source: %s\n", devicename.c_str(), src_dimm.c_str());
 239     }
 240   }
 241   if (dst_dimm.compare("DIMM Unknown")) {
 242     // Add dst DIMM as possible miscompare cause.
 243     DeviceTree *dst_dimm_dev = system_tree_root_->FindOrAddDevice(dst_dimm);
 244     error->causes_.insert(dst_dimm_dev);
 245     if (dst_dimm_dev->KnownBad()) {
 246       mask_hdd_error = true;
 247       logprintf(5, "Log: supressed %s miscompare report: "
 248                 "known bad destination: %s\n", devicename.c_str(),
 249                 dst_dimm.c_str());
 250     }
 251   }
 252
 253   DeviceTree *hdd_dev = system_tree_root_->FindOrAddDevice(devicename);
 254   hdd_dev->AddErrorInstance(error);
 255
 256   // HDD error was not masked by bad DIMMs: report bad HDD.
 257   if (!mask_hdd_error) {
 258     os_->ErrorReport(devicename.c_str(), "miscompare", 1);
 259     error->severity_ = SAT_ERROR_FATAL;
 260     return 1;
 261   }
 262   return 0;
 263 }
 264
 265 // Info about a sector tag miscompare from a drive.
 266 // Returns -1 on error, 1 if diagnoser reports error externally; 0 otherwise.
 267 int ErrorDiag::AddHDDSectorTagError(string devicename, int block, int offset,
 268                                     int sector, void *src_addr,
 269                                     void *dst_addr) {
 270   bool mask_hdd_error = false;
 271
 272   HDDSectorTagErrorInstance *error = new HDDSectorTagErrorInstance;
 273   if (!error)
 274     return -1;
 275
 276   error->addr_ = reinterpret_cast<uint64>(src_addr);
 277   error->addr2_ = reinterpret_cast<uint64>(dst_addr);
 278   error->sector_ = sector;
 279   error->block_ = block;
 280
 281   string src_dimm = AddressToDimmString(os_, src_addr, offset);
 282   string dst_dimm = AddressToDimmString(os_, dst_addr, offset);
 283
 284   // DIMM name look up success
 285   if (src_dimm.compare("DIMM Unknown")) {
 286     // Add src DIMM as possible miscompare cause.
 287     DeviceTree *src_dimm_dev = system_tree_root_->FindOrAddDevice(src_dimm);
 288     error->causes_.insert(src_dimm_dev);
 289     if (src_dimm_dev->KnownBad()) {
 290       mask_hdd_error = true;
 291       logprintf(5, "Log: supressed %s sector tag error report: "
 292                 "known bad source: %s\n", devicename.c_str(), src_dimm.c_str());
 293     }
 294   }
 295   if (dst_dimm.compare("DIMM Unknown")) {
 296     // Add dst DIMM as possible miscompare cause.
 297     DeviceTree *dst_dimm_dev = system_tree_root_->FindOrAddDevice(dst_dimm);
 298     error->causes_.insert(dst_dimm_dev);
 299     if (dst_dimm_dev->KnownBad()) {
 300       mask_hdd_error = true;
 301       logprintf(5, "Log: supressed %s sector tag error report: "
 302                 "known bad destination: %s\n", devicename.c_str(),
 303                 dst_dimm.c_str());
 304     }
 305   }
 306
 307   DeviceTree *hdd_dev = system_tree_root_->FindOrAddDevice(devicename);
 308   hdd_dev->AddErrorInstance(error);
 309
 310   // HDD error was not masked by bad DIMMs: report bad HDD.
 311   if (!mask_hdd_error) {
 312     os_->ErrorReport(devicename.c_str(), "sector", 1);
 313     error->severity_ = SAT_ERROR_FATAL;
 314     return 1;
 315   }
 316   return 0;
 317 }