ovs-vsctl: Remove default timeout.
[sliver-openvswitch.git] / debian / ovs-bugtool
1 #!/usr/bin/env python
2
3 # This library is free software; you can redistribute it and/or
4 # modify it under the terms of version 2.1 of the GNU Lesser General Public
5 # License as published by the Free Software Foundation.
6 #
7 # This library is distributed in the hope that it will be useful,
8 # but WITHOUT ANY WARRANTY; without even the implied warranty of
9 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10 # Lesser General Public License for more details.
11 #
12 # You should have received a copy of the GNU Lesser General Public
13 # License along with this library; if not, write to the Free Software
14 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
15 #
16 # Copyright (c) 2005, 2007 XenSource Ltd.
17 # Copyright (c) 2010, Nicira Networks.
18
19 #
20 # To add new entries to the bugtool, you need to:
21 #
22 # Create a new capability.  These declare the new entry to the GUI, including
23 # the expected size, time to collect, privacy implications, and whether the
24 # capability should be selected by default.  One capability may refer to
25 # multiple files, assuming that they can be reasonably grouped together, and
26 # have the same privacy implications.  You need:
27 #
28 #   A new CAP_ constant.
29 #   A cap() invocation to declare the capability.
30 #
31 # You then need to add calls to main() to collect the files.  These will
32 # typically be calls to the helpers file_output(), tree_output(), cmd_output(),
33 # or func_output().
34 #
35
36 import getopt
37 import re
38 import os
39 import StringIO
40 import sys
41 import tarfile
42 import time
43 import commands
44 import pprint
45 from xml.dom.minidom import parse, getDOMImplementation
46 import zipfile
47 from subprocess import Popen, PIPE
48 from select import select
49 from signal import SIGTERM, SIGUSR1
50 import md5
51 import platform
52 import fcntl
53 import glob
54 import urllib
55 import socket
56 import base64
57
58 sys.path.append('/usr/lib/python')
59 sys.path.append('/usr/lib64/python')
60
61 OS_RELEASE = platform.release()
62
63 #
64 # Files & directories
65 #
66
67 BUG_DIR = "/var/log/openvswitch"
68 PLUGIN_DIR = "/etc/openvswitch/bugtool"
69 GRUB_CONFIG = '/boot/grub/menu.lst'
70 BOOT_KERNEL = '/boot/vmlinuz-' + OS_RELEASE
71 BOOT_INITRD = '/boot/initrd-' + OS_RELEASE + '.img'
72 PROC_PARTITIONS = '/proc/partitions'
73 FSTAB = '/etc/fstab'
74 PROC_MOUNTS = '/proc/mounts'
75 PROC_CPUINFO = '/proc/cpuinfo'
76 PROC_MEMINFO = '/proc/meminfo'
77 PROC_IOPORTS = '/proc/ioports'
78 PROC_INTERRUPTS = '/proc/interrupts'
79 PROC_SCSI = '/proc/scsi/scsi'
80 PROC_VERSION = '/proc/version'
81 PROC_MODULES = '/proc/modules'
82 PROC_DEVICES = '/proc/devices'
83 PROC_FILESYSTEMS = '/proc/filesystems'
84 PROC_CMDLINE = '/proc/cmdline'
85 PROC_CONFIG = '/proc/config.gz'
86 PROC_USB_DEV = '/proc/bus/usb/devices'
87 PROC_NET_SOFTNET_STAT = '/proc/net/softnet_stat'
88 MODPROBE_DIR = '/etc/modprobe.d'
89 RESOLV_CONF = '/etc/resolv.conf'
90 NSSWITCH_CONF = '/etc/nsswitch.conf'
91 NTP_CONF = '/etc/ntp.conf'
92 HOSTS = '/etc/hosts'
93 HOSTS_ALLOW = '/etc/hosts.allow'
94 HOSTS_DENY = '/etc/hosts.deny'
95 DHCP_LEASE_DIR = '/var/lib/dhcp3'
96 OPENVSWITCH_CORE_DIR = '/var/log/openvswitch/cores'
97 OPENVSWITCH_DEFAULT_SWITCH = '/etc/default/openvswitch-switch'
98 OPENVSWITCH_DEFAULT_CONTROLLER = '/etc/default/openvswitch-controller'
99 OPENVSWITCH_CONF_DB = '/etc/openvswitch/conf.db'
100 OPENVSWITCH_VSWITCHD_PID = '/var/run/openvswitch/ovs-vswitchd.pid'
101 VAR_LOG_DIR = '/var/log/'
102 X11_LOGS_DIR = VAR_LOG_DIR
103 X11_LOGS_RE = re.compile(r'.*/Xorg\..*$')
104 X11_AUTH_DIR = '/root/'
105 X11_AUTH_RE = re.compile(r'.*/\.((Xauthority)|(serverauth\.[0-9]*))$')
106 PAM_DIR = '/etc/pam.d'
107
108 #
109 # External programs
110 #
111
112 ARP = '/usr/sbin/arp'
113 CAT = '/bin/cat'
114 DF = '/bin/df'
115 DMESG = '/bin/dmesg'
116 DMIDECODE = '/usr/sbin/dmidecode'
117 ETHTOOL = '/sbin/ethtool'
118 FDISK = '/sbin/fdisk'
119 FIND = '/usr/bin/find'
120 IFCONFIG = '/sbin/ifconfig'
121 IPTABLES = '/sbin/iptables'
122 LOSETUP = '/sbin/losetup'
123 LS = '/bin/ls'
124 LSPCI = '/usr/bin/lspci'
125 MD5SUM = '/usr/bin/md5sum'
126 MODINFO = '/sbin/modinfo'
127 NETSTAT = '/bin/netstat'
128 OVS_DPCTL = '/usr/sbin/ovs-dpctl'
129 OVS_OFCTL = '/usr/sbin/ovs-ofctl'
130 OVS_VSCTL = '/usr/sbin/ovs-vsctl'
131 OVS_APPCTL = '/usr/sbin/ovs-appctl'
132 PS = '/bin/ps'
133 ROUTE = '/sbin/route'
134 SYSCTL = '/sbin/sysctl'
135 TC = '/sbin/tc'
136 UPTIME = '/usr/bin/uptime'
137 ZCAT = '/bin/zcat'
138
139 #
140 # PII -- Personally identifiable information.  Of particular concern are
141 # things that would identify customers, or their network topology.
142 # Passwords are never to be included in any bug report, regardless of any PII
143 # declaration.
144 #
145 # NO            -- No PII will be in these entries.
146 # YES           -- PII will likely or certainly be in these entries.
147 # MAYBE         -- The user may wish to audit these entries for PII.
148 # IF_CUSTOMIZED -- If the files are unmodified, then they will contain no PII,
149 # but since we encourage customers to edit these files, PII may have been
150 # introduced by the customer.  This is used in particular for the networking
151 # scripts in dom0.
152 #
153
154 PII_NO            = 'no'
155 PII_YES           = 'yes'
156 PII_MAYBE         = 'maybe'
157 PII_IF_CUSTOMIZED = 'if_customized'
158 KEY      = 0
159 PII      = 1
160 MIN_SIZE = 2
161 MAX_SIZE = 3
162 MIN_TIME = 4
163 MAX_TIME = 5
164 MIME     = 6
165 CHECKED  = 7
166 HIDDEN   = 8
167
168 MIME_DATA = 'application/data'
169 MIME_TEXT = 'text/plain'
170
171 INVENTORY_XML_ROOT = "system-status-inventory"
172 INVENTORY_XML_SUMMARY = 'system-summary'
173 INVENTORY_XML_ELEMENT = 'inventory-entry'
174 CAP_XML_ROOT = "system-status-capabilities"
175 CAP_XML_ELEMENT = 'capability'
176
177
178 CAP_BLOBS                = 'blobs'
179 CAP_BOOT_LOADER          = 'boot-loader'
180 CAP_DISK_INFO            = 'disk-info'
181 CAP_FIRSTBOOT            = 'firstboot'
182 CAP_HARDWARE_INFO        = 'hardware-info'
183 CAP_HIGH_AVAILABILITY    = 'high-availability'
184 CAP_HOST_CRASHDUMP_DUMPS = 'host-crashdump-dumps'
185 CAP_HOST_CRASHDUMP_LOGS  = 'host-crashdump-logs'
186 CAP_KERNEL_INFO          = 'kernel-info'
187 CAP_LOSETUP_A            = 'loopback-devices'
188 CAP_NETWORK_CONFIG       = 'network-config'
189 CAP_NETWORK_STATUS       = 'network-status'
190 CAP_OEM                  = 'oem'
191 CAP_PAM                  = 'pam'
192 CAP_PROCESS_LIST         = 'process-list'
193 CAP_PERSISTENT_STATS     = 'persistent-stats'
194 CAP_SYSTEM_LOGS          = 'system-logs'
195 CAP_SYSTEM_SERVICES      = 'system-services'
196 CAP_VNCTERM              = 'vncterm'
197 CAP_WLB                  = 'wlb'
198 CAP_X11_LOGS             = 'X11'
199 CAP_X11_AUTH             = 'X11-auth'
200
201 KB = 1024
202 MB = 1024 * 1024
203
204 caps = {}
205 cap_sizes = {}
206 unlimited_data = False
207 dbg = False
208
209 def cap(key, pii=PII_MAYBE, min_size=-1, max_size=-1, min_time=-1,
210         max_time=-1, mime=MIME_TEXT, checked=True, hidden=False):
211     caps[key] = (key, pii, min_size, max_size, min_time, max_time, mime,
212                  checked, hidden)
213     cap_sizes[key] = 0
214
215
216 cap(CAP_BLOBS,               PII_NO,                    max_size=5*MB)
217 cap(CAP_BOOT_LOADER,         PII_NO,                    max_size=3*KB,
218     max_time=5)
219 cap(CAP_DISK_INFO,           PII_MAYBE,                 max_size=25*KB,
220     max_time=20)
221 cap(CAP_FIRSTBOOT,           PII_YES,   min_size=60*KB, max_size=80*KB)
222 cap(CAP_HARDWARE_INFO,       PII_MAYBE,                 max_size=30*KB,
223     max_time=20)
224 cap(CAP_HIGH_AVAILABILITY,   PII_MAYBE,                 max_size=5*MB)
225 cap(CAP_HOST_CRASHDUMP_DUMPS,PII_YES, checked = False)
226 cap(CAP_HOST_CRASHDUMP_LOGS, PII_NO)
227 cap(CAP_KERNEL_INFO,         PII_MAYBE,                 max_size=120*KB,
228     max_time=5)
229 cap(CAP_LOSETUP_A,           PII_MAYBE,                 max_size=KB, max_time=5)
230 cap(CAP_NETWORK_CONFIG,      PII_IF_CUSTOMIZED,
231                                         min_size=0,     max_size=20*KB)
232 cap(CAP_NETWORK_STATUS,      PII_YES,                   max_size=19*KB,
233     max_time=30)
234 cap(CAP_PAM,                 PII_NO,                    max_size=30*KB)
235 cap(CAP_PERSISTENT_STATS,    PII_MAYBE,                 max_size=50*MB,
236     max_time=60)
237 cap(CAP_PROCESS_LIST,        PII_YES,                   max_size=30*KB,
238     max_time=20)
239 cap(CAP_SYSTEM_LOGS,         PII_MAYBE,                 max_size=50*MB,
240     max_time=5)
241 cap(CAP_SYSTEM_SERVICES,     PII_NO,                    max_size=5*KB,
242     max_time=20)
243 cap(CAP_VNCTERM,             PII_MAYBE, checked = False)
244 cap(CAP_WLB,                 PII_NO,                    max_size=3*MB,
245     max_time=20)
246 cap(CAP_X11_LOGS,            PII_NO,                    max_size=100*KB)
247 cap(CAP_X11_AUTH,            PII_NO,                    max_size=100*KB)
248
249 ANSWER_YES_TO_ALL = False
250 SILENT_MODE = False
251 entries = None
252 data = {}
253 dev_null = open('/dev/null', 'r+')
254
255 def output(x):
256     global SILENT_MODE
257     if not SILENT_MODE:
258         print x
259
260 def output_ts(x):
261     output("[%s]  %s" % (time.strftime("%x %X %Z"), x))
262
263 def cmd_output(cap, args, label = None, filter = None):
264     if cap in entries:
265         if not label:
266             if isinstance(args, list):
267                 a = [aa for aa in args]
268                 a[0] = os.path.basename(a[0])
269                 label = ' '.join(a)
270             else:
271                 label = args
272         data[label] = {'cap': cap, 'cmd_args': args, 'filter': filter}
273
274 def file_output(cap, path_list):
275     if cap in entries:
276         for p in path_list:
277             if os.path.exists(p):
278                 if unlimited_data or caps[cap][MAX_SIZE] == -1 or \
279                         cap_sizes[cap] < caps[cap][MAX_SIZE]:
280                     data[p] = {'cap': cap, 'filename': p}
281                     try:
282                         s = os.stat(p)
283                         cap_sizes[cap] += s.st_size
284                     except:
285                         pass
286                 else:
287                     output("Omitting %s, size constraint of %s exceeded" % (p, cap))
288
289 def tree_output(cap, path, pattern = None, negate = False):
290     if cap in entries:
291         if os.path.exists(path):
292             for f in os.listdir(path):
293                 fn = os.path.join(path, f)
294                 if os.path.isfile(fn) and matches(fn, pattern, negate):
295                     file_output(cap, [fn])
296                 elif os.path.isdir(fn):
297                     tree_output(cap, fn, pattern, negate)
298
299 def func_output(cap, label, func):
300     if cap in entries:
301         t = str(func).split()
302         data[label] = {'cap': cap, 'func': func}
303
304 def collect_data():
305     process_lists = {}
306
307     for (k, v) in data.items():
308         cap = v['cap']
309         if v.has_key('cmd_args'):
310             v['output'] = StringIOmtime()
311             if not process_lists.has_key(cap):
312                 process_lists[cap] = []
313             process_lists[cap].append(ProcOutput(v['cmd_args'], caps[cap][MAX_TIME], v['output'], v['filter']))
314         elif v.has_key('filename') and v['filename'].startswith('/proc/'):
315             # proc files must be read into memory
316             try:
317                 f = open(v['filename'], 'r')
318                 s = f.read()
319                 f.close()
320                 if unlimited_data or caps[cap][MAX_SIZE] == -1 or \
321                         cap_sizes[cap] < caps[cap][MAX_SIZE]:
322                     v['output'] = StringIOmtime(s)
323                     cap_sizes[cap] += len(s)
324                 else:
325                     output("Omitting %s, size constraint of %s exceeded" % (v['filename'], cap))
326             except:
327                 pass
328         elif v.has_key('func'):
329             try:
330                 s = v['func'](cap)
331             except Exception, e:
332                 s = str(e)
333             if unlimited_data or caps[cap][MAX_SIZE] == -1 or \
334                     cap_sizes[cap] < caps[cap][MAX_SIZE]:
335                 v['output'] = StringIOmtime(s)
336                 cap_sizes[cap] += len(s)
337             else:
338                 output("Omitting %s, size constraint of %s exceeded" % (k, cap))
339
340     run_procs(process_lists.values())
341
342
343 def main(argv = None):
344     global ANSWER_YES_TO_ALL, SILENT_MODE
345     global entries, data, dbg
346
347     # we need access to privileged files, exit if we are not running as root
348     if os.getuid() != 0:
349         print >>sys.stderr, "Error: ovs-bugtool must be run as root"
350         return 1
351
352     output_type = 'tar.bz2'
353     output_fd = -1
354
355     if argv is None:
356         argv = sys.argv
357
358     try:
359         (options, params) = getopt.gnu_getopt(
360             argv, 'sy', ['capabilities', 'silent', 'yestoall', 'entries=',
361                          'output=', 'outfd=', 'all', 'unlimited', 'debug'])
362     except getopt.GetoptError, opterr:
363         print >>sys.stderr, opterr
364         return 2
365
366     try:
367         load_plugins(True)
368     except:
369         pass
370
371     entries = [e for e in caps.keys() if caps[e][CHECKED]]
372
373     for (k, v) in options:
374         if k == '--capabilities':
375             update_capabilities()
376             print_capabilities()
377             return 0
378
379         if k == '--output':
380             if  v in ['tar', 'tar.bz2', 'zip']:
381                 output_type = v
382             else:
383                 print >>sys.stderr, "Invalid output format '%s'" % v
384                 return 2
385
386         # "-s" or "--silent" means suppress output (except for the final
387         # output filename at the end)
388         if k in ['-s', '--silent']:
389             SILENT_MODE = True
390
391         if k == '--entries' and v != '':
392             entries = v.split(',')
393
394         # If the user runs the script with "-y" or "--yestoall" we don't ask
395         # all the really annoying questions.
396         if k in ['-y', '--yestoall']:
397             ANSWER_YES_TO_ALL = True
398
399         if k == '--outfd':
400             output_fd = int(v)
401             try:
402                 old = fcntl.fcntl(output_fd, fcntl.F_GETFD)
403                 fcntl.fcntl(output_fd, fcntl.F_SETFD, old | fcntl.FD_CLOEXEC)
404             except:
405                 print >>sys.stderr, "Invalid output file descriptor", output_fd
406                 return 2
407
408         elif k == '--all':
409             entries = caps.keys()
410         elif k == '--unlimited':
411             unlimited_data = True
412         elif k == '--debug':
413             dbg = True
414             ProcOutput.debug = True
415
416     if len(params) != 1:
417         print >>sys.stderr, "Invalid additional arguments", str(params)
418         return 2
419
420     if output_fd != -1 and output_type != 'tar':
421         print >>sys.stderr, "Option '--outfd' only valid with '--output=tar'"
422         return 2
423
424     if ANSWER_YES_TO_ALL:
425         output("Warning: '--yestoall' argument provided, will not prompt for individual files.")
426
427     output('''
428 This application will collate dmesg output, details of the
429 hardware configuration of your machine, information about the build of
430 openvswitch that you are using, plus, if you allow it, various logs.
431
432 The collated information will be saved as a .%s for archiving or
433 sending to a Technical Support Representative.
434
435 The logs may contain private information, and if you are at all
436 worried about that, you should exit now, or you should explicitly
437 exclude those logs from the archive.
438
439 ''' % output_type)
440
441     # assemble potential data
442
443     file_output(CAP_BOOT_LOADER, [GRUB_CONFIG])
444     cmd_output(CAP_BOOT_LOADER, [LS, '-lR', '/boot'])
445     cmd_output(CAP_BOOT_LOADER, [MD5SUM, BOOT_KERNEL, BOOT_INITRD], label='vmlinuz-initrd.md5sum')
446
447     cmd_output(CAP_DISK_INFO, [FDISK, '-l'])
448     file_output(CAP_DISK_INFO, [PROC_PARTITIONS, PROC_MOUNTS])
449     file_output(CAP_DISK_INFO, [FSTAB])
450     cmd_output(CAP_DISK_INFO, [DF, '-alT'])
451     cmd_output(CAP_DISK_INFO, [DF, '-alTi'])
452     cmd_output(CAP_DISK_INFO, [LS, '-R', '/sys/class/scsi_host'])
453     cmd_output(CAP_DISK_INFO, [LS, '-R', '/sys/class/scsi_disk'])
454     cmd_output(CAP_DISK_INFO, [LS, '-R', '/sys/class/fc_transport'])
455     func_output(CAP_DISK_INFO, 'scsi-hosts', dump_scsi_hosts)
456
457
458     file_output(CAP_HARDWARE_INFO, [PROC_CPUINFO, PROC_MEMINFO, PROC_IOPORTS, PROC_INTERRUPTS])
459     cmd_output(CAP_HARDWARE_INFO, [DMIDECODE])
460     cmd_output(CAP_HARDWARE_INFO, [LSPCI, '-n'])
461     cmd_output(CAP_HARDWARE_INFO, [LSPCI, '-vv'])
462     file_output(CAP_HARDWARE_INFO, [PROC_USB_DEV, PROC_SCSI])
463     cmd_output(CAP_HARDWARE_INFO, [LS, '-lR', '/dev'])
464
465     file_output(CAP_KERNEL_INFO, [PROC_VERSION, PROC_MODULES, PROC_DEVICES,
466                                   PROC_FILESYSTEMS, PROC_CMDLINE])
467     cmd_output(CAP_KERNEL_INFO, [ZCAT, PROC_CONFIG], label='config')
468     cmd_output(CAP_KERNEL_INFO, [SYSCTL, '-A'])
469     tree_output(CAP_KERNEL_INFO, MODPROBE_DIR)
470     func_output(CAP_KERNEL_INFO, 'modinfo', module_info)
471
472     cmd_output(CAP_LOSETUP_A, [LOSETUP, '-a'])
473
474     file_output(CAP_NETWORK_CONFIG, [RESOLV_CONF, NSSWITCH_CONF, HOSTS])
475     file_output(CAP_NETWORK_CONFIG, [NTP_CONF, HOSTS_ALLOW, HOSTS_DENY])
476     file_output(CAP_NETWORK_CONFIG, [OPENVSWITCH_DEFAULT_SWITCH,
477         OPENVSWITCH_DEFAULT_CONTROLLER, OPENVSWITCH_CONF_DB])
478
479     cmd_output(CAP_NETWORK_STATUS, [IFCONFIG, '-a'])
480     cmd_output(CAP_NETWORK_STATUS, [ROUTE, '-n'])
481     cmd_output(CAP_NETWORK_STATUS, [ARP, '-n'])
482     cmd_output(CAP_NETWORK_STATUS, [NETSTAT, '-an'])
483     tree_output(CAP_NETWORK_STATUS, DHCP_LEASE_DIR)
484     cmd_output(CAP_NETWORK_STATUS, [IPTABLES, '-nL'])
485     for p in os.listdir('/sys/class/net/'):
486         try:
487             f = open('/sys/class/net/%s/type' % p, 'r')
488             t = f.readline()
489             f.close()
490             if int(t) == 1:
491                 # ARPHRD_ETHER
492                 cmd_output(CAP_NETWORK_STATUS, [ETHTOOL, p])
493                 cmd_output(CAP_NETWORK_STATUS, [ETHTOOL, '-S', p])
494                 cmd_output(CAP_NETWORK_STATUS, [ETHTOOL, '-k', p])
495                 cmd_output(CAP_NETWORK_STATUS, [ETHTOOL, '-i', p])
496                 cmd_output(CAP_NETWORK_STATUS, [ETHTOOL, '-c', p])
497         except:
498             pass
499     cmd_output(CAP_NETWORK_STATUS, [TC, '-s', 'qdisc'])
500     file_output(CAP_NETWORK_STATUS, [PROC_NET_SOFTNET_STAT])
501     tree_output(CAP_NETWORK_STATUS, OPENVSWITCH_CORE_DIR)
502     if os.path.exists(OPENVSWITCH_VSWITCHD_PID):
503         cmd_output(CAP_NETWORK_STATUS, [OVS_DPCTL, 'show'])
504         for d in dp_list():
505             cmd_output(CAP_NETWORK_STATUS, [OVS_OFCTL, 'show', d])
506             cmd_output(CAP_NETWORK_STATUS, [OVS_OFCTL, 'status', d])
507             cmd_output(CAP_NETWORK_STATUS, [OVS_OFCTL, 'dump-flows', d])
508             cmd_output(CAP_NETWORK_STATUS, [OVS_DPCTL, 'dump-flows', d])
509         try:
510             vspidfile = open(OPENVSWITCH_VSWITCHD_PID)
511             vspid = int(vspidfile.readline().strip())
512             vspidfile.close()
513             for b in bond_list(vspid):
514                 cmd_output(CAP_NETWORK_STATUS,
515                            [OVS_APPCTL, '-t', '/var/run/ovs-vswitchd.%s.ctl' % vspid, '-e' 'bond/show %s' % b],
516                            'ovs-appctl-bond-show-%s.out' % b)
517         except e:
518             pass
519
520     tree_output(CAP_PAM, PAM_DIR)
521
522     cmd_output(CAP_PROCESS_LIST, [PS, 'wwwaxf', '-eo', 'pid,tty,stat,time,nice,psr,pcpu,pmem,nwchan,wchan:25,args'], label='process-tree')
523     func_output(CAP_PROCESS_LIST, 'fd_usage', fd_usage)
524
525     file_output(CAP_SYSTEM_LOGS,
526          [ VAR_LOG_DIR + x for x in
527            [ 'kern.log', 'daemon.log', 'user.log', 'syslog', 'messages',
528              'debug', 'dmesg', 'boot'] +
529            [ f % n for n in range(1, 20) \
530                  for f in ['kern.log.%d', 'kern.log.%d.gz',
531                            'daemon.log.%d', 'daemon.log.%d.gz',
532                            'user.log.%d', 'user.log.%d.gz',
533                            'messages.%d', 'messages.%d.gz']]])
534     if not os.path.exists('/var/log/dmesg') and not os.path.exists('/var/log/boot'):
535         cmd_output(CAP_SYSTEM_LOGS, [DMESG])
536
537
538     tree_output(CAP_X11_LOGS, X11_LOGS_DIR, X11_LOGS_RE)
539     tree_output(CAP_X11_AUTH, X11_AUTH_DIR, X11_AUTH_RE)
540
541
542     try:
543         load_plugins()
544     except:
545         pass
546
547     # permit the user to filter out data
548     for k in sorted(data.keys()):
549         if not ANSWER_YES_TO_ALL and not yes("Include '%s'? [Y/n]: " % k):
550             del data[k]
551
552     # collect selected data now
553     output_ts('Running commands to collect data')
554     collect_data()
555
556     subdir = "bug-report-%s" % time.strftime("%Y%m%d%H%M%S")
557
558     # include inventory
559     data['inventory.xml'] = {'cap': None, 'output': StringIOmtime(make_inventory(data, subdir))}
560
561     # create archive
562     if output_fd == -1 and not os.path.exists(BUG_DIR):
563         try:
564             os.makedirs(BUG_DIR)
565         except:
566             pass
567
568     if output_fd == -1:
569         output_ts('Creating output file')
570
571     if output_type.startswith('tar'):
572         make_tar(subdir, output_type, output_fd)
573     else:
574         make_zip(subdir)
575
576     clean_tapdisk_logs()
577
578     if dbg:
579         print >>sys.stderr, "Category sizes (max, actual):\n"
580         for c in caps.keys():
581             print >>sys.stderr, "    %s (%d, %d)" % (c, caps[c][MAX_SIZE],
582                                                      cap_sizes[c])
583     return 0
584
585 def find_tapdisk_logs():
586     return glob.glob('/var/log/blktap/*.log*')
587
588 def generate_tapdisk_logs():
589     for pid in pidof('tapdisk'):
590         try:
591             os.kill(pid, SIGUSR1)
592             output_ts("Including logs for tapdisk process %d" % pid)
593         except :
594             pass
595     # give processes a second to write their logs
596     time.sleep(1)
597
598 def clean_tapdisk_logs():
599     for filename in find_tapdisk_logs():
600         try:
601             os.remove(filename)
602         except :
603             pass
604
605 def filter_db_pii(str, state):
606     if 'in_secret_table' not in state:
607         state['in_secret_table'] = False
608
609     if str.startswith('<table ') and 'name="secret"' in str:
610         state['in_secret_table'] = True
611     elif str.startswith('</table>'):
612         state['in_secret_table'] = False
613
614     if state['in_secret_table'] and str.startswith("<row"): # match only on DB rows
615         str = re.sub(r'(value=")[^"]+(")', r'\1REMOVED\2', str)
616     return str
617
618 def dump_scsi_hosts(cap):
619     output = ''
620     l = os.listdir('/sys/class/scsi_host')
621     l.sort()
622
623     for h in l:
624         procname = ''
625         try:
626                 f = open('/sys/class/scsi_host/%s/proc_name' % h)
627                 procname = f.readline().strip("\n")
628                 f.close()
629         except:
630                 pass
631         modelname = None
632         try:
633                 f = open('/sys/class/scsi_host/%s/model_name' % h)
634                 modelname = f.readline().strip("\n")
635                 f.close()
636         except:
637                 pass
638
639         output += "%s:\n" %h
640         output += "    %s%s\n" % (procname, modelname and (" -> %s" % modelname) or '')
641
642     return output
643
644 def module_info(cap):
645     output = StringIO.StringIO()
646     modules = open(PROC_MODULES, 'r')
647     procs = []
648
649     for line in modules:
650         module = line.split()[0]
651         procs.append(ProcOutput([MODINFO, module], caps[cap][MAX_TIME], output))
652     modules.close()
653
654     run_procs([procs])
655
656     return output.getvalue()
657
658 def dp_list():
659     output = StringIO.StringIO()
660     procs = [ProcOutput([OVS_DPCTL, 'dump-dps'], caps[CAP_NETWORK_STATUS][MAX_TIME], output)]
661
662     run_procs([procs])
663
664     if not procs[0].timed_out:
665         return output.getvalue().splitlines()
666     return []
667
668 def bond_list(pid):
669     output = StringIO.StringIO()
670     procs = [ProcOutput([OVS_APPCTL, '-t', '/var/run/ovs-vswitchd.%s.ctl' % pid, '-e' 'bond/list'], caps[CAP_NETWORK_STATUS][MAX_TIME], output)]
671
672     run_procs([procs])
673
674     if not procs[0].timed_out:
675         bonds = output.getvalue().splitlines()[1:]
676         return [x.split('\t')[1] for x in bonds]
677     return []
678
679 def fd_usage(cap):
680     output = ''
681     fd_dict = {}
682     for d in [p for p in os.listdir('/proc') if p.isdigit()]:
683         try:
684             fh = open('/proc/'+d+'/cmdline')
685             name = fh.readline()
686             num_fds = len(os.listdir(os.path.join('/proc/'+d+'/fd')))
687             if num_fds > 0:
688                 if not num_fds in fd_dict:
689                     fd_dict[num_fds] = []
690                 fd_dict[num_fds].append(name.replace('\0', ' ').strip())
691         finally:
692             fh.close()
693     keys = fd_dict.keys()
694     keys.sort(lambda a, b: int(b) - int(a))
695     for k in keys:
696         output += "%s: %s\n" % (k, str(fd_dict[k]))
697     return output
698
699 def load_plugins(just_capabilities = False):
700     def getText(nodelist):
701         rc = ""
702         for node in nodelist:
703             if node.nodeType == node.TEXT_NODE:
704                 rc += node.data
705         return rc.encode()
706
707     def getBoolAttr(el, attr, default = False):
708         ret = default
709         val = el.getAttribute(attr).lower()
710         if val in ['true', 'false', 'yes', 'no']:
711             ret = val in ['true', 'yes']
712         return ret
713
714     for dir in [d for d in os.listdir(PLUGIN_DIR) if os.path.isdir(os.path.join(PLUGIN_DIR, d))]:
715         if not caps.has_key(dir):
716             if not os.path.exists("%s/%s.xml" % (PLUGIN_DIR, dir)):
717                 continue
718             xmldoc = parse("%s/%s.xml" % (PLUGIN_DIR, dir))
719             assert xmldoc.documentElement.tagName == "capability"
720
721             pii, min_size, max_size, min_time, max_time, mime = \
722                  PII_MAYBE, -1,-1,-1,-1, MIME_TEXT
723
724             if xmldoc.documentElement.getAttribute("pii") in [PII_NO, PII_YES, PII_MAYBE, PII_IF_CUSTOMIZED]:
725                 pii = xmldoc.documentElement.getAttribute("pii")
726             if xmldoc.documentElement.getAttribute("min_size") != '':
727                 min_size = long(xmldoc.documentElement.getAttribute("min_size"))
728             if xmldoc.documentElement.getAttribute("max_size") != '':
729                 max_size = long(xmldoc.documentElement.getAttribute("max_size"))
730             if xmldoc.documentElement.getAttribute("min_time") != '':
731                 min_time = int(xmldoc.documentElement.getAttribute("min_time"))
732             if xmldoc.documentElement.getAttribute("max_time") != '':
733                 max_time = int(xmldoc.documentElement.getAttribute("max_time"))
734             if xmldoc.documentElement.getAttribute("mime") in [MIME_DATA, MIME_TEXT]:
735                 mime = xmldoc.documentElement.getAttribute("mime")
736             checked = getBoolAttr(xmldoc.documentElement, 'checked', True)
737             hidden = getBoolAttr(xmldoc.documentElement, 'hidden', False)
738
739             cap(dir, pii, min_size, max_size, min_time, max_time, mime, checked, hidden)
740
741         if just_capabilities:
742             continue
743
744         plugdir = os.path.join(PLUGIN_DIR, dir)
745         for file in [f for f in os.listdir(plugdir) if f.endswith('.xml')]:
746             xmldoc = parse(os.path.join(plugdir, file))
747             assert xmldoc.documentElement.tagName == "collect"
748
749             for el in xmldoc.documentElement.getElementsByTagName("*"):
750                 if el.tagName == "files":
751                     file_output(dir, getText(el.childNodes).split())
752                 elif el.tagName == "directory":
753                     pattern = el.getAttribute("pattern")
754                     if pattern == '': pattern = None
755                     negate = getBoolAttr(el, 'negate')
756                     tree_output(dir, getText(el.childNodes), pattern and re.compile(pattern) or None, negate)
757                 elif el.tagName == "command":
758                     label = el.getAttribute("label")
759                     if label == '': label = None
760                     cmd_output(dir, getText(el.childNodes), label)
761
762 def make_tar(subdir, suffix, output_fd):
763     global SILENT_MODE, data
764
765     mode = 'w'
766     if suffix == 'tar.bz2':
767         mode = 'w:bz2'
768     filename = "%s/%s.%s" % (BUG_DIR, subdir, suffix)
769
770     if output_fd == -1:
771         tf = tarfile.open(filename, mode)
772     else:
773         tf = tarfile.open(None, 'w', os.fdopen(output_fd, 'a'))
774
775     try:
776         for (k, v) in data.items():
777             try:
778                 tar_filename = os.path.join(subdir, construct_filename(k, v))
779                 ti = tarfile.TarInfo(tar_filename)
780
781                 ti.uname = 'root'
782                 ti.gname = 'root'
783
784                 if v.has_key('output'):
785                     ti.mtime = v['output'].mtime
786                     ti.size = len(v['output'].getvalue())
787                     v['output'].seek(0)
788                     tf.addfile(ti, v['output'])
789                 elif v.has_key('filename'):
790                     s = os.stat(v['filename'])
791                     ti.mtime = s.st_mtime
792                     ti.size = s.st_size
793                     tf.addfile(ti, file(v['filename']))
794             except:
795                 pass
796     finally:
797         tf.close()
798
799     if output_fd == -1:
800         output ('Writing tarball %s successful.' % filename)
801         if SILENT_MODE:
802             print filename
803
804
805 def make_zip(subdir):
806     global SILENT_MODE, data
807
808     filename = "%s/%s.zip" % (BUG_DIR, subdir)
809     zf = zipfile.ZipFile(filename, 'w', zipfile.ZIP_DEFLATED)
810
811     try:
812         for (k, v) in data.items():
813             try:
814                 dest = os.path.join(subdir, construct_filename(k, v))
815
816                 if v.has_key('output'):
817                     zf.writestr(dest, v['output'].getvalue())
818                 else:
819                     if os.stat(v['filename']).st_size < 50:
820                         compress_type = zipfile.ZIP_STORED
821                     else:
822                         compress_type = zipfile.ZIP_DEFLATED
823                     zf.write(v['filename'], dest, compress_type)
824             except:
825                 pass
826     finally:
827         zf.close()
828
829     output ('Writing archive %s successful.' % filename)
830     if SILENT_MODE:
831         print filename
832
833
834 def make_inventory(inventory, subdir):
835     document = getDOMImplementation().createDocument(
836         None, INVENTORY_XML_ROOT, None)
837
838     # create summary entry
839     s = document.createElement(INVENTORY_XML_SUMMARY)
840     user = os.getenv('SUDO_USER', os.getenv('USER'))
841     if user:
842         s.setAttribute('user', user)
843     s.setAttribute('date', time.strftime('%c'))
844     s.setAttribute('hostname', platform.node())
845     s.setAttribute('uname', ' '.join(platform.uname()))
846     s.setAttribute('uptime', commands.getoutput(UPTIME))
847     document.getElementsByTagName(INVENTORY_XML_ROOT)[0].appendChild(s)
848
849     map(lambda (k, v): inventory_entry(document, subdir, k, v),
850         inventory.items())
851     return document.toprettyxml()
852
853 def inventory_entry(document, subdir, k, v):
854     try:
855         el = document.createElement(INVENTORY_XML_ELEMENT)
856         el.setAttribute('capability', v['cap'])
857         el.setAttribute('filename', os.path.join(subdir, construct_filename(k, v)))
858         el.setAttribute('md5sum', md5sum(v))
859         document.getElementsByTagName(INVENTORY_XML_ROOT)[0].appendChild(el)
860     except:
861         pass
862
863
864 def md5sum(d):
865     m = md5.new()
866     if d.has_key('filename'):
867         f = open(d['filename'])
868         data = f.read(1024)
869         while len(data) > 0:
870             m.update(data)
871             data = f.read(1024)
872         f.close()
873     elif d.has_key('output'):
874         m.update(d['output'].getvalue())
875     return m.hexdigest()
876
877
878 def construct_filename(k, v):
879     if v.has_key('filename'):
880         if v['filename'][0] == '/':
881             return v['filename'][1:]
882         else:
883             return v['filename']
884     s = k.replace(' ', '-')
885     s = s.replace('--', '-')
886     s = s.replace('/', '%')
887     if s.find('.') == -1:
888         s += '.out'
889
890     return s
891
892 def update_capabilities():
893     pass
894
895 def update_cap_size(cap, size):
896     update_cap(cap, MIN_SIZE, size)
897     update_cap(cap, MAX_SIZE, size)
898     update_cap(cap, CHECKED, size > 0)
899
900
901 def update_cap(cap, k, v):
902     global caps
903     l = list(caps[cap])
904     l[k] = v
905     caps[cap] = tuple(l)
906
907
908 def size_of_dir(d, pattern = None, negate = False):
909     if os.path.isdir(d):
910         return size_of_all([os.path.join(d, fn) for fn in os.listdir(d)],
911                            pattern, negate)
912     else:
913         return 0
914
915
916 def size_of_all(files, pattern = None, negate = False):
917     return sum([size_of(f, pattern, negate) for f in files])
918
919
920 def matches(f, pattern, negate):
921     if negate:
922         return not matches(f, pattern, False)
923     else:
924         return pattern is None or pattern.match(f)
925
926
927 def size_of(f, pattern, negate):
928     if os.path.isfile(f) and matches(f, pattern, negate):
929         return os.stat(f)[6]
930     else:
931         return size_of_dir(f, pattern, negate)
932
933
934 def print_capabilities():
935     document = getDOMImplementation().createDocument(
936         "ns", CAP_XML_ROOT, None)
937     map(lambda key: capability(document, key), [k for k in caps.keys() if not caps[k][HIDDEN]])
938     print document.toprettyxml()
939
940 def capability(document, key):
941     c = caps[key]
942     el = document.createElement(CAP_XML_ELEMENT)
943     el.setAttribute('key', c[KEY])
944     el.setAttribute('pii', c[PII])
945     el.setAttribute('min-size', str(c[MIN_SIZE]))
946     el.setAttribute('max-size', str(c[MAX_SIZE]))
947     el.setAttribute('min-time', str(c[MIN_TIME]))
948     el.setAttribute('max-time', str(c[MAX_TIME]))
949     el.setAttribute('content-type', c[MIME])
950     el.setAttribute('default-checked', c[CHECKED] and 'yes' or 'no')
951     document.getElementsByTagName(CAP_XML_ROOT)[0].appendChild(el)
952
953
954 def prettyDict(d):
955     format = '%%-%ds: %%s' % max(map(len, [k for k, _ in d.items()]))
956     return '\n'.join([format % i for i in d.items()]) + '\n'
957
958
959 def yes(prompt):
960     yn = raw_input(prompt)
961
962     return len(yn) == 0 or yn.lower()[0] == 'y'
963
964
965 partition_re = re.compile(r'(.*[0-9]+$)|(^xvd)')
966
967 def disk_list():
968     disks = []
969     try:
970         f = open('/proc/partitions')
971         f.readline()
972         f.readline()
973         for line in f.readlines():
974             (major, minor, blocks, name) = line.split()
975             if int(major) < 254 and not partition_re.match(name):
976                 disks.append(name)
977         f.close()
978     except:
979         pass
980     return disks
981
982
983 class ProcOutput:
984     debug = False
985
986     def __init__(self, command, max_time, inst=None, filter=None):
987         self.command = command
988         self.max_time = max_time
989         self.inst = inst
990         self.running = False
991         self.status = None
992         self.timed_out = False
993         self.failed = False
994         self.timeout = int(time.time()) + self.max_time
995         self.filter = filter
996         self.filter_state = {}
997
998     def __del__(self):
999         self.terminate()
1000
1001     def cmdAsStr(self):
1002         return isinstance(self.command, list) and ' '.join(self.command) or self.command
1003
1004     def run(self):
1005         self.timed_out = False
1006         try:
1007             if ProcOutput.debug:
1008                 output_ts("Starting '%s'" % self.cmdAsStr())
1009             self.proc = Popen(self.command, bufsize=1, stdin=dev_null, stdout=PIPE, stderr=dev_null, shell=isinstance(self.command, str))
1010             old = fcntl.fcntl(self.proc.stdout.fileno(), fcntl.F_GETFD)
1011             fcntl.fcntl(self.proc.stdout.fileno(), fcntl.F_SETFD, old | fcntl.FD_CLOEXEC)
1012             self.running = True
1013             self.failed = False
1014         except:
1015             output_ts("'%s' failed" % self.cmdAsStr())
1016             self.running = False
1017             self.failed = True
1018
1019     def terminate(self):
1020         if self.running:
1021             try:
1022                 os.kill(self.proc.pid, SIGTERM)
1023             except:
1024                 pass
1025             self.proc = None
1026             self.running = False
1027             self.status = SIGTERM
1028
1029     def read_line(self):
1030         assert self.running
1031         line = self.proc.stdout.readline()
1032         if line == '':
1033             # process exited
1034             self.status = self.proc.wait()
1035             self.proc = None
1036             self.running = False
1037         else:
1038             if self.filter:
1039                 line = self.filter(line, self.filter_state)
1040             if self.inst:
1041                 self.inst.write(line)
1042
1043 def run_procs(procs):
1044     while True:
1045         pipes = []
1046         active_procs = []
1047
1048         for pp in procs:
1049             for p in pp:
1050                 if p.running:
1051                     active_procs.append(p)
1052                     pipes.append(p.proc.stdout)
1053                     break
1054                 elif p.status == None and not p.failed and not p.timed_out:
1055                     p.run()
1056                     if p.running:
1057                         active_procs.append(p)
1058                         pipes.append(p.proc.stdout)
1059                         break
1060
1061         if len(pipes) == 0:
1062             # all finished
1063             break
1064
1065         (i, o, x) = select(pipes, [], [], 1.0)
1066         now = int(time.time())
1067
1068         # handle process output
1069         for p in active_procs:
1070             if p.proc.stdout in i:
1071                 p.read_line()
1072
1073             # handle timeout
1074             if p.running and now > p.timeout:
1075                 output_ts("'%s' timed out" % p.cmdAsStr())
1076                 if p.inst:
1077                     p.inst.write("\n** timeout **\n")
1078                 p.timed_out = True
1079                 p.terminate()
1080
1081
1082 def pidof(name):
1083     pids = []
1084
1085     for d in [p for p in os.listdir('/proc') if p.isdigit()]:
1086         try:
1087             if os.path.basename(os.readlink('/proc/%s/exe' % d)) == name:
1088                 pids.append(int(d))
1089         except:
1090             pass
1091
1092     return pids
1093
1094
1095 class StringIOmtime(StringIO.StringIO):
1096     def __init__(self, buf = ''):
1097         StringIO.StringIO.__init__(self, buf)
1098         self.mtime = time.time()
1099
1100     def write(self, s):
1101         StringIO.StringIO.write(self, s)
1102         self.mtime = time.time()
1103
1104
1105 if __name__ == "__main__":
1106     try:
1107         sys.exit(main())
1108     except KeyboardInterrupt:
1109         print "\nInterrupted."
1110         sys.exit(3)