6c83be31e7bffe8f88032fff2f32ef695f61a185
[chef.git] / 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_disk_size(size)
15     if size =~ /^(\d+(?:\.\d+))?\s*TB/i
16       sprintf "%dTB", Regexp.last_match(1).to_f * 2**40 / 1_000_000_000_000
17     elsif size =~ /^(\d+(?:\.\d+))?\s*GB/i
18       sprintf "%dGB", Regexp.last_match(1).to_f * 2**30 / 1000000000
19     end
20   end
21
22   def pci_devices
23     device = nil
24
25     IO.popen(["lspci", "-Dkvmm"]).each_with_object(Mash.new) do |line, devices|
26       if line =~ /^Slot:\s+((\h{4}):(\h{2}):(\h{2}).(\h))\s*$/
27         device = {
28           :slot => Regexp.last_match(1),
29           :domain => Regexp.last_match(2),
30           :bus => Regexp.last_match(3),
31           :device => Regexp.last_match(4),
32           :function => Regexp.last_match(5)
33         }
34       elsif device && line =~ /^([A-Z]+):\s+(.*)\s*$/i
35         case Regexp.last_match(1)
36         when "Class" then device[:class_name] = Regexp.last_match(2)
37         when "Vendor" then device[:vendor_name] = Regexp.last_match(2)
38         when "Device" then device[:device_name] = Regexp.last_match(2)
39         when "SVendor" then device[:subsystem_vendor_name] = Regexp.last_match(2)
40         when "SDevice" then device[:subsystem_device_name] = Regexp.last_match(2)
41         when "PhySlot" then device[:physical_slot] = Regexp.last_match(2)
42         when "Rev" then device[:revision] = Regexp.last_match(2)
43         when "ProgIf" then device[:programming_interface] = Regexp.last_match(2)
44         when "Driver" then device[:driver] = Regexp.last_match(2)
45         when "Module" then device[:modules] = Array(device[:modules]) << Regexp.last_match(2)
46         end
47       elsif device && line =~ /^\s*$/
48         devices[device[:slot]] = device
49         device = nil
50       end
51     end
52   end
53
54   def network_devices
55     Dir.glob("/sys/class/net/*").each_with_object(Mash.new) do |device, devices|
56       name = File.basename(device)
57
58       devices[name] = {
59         :device => read_sysctl_link("#{device}/device"),
60         :duplex => read_sysctl_file("#{device}/duplex"),
61         :speed => read_sysctl_file("#{device}/speed")
62       }.delete_if { |_, v| v.nil? }
63     end
64   end
65
66   def memory_devices
67     device = nil
68
69     IO.popen(["dmidecode", "-t", "memory"]).each_with_object([]) do |line, devices|
70       if line =~ /^Memory Device\s*$/
71         device = {}
72       elsif device && line =~ /^\s+([A-Z ]+):\s+(.*)\s*$/i
73         device[Regexp.last_match(1).tr(" ", "_").downcase.to_sym] = Regexp.last_match(2).strip
74       elsif device && line =~ /^\s*$/
75         devices << device
76         device = nil
77       end
78     end
79   end
80
81   def disk_devices
82     disk = Mash.new
83
84     disk[:controllers] = []
85     disk[:arrays] = []
86     disk[:disks] = []
87
88     find_direct_disks(disk)
89     find_hp_disks(disk) if File.exist?("/usr/sbin/hpssacli")
90     find_megaraid_disks(disk) if File.exist?("/usr/sbin/megacli")
91     # aacraid
92     # areca (/opt/areca/x86_64/cli64)
93
94     disk
95   end
96
97   def find_direct_disks(devices)
98     Dir.glob("/sys/class/scsi_host/host*") do |host|
99       driver = read_sysctl_file("#{host}/proc_name")
100
101       if driver == "ahci" || driver == "mptsas" ||
102          driver == "mpt2sas" || driver == "mpt3sas"
103         bus = host.sub("/sys/class/scsi_host/host", "")
104
105         Dir.glob("/sys/bus/scsi/devices/#{bus}:0:*").each do |device|
106           next unless File.exist?("#{device}/scsi_disk")
107
108           block = Dir.glob("#{device}/block/*").first
109           vendor = read_sysctl_file("#{device}/vendor")
110           model = read_sysctl_file("#{device}/model")
111           size = read_sysctl_file("#{block}/size").to_i * 512
112
113           if vendor == "ATA" && model =~ /^(\S+)\s+(.*)$/
114             vendor = Regexp.last_match(1)
115             model = Regexp.last_match(2)
116           end
117
118           if size > 1_000_000_000_000
119             size = sprintf "%d TB", size / 1_000_000_000_000
120           elsif size > 1000000000
121             size = sprintf "%d GB", size / 1000000000
122           end
123
124           devices[:disks] << {
125             :id => devices[:disks].count,
126             :device => "/dev/#{File.basename(block)}",
127             :vendor => vendor,
128             :model => model,
129             :firmware_version => read_sysctl_file("#{device}/rev"),
130             :size => size
131           }
132         end
133       end
134     end
135   end
136
137   def find_hp_disks(devices)
138     controllers = []
139     disks = []
140
141     controller = nil
142     array = nil
143     disk = nil
144
145     IO.popen(%w(hpssacli controller all show config detail)).each do |line|
146       if line =~ /^Smart Array (\S+) /
147         controller = {
148           :id => devices[:controllers].count,
149           :model => Regexp.last_match(1),
150           :arrays => [],
151           :disks => []
152         }
153
154         devices[:controllers] << controller
155
156         controllers << controller
157
158         array = nil
159         disk = nil
160       elsif controller && line =~ /^   (\S.*):\s+(.*)$/
161         case Regexp.last_match(1)
162         when "Serial Number" then controller[:serial_number] = Regexp.last_match(2)
163         when "Hardware Revision" then controller[:hardware_version] = Regexp.last_match(2)
164         when "Firmware Version" then controller[:firmware_version] = Regexp.last_match(2)
165         when "PCI Address (Domain:Bus:Device.Function)" then controller[:pci_slot] = Regexp.last_match(2)
166         end
167       elsif controller && line =~ /^      Logical Drive: (\d+)$/
168         array = {
169           :id => devices[:arrays].count,
170           :controller => controller[:id],
171           :number => Regexp.last_match(1),
172           :disks => []
173         }
174
175         devices[:arrays] << array
176         controller[:arrays] << array[:id]
177
178         disk = nil
179       elsif controller && line =~ /^      physicaldrive (\S+) /
180         disks << Regexp.last_match(1)
181       elsif array && line =~ /^      physicaldrive (\S+)$/
182         disk = {
183           :id => devices[:disks].count,
184           :controller => controller[:id],
185           :array => array[:id],
186           :location => Regexp.last_match(1),
187           :smart_device => "cciss,#{disks.find_index(Regexp.last_match(1))}"
188         }
189
190         devices[:disks] << disk
191         controller[:disks] << disk[:id]
192         array[:disks] << disk[:id]
193       elsif disk && line =~ /^         (\S[^:]+):\s+(.*)$/
194         case Regexp.last_match(1)
195         when "Interface Type" then disk[:interface] = Regexp.last_match(2)
196         when "Size" then disk[:size] = Regexp.last_match(2)
197         when "Rotational Speed" then disk[:rpm] = Regexp.last_match(2)
198         when "Firmware Revision" then disk[:firmware_version] = Regexp.last_match(2)
199         when "Serial Number" then disk[:serial_number] = Regexp.last_match(2)
200         when "Model" then disk[:vendor], disk[:model] = Regexp.last_match(2).squeeze(" ").strip.sub(/^ATA /, "").split
201         end
202       elsif array && line =~ /^         (\S[^:]+):\s+(.*)$/
203         case Regexp.last_match(1)
204         when "Size" then array[:size] = Regexp.last_match(2)
205         when "Fault Tolerance" then array[:raid_level] = Regexp.last_match(2)
206         when "Disk Name" then array[:device] = Regexp.last_match(2).strip
207         when "Mount Points" then array[:mount_point] = Regexp.last_match(2).split.first
208         when "Unique Identifier" then array[:wwn] = Regexp.last_match(2)
209         end
210       end
211     end
212
213     controllers.each do |controller|
214       if device = Dir.glob("/sys/bus/pci/devices/#{controller[:pci_slot]}/cciss*").first
215         controller[:device] = File.basename(device).sub(/^cciss(\d+)$/, "/dev/cciss/c\\1d0")
216       elsif device = Dir.glob("/sys/bus/pci/devices/#{controller[:pci_slot]}/host*/target0:0:0/0:0:0:0/scsi_generic/sg*").first
217         controller[:device] = "/dev/#{File.basename(device)}"
218       end
219     end
220   end
221
222   def find_megaraid_disks(devices)
223     controllers = []
224     arrays = []
225
226     controller = nil
227     array = nil
228     disk = nil
229
230     IO.popen(%w(megacli -AdpGetPciInfo -aAll -NoLog)).each do |line|
231       if line =~ /^PCI information for Controller (\d+)$/
232         controller = {
233           :id => devices[:controllers].count,
234           :arrays => [],
235           :disks => []
236         }
237
238         devices[:controllers] << controller
239
240         controllers << controller
241       elsif line =~ /^Bus Number\s+:\s+(\d+)$/
242         controller[:pci_slot] = sprintf "0000:%02x", Integer("0x#{Regexp.last_match(1)}")
243       elsif line =~ /^Device Number\s+:\s+(\d+)$/
244         controller[:pci_slot] = sprintf "%s:%02x", controller[:pci_slot], Integer("0x#{Regexp.last_match(1)}")
245       elsif line =~ /^Function Number\s+:\s+(\d+)$/
246         controller[:pci_slot] = sprintf "%s.%01x", controller[:pci_slot], Integer("0x#{Regexp.last_match(1)}")
247       end
248     end
249
250     IO.popen(%w(megacli -AdpAllInfo -aAll -NoLog)).each do |line|
251       if line =~ /^Adapter #(\d+)$/
252         controller = controllers[Regexp.last_match(1).to_i]
253       elsif line =~ /^(\S.*\S)\s*:\s+(\S.*)$/
254         case Regexp.last_match(1)
255         when "Product Name" then controller[:model] = Regexp.last_match(2)
256         when "Serial No" then controller[:serial_number] = Regexp.last_match(2)
257         when "FW Package Build" then controller[:firmware_version] = Regexp.last_match(2)
258         end
259       end
260     end
261
262     IO.popen(%w(megacli -LdPdInfo -aAll -NoLog)).each do |line|
263       if line =~ /^Adapter #(\d+)$/
264         controller = controllers[Regexp.last_match(1).to_i]
265       elsif controller && line =~ /^Virtual Drive: (\d+) \(Target Id: (\d+)\)$/
266         array = {
267           :id => devices[:arrays].count,
268           :controller => controller[:id],
269           :number => Regexp.last_match(1),
270           :disks => []
271         }
272
273         devices[:arrays] << array
274         controller[:arrays] << array[:id]
275
276         arrays << array
277
278         disk = nil
279       elsif array && line =~ /^PD: (\d+) Information$/
280         disk = {
281           :id => devices[:disks].count,
282           :controller => controller[:id],
283           :array => array[:id]
284         }
285
286         devices[:disks] << disk
287         controller[:disks] << disk[:id]
288         array[:disks] << disk[:id]
289       elsif disk && line =~ /^(\S.*\S)\s*:\s+(\S.*)$/
290         case Regexp.last_match(1)
291         when "Device Id" then disk[:smart_devlce] = "megaraid,#{Regexp.last_match(2)}"
292         when "WWN" then disk[:wwn] = Regexp.last_match(2)
293         when "PD Type" then disk[:interface] = Regexp.last_match(2)
294         when "Raw Size" then disk[:size] = parse_disk_size(Regexp.last_match(2).sub(/\s*\[.*\]$/, ""))
295         when "Inquiry Data" then disk[:vendor], disk[:model], disk[:serial] = Regexp.last_match(2).split
296         end
297       elsif array && line =~ /^(\S.*\S)\s*:\s+(\S.*)$/
298         case Regexp.last_match(1)
299         when "RAID Level" then array[:raid_level] = Regexp.last_match(2).scan(/Primary-(\d+)/).first.first
300         when "Size" then array[:size] = Regexp.last_match(2)
301         end
302       end
303     end
304
305     IO.popen(%w(megacli -PDList -aAll -NoLog)).each do |line|
306       if line =~ /^Adapter #(\d+)$/
307         controller = controllers[Regexp.last_match(1).to_i]
308       elsif controller && line =~ /^Enclosure Device ID: \d+$/
309         disk = {
310           :controller => controller[:id]
311         }
312       elsif disk && line =~ /^WWN:\s+(\S+)$/
313         unless devices[:disks].find { |d| d[:wwn] == Regexp.last_match(1) }
314           disk[:id] = devices[:disks].count
315           disk[:wwn] = Regexp.last_match(1)
316
317           devices[:disks] << disk
318         end
319       elsif disk && line =~ /^(\S.*\S)\s*:\s+(\S.*)$/
320         case Regexp.last_match(1)
321         when "Device Id" then disk[:smart_devlce] = "megaraid,#{Regexp.last_match(2)}"
322         when "WWN" then disk[:wwn] = Regexp.last_match(2)
323         when "PD Type" then disk[:interface] = Regexp.last_match(2)
324         when "Raw Size" then disk[:size] = parse_disk_size(Regexp.last_match(2).sub(/\s*\[.*\]$/, ""))
325         when "Inquiry Data" then disk[:vendor], disk[:model], disk[:serial] = Regexp.last_match(2).split
326         end
327       end
328     end
329
330     controllers.each do |controller|
331       if device = Dir.glob("/sys/bus/pci/devices/#{controller[:pci_slot]}/host*/target*:2:0/*/scsi_generic/sg*").first
332         controller[:device] = "/dev/#{File.basename(device)}"
333       end
334     end
335   end
336
337   collect_data(:default) do
338     hardware Mash.new
339
340     hardware[:pci] = pci_devices
341     hardware[:network] = network_devices
342     hardware[:memory] = memory_devices
343     hardware[:disk] = disk_devices
344   end
345 end