cookbooks/hardware/templates/default/ohai.rb.erb

   1 Ohai.plugin(:Hardware) do
   2   provides "hardware"
   3
   4   def read_sysctl_link(file)
   5     File.basename(File.readlink(file))
   6   rescue Errno::ENOENT
   7   end
   8
   9   def read_sysctl_file(file)
  10     IO.read(file).strip
  11   rescue Errno::ENOENT, Errno::EINVAL
  12   end
  13
  14   def parse_memory_size(size)
  15     if size =~ /^(\d+(?:\.\d+)?)\s*TB/i
  16       Regexp.last_match(1).to_f * 2**30
  17     elsif size =~ /^(\d+(?:\.\d+)?)\s*GB/i
  18       Regexp.last_match(1).to_f * 2**20
  19     elsif size =~ /^(\d+(?:\.\d+)?)\s*MB/i
  20       Regexp.last_match(1).to_f * 2**10
  21     end
  22   end
  23
  24   def format_disk_size(kb)
  25     if kb == 0
  26       ""
  27     else
  28       kblog10 = Math.log10(kb)
  29
  30       if kblog10 >= 9
  31         format "%gTB", 10**(kblog10 - 9)
  32       elsif kblog10 >= 6
  33         format "%dGB", 10**(kblog10 - 6)
  34       else
  35         format "%dMB", 10**(kblog10 - 3)
  36       end
  37     end
  38   end
  39
  40   def memory_to_disk_size(size)
  41     format_disk_size(parse_memory_size(size))
  42   end
  43
  44   def find_sas_device(address)
  45     file = Dir.glob("/sys/class/scsi_generic/sg*/device/sas_address").find do |file|
  46       read_sysctl_file(file) == "0x#{address}"
  47     end
  48
  49     if file
  50       dir = File.dirname(file)
  51       device = Dir.glob("#{dir}/block/*").first ||
  52                Dir.glob("#{dir}/scsi_generic/*").first
  53
  54       "/dev/#{File.basename(device)}"
  55     end
  56   end
  57
  58   def pci_devices
  59     device = nil
  60
  61     IO.popen(["lspci", "-Dkvmm"]).each_with_object(Mash.new) do |line, devices|
  62       if line =~ /^Slot:\s+((\h{4}):(\h{2}):(\h{2}).(\h))\s*$/
  63         device = {
  64           :slot => Regexp.last_match(1),
  65           :domain => Regexp.last_match(2),
  66           :bus => Regexp.last_match(3),
  67           :device => Regexp.last_match(4),
  68           :function => Regexp.last_match(5)
  69         }
  70       elsif device && line =~ /^([A-Z]+):\s+(.*)\s*$/i
  71         case Regexp.last_match(1)
  72         when "Class" then device[:class_name] = Regexp.last_match(2)
  73         when "Vendor" then device[:vendor_name] = Regexp.last_match(2)
  74         when "Device" then device[:device_name] = Regexp.last_match(2)
  75         when "SVendor" then device[:subsystem_vendor_name] = Regexp.last_match(2)
  76         when "SDevice" then device[:subsystem_device_name] = Regexp.last_match(2)
  77         when "PhySlot" then device[:physical_slot] = Regexp.last_match(2)
  78         when "Rev" then device[:revision] = Regexp.last_match(2)
  79         when "ProgIf" then device[:programming_interface] = Regexp.last_match(2)
  80         when "Driver" then device[:driver] = Regexp.last_match(2)
  81         when "Module" then device[:modules] = Array(device[:modules]) << Regexp.last_match(2)
  82         end
  83       elsif device && line =~ /^\s*$/
  84         devices[device[:slot]] = device
  85         device = nil
  86       end
  87     end
  88   end
  89
  90   def network_devices
  91     Dir.glob("/sys/class/net/*").each_with_object(Mash.new) do |device, devices|
  92       name = File.basename(device)
  93
  94       devices[name] = {
  95         :device => read_sysctl_link("#{device}/device"),
  96         :duplex => read_sysctl_file("#{device}/duplex"),
  97         :speed => read_sysctl_file("#{device}/speed")
  98       }.delete_if { |_, v| v.nil? }
  99     end
 100   end
 101
 102   def memory_devices
 103     device = nil
 104
 105     IO.popen(["dmidecode", "-t", "memory"]).each_with_object([]) do |line, devices|
 106       if line =~ /^Memory Device\s*$/
 107         device = {}
 108       elsif device && line =~ /^\s+([A-Z ]+):\s+(.*)\s*$/i
 109         device[Regexp.last_match(1).tr(" ", "_").downcase.to_sym] = Regexp.last_match(2).strip
 110       elsif device && line =~ /^\s*$/
 111         devices << device
 112         device = nil
 113       end
 114     end
 115   end
 116
 117   def disk_devices
 118     disk = Mash.new
 119
 120     disk[:controllers] = []
 121     disk[:arrays] = []
 122     disk[:disks] = []
 123
 124     find_direct_disks(disk)
 125
 126     find_hp_disks(disk) if File.exist?("/usr/sbin/hpssacli")
 127     find_megaraid_disks(disk) if File.exist?("/usr/sbin/megacli")
 128     find_mpt_disks(disk) if File.exist?("/usr/sbin/sas2ircu")
 129     # aacraid
 130     # areca (/opt/areca/x86_64/cli64)
 131
 132     find_md_arrays(disk)
 133
 134     disk
 135   end
 136
 137   def find_direct_disks(devices)
 138     Dir.glob("/sys/class/scsi_host/host*") do |host|
 139       driver = read_sysctl_file("#{host}/proc_name")
 140
 141       if driver == "ahci" || driver == "mptsas"
 142         bus = host.sub("/sys/class/scsi_host/host", "")
 143
 144         Dir.glob("/sys/bus/scsi/devices/#{bus}:0:*").each do |device|
 145           next unless File.exist?("#{device}/scsi_disk")
 146
 147           block = Dir.glob("#{device}/block/*").first
 148           vendor = read_sysctl_file("#{device}/vendor")
 149           model = read_sysctl_file("#{device}/model")
 150           size = read_sysctl_file("#{block}/size").to_i * 512
 151
 152           if vendor == "ATA" && model =~ /^(\S+)\s+(.*)$/
 153             vendor = Regexp.last_match(1)
 154             model = Regexp.last_match(2)
 155           end
 156
 157           devices[:disks] << {
 158             :id => devices[:disks].count,
 159             :device => "/dev/#{File.basename(block)}",
 160             :vendor => vendor,
 161             :model => model,
 162             :firmware_version => read_sysctl_file("#{device}/rev"),
 163             :size => format_disk_size(size),
 164             :arrays => []
 165           }
 166         end
 167       end
 168     end
 169   end
 170
 171   def find_md_arrays(devices)
 172     array = nil
 173
 174     File.new("/proc/mdstat", "r").each do |line|
 175       if line =~ /^(md\d+) : active raid(\d+)((?: [a-z]+\d+\[\d+\](?:\([A-Z]\))*)+)$/
 176         array = {
 177           :id => devices[:arrays].count,
 178           :device => "/dev/#{Regexp.last_match(1)}",
 179           :raid_level => Regexp.last_match(2),
 180           :disks => []
 181         }
 182
 183         Regexp.last_match(3).scan(/ ([a-z]+)\d+\[\d+\](?:\([A-Z]\))*/).flatten.each do |device|
 184           if disk = devices[:disks].find { |d| d[:device] == "/dev/#{device}" }
 185             disk[:arrays] << array[:id]
 186             array[:disks] << disk[:id]
 187           end
 188         end
 189
 190         devices[:arrays] << array
 191       elsif line =~ /^\s+(\d+) blocks/
 192         array[:size] = format_disk_size(Regexp.last_match(1).to_i)
 193       end
 194     end
 195   end
 196
 197   def find_hp_disks(devices)
 198     controllers = []
 199     disks = []
 200
 201     controller = nil
 202     array = nil
 203     disk = nil
 204
 205     IO.popen(%w(hpssacli controller all show config detail)).each do |line|
 206       if line =~ /^Smart Array (\S+) /
 207         controller = {
 208           :id => devices[:controllers].count,
 209           :model => Regexp.last_match(1),
 210           :arrays => [],
 211           :disks => []
 212         }
 213
 214         devices[:controllers] << controller
 215
 216         controllers << controller
 217
 218         array = nil
 219         disk = nil
 220       elsif controller && line =~ /^   (\S.*):\s+(.*)$/
 221         case Regexp.last_match(1)
 222         when "Serial Number" then controller[:serial_number] = Regexp.last_match(2)
 223         when "Hardware Revision" then controller[:hardware_version] = Regexp.last_match(2)
 224         when "Firmware Version" then controller[:firmware_version] = Regexp.last_match(2)
 225         when "PCI Address (Domain:Bus:Device.Function)" then controller[:pci_slot] = Regexp.last_match(2)
 226         end
 227       elsif controller && line =~ /^      Logical Drive: (\d+)$/
 228         array = {
 229           :id => devices[:arrays].count,
 230           :controller => controller[:id],
 231           :number => Regexp.last_match(1),
 232           :disks => []
 233         }
 234
 235         devices[:arrays] << array
 236         controller[:arrays] << array[:id]
 237
 238         disk = nil
 239       elsif controller && line =~ /^      physicaldrive (\S+) /
 240         disks << Regexp.last_match(1)
 241       elsif array && line =~ /^      physicaldrive (\S+)$/
 242         disk = {
 243           :id => devices[:disks].count,
 244           :controller => controller[:id],
 245           :arrays => [array[:id]],
 246           :location => Regexp.last_match(1),
 247           :smart_device => "cciss,#{disks.find_index(Regexp.last_match(1))}"
 248         }
 249
 250         devices[:disks] << disk
 251         controller[:disks] << disk[:id]
 252         array[:disks] << disk[:id]
 253       elsif disk && line =~ /^         (\S[^:]+):\s+(.*)$/
 254         case Regexp.last_match(1)
 255         when "Interface Type" then disk[:interface] = Regexp.last_match(2)
 256         when "Size" then disk[:size] = Regexp.last_match(2)
 257         when "Rotational Speed" then disk[:rpm] = Regexp.last_match(2)
 258         when "Firmware Revision" then disk[:firmware_version] = Regexp.last_match(2)
 259         when "Serial Number" then disk[:serial_number] = Regexp.last_match(2)
 260         when "Model" then disk[:vendor], disk[:model] = Regexp.last_match(2).squeeze(" ").strip.sub(/^ATA /, "").split
 261         end
 262       elsif array && line =~ /^         (\S[^:]+):\s+(.*)$/
 263         case Regexp.last_match(1)
 264         when "Size" then array[:size] = Regexp.last_match(2)
 265         when "Fault Tolerance" then array[:raid_level] = Regexp.last_match(2)
 266         when "Disk Name" then array[:device] = Regexp.last_match(2).strip
 267         when "Mount Points" then array[:mount_point] = Regexp.last_match(2).split.first
 268         when "Unique Identifier" then array[:wwn] = Regexp.last_match(2)
 269         end
 270       end
 271     end
 272
 273     controllers.each do |controller|
 274       if device = Dir.glob("/sys/bus/pci/devices/#{controller[:pci_slot]}/cciss*").first
 275         controller[:device] = File.basename(device).sub(/^cciss(\d+)$/, "/dev/cciss/c\\1d0")
 276       elsif device = Dir.glob("/sys/bus/pci/devices/#{controller[:pci_slot]}/host*/target0:0:0/0:0:0:0/scsi_generic/sg*").first
 277         controller[:device] = "/dev/#{File.basename(device)}"
 278       end
 279     end
 280   end
 281
 282   def find_megaraid_disks(devices)
 283     controllers = []
 284     arrays = []
 285
 286     controller = nil
 287     array = nil
 288     disk = nil
 289
 290     IO.popen(%w(megacli -AdpGetPciInfo -aAll -NoLog)).each do |line|
 291       if line =~ /^PCI information for Controller (\d+)$/
 292         controller = {
 293           :id => devices[:controllers].count,
 294           :arrays => [],
 295           :disks => []
 296         }
 297
 298         devices[:controllers] << controller
 299
 300         controllers << controller
 301       elsif line =~ /^Bus Number\s+:\s+(\d+)$/
 302         controller[:pci_slot] = format "0000:%02x", Integer("0x#{Regexp.last_match(1)}")
 303       elsif line =~ /^Device Number\s+:\s+(\d+)$/
 304         controller[:pci_slot] = format "%s:%02x", controller[:pci_slot], Integer("0x#{Regexp.last_match(1)}")
 305       elsif line =~ /^Function Number\s+:\s+(\d+)$/
 306         controller[:pci_slot] = format "%s.%01x", controller[:pci_slot], Integer("0x#{Regexp.last_match(1)}")
 307       end
 308     end
 309
 310     IO.popen(%w(megacli -AdpAllInfo -aAll -NoLog)).each do |line|
 311       if line =~ /^Adapter #(\d+)$/
 312         controller = controllers[Regexp.last_match(1).to_i]
 313       elsif line =~ /^(\S.*\S)\s*:\s+(\S.*)$/
 314         case Regexp.last_match(1)
 315         when "Product Name" then controller[:model] = Regexp.last_match(2)
 316         when "Serial No" then controller[:serial_number] = Regexp.last_match(2)
 317         when "FW Package Build" then controller[:firmware_version] = Regexp.last_match(2)
 318         end
 319       end
 320     end
 321
 322     IO.popen(%w(megacli -LdPdInfo -aAll -NoLog)).each do |line|
 323       if line =~ /^Adapter #(\d+)$/
 324         controller = controllers[Regexp.last_match(1).to_i]
 325       elsif controller && line =~ /^Virtual Drive: (\d+) \(Target Id: (\d+)\)$/
 326         pci_slot = controller[:pci_slot]
 327         target = Regexp.last_match(2)
 328         device = Dir.glob("/sys/bus/pci/devices/#{pci_slot}/host*/target*:2:#{target}/*:2:#{target}:0/block/*").first
 329
 330         array = {
 331           :id => devices[:arrays].count,
 332           :controller => controller[:id],
 333           :number => Regexp.last_match(1),
 334           :device => "/dev/#{File.basename(device)}",
 335           :disks => []
 336         }
 337
 338         devices[:arrays] << array
 339         controller[:arrays] << array[:id]
 340
 341         arrays << array
 342
 343         disk = nil
 344       elsif array && line =~ /^PD: (\d+) Information$/
 345         disk = {
 346           :id => devices[:disks].count,
 347           :controller => controller[:id],
 348           :arrays => [array[:id]]
 349         }
 350
 351         devices[:disks] << disk
 352         controller[:disks] << disk[:id]
 353         array[:disks] << disk[:id]
 354       elsif disk && line =~ /^(\S.*\S)\s*:\s+(\S.*)$/
 355         case Regexp.last_match(1)
 356         when "Device Id" then disk[:smart_devlce] = "megaraid,#{Regexp.last_match(2)}"
 357         when "WWN" then disk[:wwn] = Regexp.last_match(2)
 358         when "PD Type" then disk[:interface] = Regexp.last_match(2)
 359         when "Raw Size" then disk[:size] = memory_to_disk_size(Regexp.last_match(2).sub(/\s*\[.*\]$/, ""))
 360         when "Inquiry Data" then disk[:vendor], disk[:model], disk[:serial] = Regexp.last_match(2).split
 361         end
 362       elsif array && line =~ /^(\S.*\S)\s*:\s+(\S.*)$/
 363         case Regexp.last_match(1)
 364         when "RAID Level" then array[:raid_level] = Regexp.last_match(2).scan(/Primary-(\d+)/).first.first
 365         when "Size" then array[:size] = Regexp.last_match(2)
 366         end
 367       end
 368     end
 369
 370     IO.popen(%w(megacli -PDList -aAll -NoLog)).each do |line|
 371       if line =~ /^Adapter #(\d+)$/
 372         controller = controllers[Regexp.last_match(1).to_i]
 373       elsif controller && line =~ /^Enclosure Device ID: \d+$/
 374         disk = {
 375           :controller => controller[:id]
 376         }
 377       elsif disk && line =~ /^WWN:\s+(\S+)$/
 378         unless devices[:disks].find { |d| d[:wwn] == Regexp.last_match(1) }
 379           disk[:id] = devices[:disks].count
 380           disk[:wwn] = Regexp.last_match(1)
 381
 382           devices[:disks] << disk
 383         end
 384       elsif disk && line =~ /^(\S.*\S)\s*:\s+(\S.*)$/
 385         case Regexp.last_match(1)
 386         when "Device Id" then disk[:smart_devlce] = "megaraid,#{Regexp.last_match(2)}"
 387         when "WWN" then disk[:wwn] = Regexp.last_match(2)
 388         when "PD Type" then disk[:interface] = Regexp.last_match(2)
 389         when "Raw Size" then disk[:size] = memory_to_disk_size(Regexp.last_match(2).sub(/\s*\[.*\]$/, ""))
 390         when "Inquiry Data" then disk[:vendor], disk[:model], disk[:serial] = Regexp.last_match(2).split
 391         end
 392       end
 393     end
 394
 395     controllers.each do |controller|
 396       if device = Dir.glob("/sys/bus/pci/devices/#{controller[:pci_slot]}/host*/target*:2:0/*/scsi_generic/sg*").first
 397         controller[:device] = "/dev/#{File.basename(device)}"
 398       end
 399     end
 400   end
 401
 402   def find_mpt_disks(devices)
 403     controllers = []
 404
 405     IO.popen(%w(sas2ircu list)).each do |line|
 406       next unless line =~ /^\s+(\d+)\s+(\S+)\s+\h+h\s+\h+h\s+(\S+)\s+\h+h\s+\h+h\s*$/
 407       controllers[Regexp.last_match(1).to_i] = {
 408         :id => devices[:controllers].count,
 409         :model => Regexp.last_match(2),
 410         :pci_slot => Regexp.last_match(3).sub(/^(\h{2})h:(\h{2})h:(\h{2})h:0(\h)h$/, "00\\1:\\2:\\3.\\4"),
 411         :arrays => [],
 412         :disks => []
 413       }
 414
 415       devices[:controllers] << controllers[Regexp.last_match(1).to_i]
 416     end
 417
 418     controllers.each_with_index do |controller, index|
 419       arrays = []
 420       disks = []
 421
 422       array = nil
 423       disk = nil
 424
 425       IO.popen(["sas2ircu", index.to_s, "display"]).each do |line|
 426         if line =~ /^IR volume (\d+)$/
 427           array = {
 428             :id => devices[:arrays].count,
 429             :controller => controller[:id],
 430             :number => Regexp.last_match(1),
 431             :disks => []
 432           }
 433
 434           devices[:arrays] << array
 435           controller[:arrays] << array[:id]
 436
 437           arrays << array
 438         elsif line =~ /^Device is a Hard disk$/
 439           disk = {
 440             :id => devices[:disks].count,
 441             :controller => controller[:id],
 442             :arrays => []
 443           }
 444
 445           devices[:disks] << disk
 446           controller[:disks] << disk[:id]
 447
 448           disks << disk
 449         elsif disk && line =~ /^  (\S.*\S)\s+:\s+(.*\S)\s*$/
 450           case Regexp.last_match(1)
 451           when "Enclosure #" then disk[:location] = Regexp.last_match(2)
 452           when "Slot #" then disk[:location] = "#{disk[:location]}:#{Regexp.last_match(2)}"
 453           when "SAS Address" then disk[:device] = find_sas_device(Regexp.last_match(2).tr("-", ""))
 454           when "Size (in MB)/(in sectors)" then disk[:size] = memory_to_disk_size("#{Regexp.last_match(2).split('/').first} MB")
 455           when "Manufacturer" then disk[:vendor] = Regexp.last_match(2)
 456           when "Model Number" then disk[:model] = Regexp.last_match(2)
 457           when "Firmware Revision" then disk[:firmware_version] = Regexp.last_match(2)
 458           when "Serial Number" then disk[:serial_number] = Regexp.last_match(2)
 459           when "Protocol" then disk[:interface] = Regexp.last_match(2)
 460           end
 461         elsif array && line =~ /^  PHY\[\d+\] Enclosure#\/Slot#\s+:\s+(\d+:\d+)\s*$/
 462           array[:disks] << Regexp.last_match(1)
 463         elsif array && line =~ /^  (\S.*\S)\s+:\s+(.*\S)\s*$/
 464           case Regexp.last_match(1)
 465           when "Volume wwid" then array[:device] = find_sas_device(Regexp.last_match(2))
 466           when "RAID level" then array[:raid_level] = Regexp.last_match(2).sub(/^RAID/, "")
 467           when "Size (in MB)" then array[:size] = "#{Regexp.last_match(2)} MB"
 468           end
 469         elsif line =~ /^  (\S.*\S)\s+:\s+(.*\S)\s*$/
 470           case Regexp.last_match(1)
 471           when "BIOS version" then controller[:bios_version] = Regexp.last_match(2)
 472           when "Firmware version" then controller[:firmware_version] = Regexp.last_match(2)
 473           end
 474         end
 475       end
 476
 477       arrays.each do |array|
 478         array[:disks].map! do |location|
 479           disk = disks.find { |disk| disk[:location] == location }
 480
 481           disk[:arrays] << array[:id]
 482           disk[:id]
 483         end
 484       end
 485     end
 486   end
 487
 488   collect_data(:default) do
 489     hardware Mash.new
 490
 491     hardware[:pci] = pci_devices
 492     hardware[:network] = network_devices
 493     hardware[:memory] = memory_devices
 494     hardware[:disk] = disk_devices
 495   end
 496 end