File Manager

X7ROOT File Manager

Current Path: /usr/sbin

📁 ..
📄 ModemManager(1.19 MB)
📄 NetworkManager(2.83 MB)
📄 abrt-auto-reporting(10.98 KB)
📄 abrt-configuration(31.66 KB)
📄 abrt-dbus(31.22 KB)
📄 abrt-harvest-pstoreoops(1.32 KB)
📄 abrt-harvest-vmcore(8.19 KB)
📄 abrt-install-ccpp-hook(2.85 KB)
📄 abrt-server(31.11 KB)
📄 abrtd(31.22 KB)
📄 accept(10.95 KB)
📄 accessdb(11.55 KB)
📄 accton(11.19 KB)
📄 activate-devpay(15.04 KB)
📄 addgnupghome(3.05 KB)
📄 addpart(19.69 KB)
📄 adduser(134.39 KB)
📄 agetty(48.48 KB)
📄 alsa-info(28.09 KB)
📄 alsa-info.sh(28.09 KB)
📄 alsabat-test.sh(4.04 KB)
📄 alsactl(99.15 KB)
📄 alternatives(27.61 KB)
📄 amaddclient(15.02 KB)
📄 amadmin(55.69 KB)
📄 amaespipe(3.29 KB)
📄 amandad(35.36 KB)
📄 amarchiver(15.3 KB)
📄 amcheck(63.25 KB)
📄 amcheckdb(1.79 KB)
📄 amcheckdump(14.25 KB)
📄 amcleanup(6.21 KB)
📄 amcleanupdisk(4.16 KB)
📄 amcrypt(1.02 KB)
📄 amcrypt-ossl(3.12 KB)
📄 amcrypt-ossl-asym(6.8 KB)
📄 amcryptsimple(4.55 KB)
📄 amdevcheck(4.51 KB)
📄 amdump(10.46 KB)
📄 amfetchdump(26.87 KB)
📄 amflush(27.13 KB)
📄 amgetconf(12.24 KB)
📄 amgpgcrypt(2.68 KB)
📄 amlabel(11.22 KB)
📄 amoverview(6.42 KB)
📄 amplot(5.94 KB)
📄 amreport(17.65 KB)
📄 amrestore(12.7 KB)
📄 amrmtape(8.91 KB)
📄 amserverconfig(20.99 KB)
📄 amservice(19.16 KB)
📄 amstatus(49.23 KB)
📄 amtape(19.47 KB)
📄 amtapetype(22.56 KB)
📄 amtoc(7.54 KB)
📄 amvault(29.59 KB)
📄 anaconda(54.99 KB)
📄 anacron(35.52 KB)
📄 apachectl(4.19 KB)
📄 applygnupgdefaults(2.21 KB)
📄 arp(63.98 KB)
📄 arpd(52.98 KB)
📄 arping(23.19 KB)
📄 atd(27.17 KB)
📄 atrun(67 B)
📄 attrd_updater(16.52 KB)
📄 audispd(39.75 KB)
📄 auditctl(39.56 KB)
📄 auditd(125.65 KB)
📄 augenrules(3.7 KB)
📄 aureport(105.39 KB)
📄 ausearch(109.8 KB)
📄 authconfig(43.49 KB)
📄 authconfig-tui(43.49 KB)
📄 autrace(15.49 KB)
📄 avahi-daemon(133.04 KB)
📄 avcstat(11.25 KB)
📄 badblocks(27.69 KB)
📄 biosdecode(24.15 KB)
📄 biosdevname(36.57 KB)
📄 blkdeactivate(15.97 KB)
📄 blkdiscard(23.84 KB)
📄 blkid(77.92 KB)
📄 blkmapd(43.81 KB)
📄 blockdev(32.2 KB)
📄 brctl(32.13 KB)
📄 bridge(77.61 KB)
📄 btrfs(690.59 KB)
📄 btrfs-convert(378.62 KB)
📄 btrfs-debug-tree(354.23 KB)
📄 btrfs-find-root(346.22 KB)
📄 btrfs-image(374.63 KB)
📄 btrfs-map-logical(350.27 KB)
📄 btrfs-select-super(346.2 KB)
📄 btrfs-zero-log(346.2 KB)
📄 btrfsck(690.59 KB)
📄 btrfstune(350.24 KB)
📄 build-locale-archive(860.52 KB)
📄 cacertdir_rehash(644 B)
📄 cache_check(1.23 MB)
📄 cache_dump(1.23 MB)
📄 cache_metadata_size(1.23 MB)
📄 cache_repair(1.23 MB)
📄 cache_restore(1.23 MB)
📄 cache_writeback(1.23 MB)
📄 capsh(19.43 KB)
📄 cbq(32.73 KB)
📄 cfdisk(71.37 KB)
📄 cgdisk(176.87 KB)
📄 chat(27.3 KB)
📄 chcpu(23.7 KB)
📄 chgpasswd(64.1 KB)
📄 chkconfig(40.22 KB)
📄 chpasswd(55.88 KB)
📄 chronyd(263.08 KB)
📄 chroot(32.48 KB)
📄 cibadmin(27.2 KB)
📄 cifs.idmap(15.07 KB)
📄 cifs.upcall(31.23 KB)
📄 clamd(208.18 KB)
📄 clamonacc(200.67 KB)
📄 clock(48.44 KB)
📄 clockdiff(19.04 KB)
📄 consoletype(6.95 KB)
📄 convertquota(70.88 KB)
📄 corosync(284.76 KB)
📄 corosync-cfgtool(14.97 KB)
📄 corosync-cmapctl(23.31 KB)
📄 corosync-cpgtool(11 KB)
📄 corosync-keygen(11.12 KB)
📄 corosync-notifyd(33.63 KB)
📄 corosync-quorumtool(23.16 KB)
📄 cracklib-check(7.04 KB)
📄 cracklib-format(246 B)
📄 cracklib-packer(11.06 KB)
📄 cracklib-unpacker(7.02 KB)
📄 crda(11.34 KB)
📄 create-cracklib-dict(990 B)
📄 crm_attribute(21.51 KB)
📄 crm_diff(16.73 KB)
📄 crm_error(11.48 KB)
📄 crm_failcount(6.56 KB)
📄 crm_master(2.37 KB)
📄 crm_mon(84.05 KB)
📄 crm_node(24.93 KB)
📄 crm_report(15.9 KB)
📄 crm_resource(112.09 KB)
📄 crm_shadow(21.02 KB)
📄 crm_simulate(50.68 KB)
📄 crm_standby(3.33 KB)
📄 crm_ticket(31.15 KB)
📄 crm_verify(16.38 KB)
📄 crmadmin(21.1 KB)
📄 crond(68.48 KB)
📄 cryptsetup(85.41 KB)
📄 ctrlaltdel(11.2 KB)
📄 ctstat(20.09 KB)
📄 cups-browsed(136.9 KB)
📄 cups-genppd.5.2(56.05 KB)
📄 cups-genppdupdate(34.2 KB)
📄 cupsaccept(10.95 KB)
📄 cupsaddsmb(10.98 KB)
📄 cupsctl(14.97 KB)
📄 cupsd(427.17 KB)
📄 cupsdisable(10.95 KB)
📄 cupsenable(10.95 KB)
📄 cupsfilter(27.37 KB)
📄 cupsreject(10.95 KB)
📄 dcbtool(60.03 KB)
📄 ddns-confgen(19.44 KB)
📄 debugfs(120.65 KB)
📄 delpart(19.69 KB)
📄 depmod(143.24 KB)
📄 devlink(64.72 KB)
📄 dhclient(414.34 KB)
📄 dhclient-script(30.38 KB)
📄 dm_dso_reg_tool(11.29 KB)
📄 dmevent_tool(11.29 KB)
📄 dmeventd(39.56 KB)
📄 dmfilemapd(19.16 KB)
📄 dmidecode(120.2 KB)
📄 dmraid(22.1 KB)
📄 dmraid.static(22.1 KB)
📄 dmsetup(149.2 KB)
📄 dmstats(149.2 KB)
📄 dnsmasq(340.79 KB)
📄 dnssec-checkds(922 B)
📄 dnssec-coverage(924 B)
📄 dnssec-dsfromkey(56.6 KB)
📄 dnssec-importkey(52.59 KB)
📄 dnssec-keyfromlabel(60.52 KB)
📄 dnssec-keygen(64.55 KB)
📄 dnssec-keymgr(920 B)
📄 dnssec-revoke(48.46 KB)
📄 dnssec-settime(56.52 KB)
📄 dnssec-signzone(105.71 KB)
📄 dnssec-verify(48.47 KB)
📄 dosfsck(56.24 KB)
📄 dosfslabel(52.23 KB)
📄 dovecot(88.1 KB)
📄 dracut(55.83 KB)
📄 dump-acct(19.63 KB)
📄 dump-utmp(15.47 KB)
📄 dumpe2fs(23.62 KB)
📄 e2freefrag(11.15 KB)
📄 e2fsck(250.55 KB)
📄 e2image(27.85 KB)
📄 e2label(69.41 KB)
📄 e2undo(11.32 KB)
📄 e4defrag(23.55 KB)
📄 eapol_test(1.77 MB)
📄 ebtables(6.85 KB)
📄 ebtables-restore(10.88 KB)
📄 ebtables-save(851 B)
📄 editmap.sendmail(95.55 KB)
📄 edquota(83.09 KB)
📄 era_check(1.23 MB)
📄 era_dump(1.23 MB)
📄 era_invalidate(1.23 MB)
📄 era_restore(1.23 MB)
📄 ether-wake(73.26 KB)
📄 ethtool(293.87 KB)
📄 eventlogadm(39.17 KB)
📄 exportfs(76.91 KB)
📄 faillock(15.02 KB)
📄 fancontrol(14.01 KB)
📄 fatlabel(52.23 KB)
📄 fcgistarter(11 KB)
📄 fcgiwrap(19.8 KB)
📄 fcnsq(15.13 KB)
📄 fcoeadm(48.52 KB)
📄 fcoemon(69.21 KB)
📄 fcping(31.52 KB)
📄 fcrls(19.16 KB)
📄 fdformat(11.27 KB)
📄 fdisk(195.8 KB)
📄 fence_amt_ws(8.77 KB)
📄 fence_apc(7.49 KB)
📄 fence_apc_snmp(6.28 KB)
📄 fence_bladecenter(3.09 KB)
📄 fence_brocade(2.45 KB)
📄 fence_cisco_mds(2.62 KB)
📄 fence_cisco_ucs(5.53 KB)
📄 fence_compute(16.43 KB)
📄 fence_drac5(5 KB)
📄 fence_eaton_snmp(6.66 KB)
📄 fence_emerson(1.85 KB)
📄 fence_eps(3.52 KB)
📄 fence_evacuate(13 KB)
📄 fence_heuristics_ping(5.78 KB)
📄 fence_hpblade(3.66 KB)
📄 fence_ibmblade(1.96 KB)
📄 fence_idrac(6.5 KB)
📄 fence_ifmib(3.18 KB)
📄 fence_ilo(4.42 KB)
📄 fence_ilo2(4.42 KB)
📄 fence_ilo3(6.5 KB)
📄 fence_ilo3_ssh(2.03 KB)
📄 fence_ilo4(6.5 KB)
📄 fence_ilo4_ssh(2.03 KB)
📄 fence_ilo5(6.5 KB)
📄 fence_ilo5_ssh(2.03 KB)
📄 fence_ilo_moonshot(1.56 KB)
📄 fence_ilo_mp(1.29 KB)
📄 fence_ilo_ssh(2.03 KB)
📄 fence_imm(6.5 KB)
📄 fence_intelmodular(2.43 KB)
📄 fence_ipdu(3.86 KB)
📄 fence_ipmilan(6.5 KB)
📄 fence_kdump(23.4 KB)
📄 fence_mpath(9.98 KB)
📄 fence_redfish(5.34 KB)
📄 fence_rhevm(6.4 KB)
📄 fence_rsa(1.76 KB)
📄 fence_rsb(2.22 KB)
📄 fence_sbd(11.11 KB)
📄 fence_scsi(15.95 KB)
📄 fence_virt(57.66 KB)
📄 fence_vmware_rest(5.61 KB)
📄 fence_vmware_soap(8.44 KB)
📄 fence_wti(7.53 KB)
📄 fence_xvm(57.66 KB)
📄 filefrag(15.23 KB)
📄 findfs(11.2 KB)
📄 fipvlan(40.16 KB)
📄 firewalld(6.87 KB)
📄 firstboot(6.45 KB)
📄 fixfiles(11.03 KB)
📄 fixparts(61.65 KB)
📄 fsadm(23.97 KB)
📄 fsck(32.12 KB)
📄 fsck.btrfs(1.16 KB)
📄 fsck.cramfs(19.57 KB)
📄 fsck.ext2(250.55 KB)
📄 fsck.ext3(250.55 KB)
📄 fsck.ext4(250.55 KB)
📄 fsck.fat(56.24 KB)
📄 fsck.minix(73.32 KB)
📄 fsck.msdos(56.24 KB)
📄 fsck.vfat(56.24 KB)
📄 fsck.xfs(433 B)
📄 fsfreeze(11.23 KB)
📄 fstrim(40.59 KB)
📄 ftpscrub(16.47 KB)
📄 ftpshut(10.98 KB)
📄 fuser(32.34 KB)
📄 fxload(19.26 KB)
📄 gdisk(184.49 KB)
📄 gdm(430.45 KB)
📄 genhomedircon(23.77 KB)
📄 genhostid(6.94 KB)
📄 genl(52.81 KB)
📄 genl-ctrl-list(11.27 KB)
📄 genrandom(11.16 KB)
📄 getcap(11.13 KB)
📄 getenforce(7.01 KB)
📄 getpcaps(7.07 KB)
📄 getsebool(11.13 KB)
📄 glibc_post_upgrade.i686(700.2 KB)
📄 glibc_post_upgrade.x86_64(772.05 KB)
📄 gluster(465.84 KB)
📄 groupadd(85.65 KB)
📄 groupdel(77.38 KB)
📄 groupmems(55.97 KB)
📄 groupmod(85.66 KB)
📄 grpck(59.93 KB)
📄 grpconv(51.73 KB)
📄 grpunconv(51.73 KB)
📄 grub2-bios-setup(1.03 MB)
📄 grub2-get-kernel-settings(2.08 KB)
📄 grub2-install(1.28 MB)
📄 grub2-macbless(1.01 MB)
📄 grub2-mkconfig(7.63 KB)
📄 grub2-ofpathname(225.54 KB)
📄 grub2-probe(1.03 MB)
📄 grub2-reboot(4 KB)
📄 grub2-rpm-sort(258.52 KB)
📄 grub2-set-default(3.46 KB)
📄 grub2-setpassword(2.96 KB)
📄 grub2-sparc64-setup(1.03 MB)
📄 grubby(71.27 KB)
📄 gssproxy(130.64 KB)
📄 halt(704.8 KB)
📄 handle-sshpw(2.35 KB)
📄 hardlink(15.29 KB)
📄 htcacheclean(31.16 KB)
📄 httpd(511.44 KB)
📄 hwclock(48.44 KB)
📄 hwloc-dump-hwdata(15.32 KB)
📄 hypervfcopyd(11.18 KB)
📄 hypervkvpd(27.38 KB)
📄 hypervvssd(15.23 KB)
📄 iconvconfig(22.15 KB)
📄 iconvconfig.i686(21.44 KB)
📄 iconvconfig.x86_64(22.15 KB)
📄 ifcfg(2.99 KB)
📄 ifconfig(80.05 KB)
📄 ifdown(1.61 KB)
📄 ifenslave(19.74 KB)
📄 ifstat(40.6 KB)
📄 ifup(4.89 KB)
📄 in.proftpd(988.23 KB)
📄 init(1.56 MB)
📄 insmod(143.24 KB)
📄 install-info(110.42 KB)
📄 installkernel(2.69 KB)
📄 intel-microcode2ucode(11.1 KB)
📄 ip(459.59 KB)
📄 ip6tables(91.52 KB)
📄 ip6tables-restore(91.52 KB)
📄 ip6tables-save(91.52 KB)
📄 ipmaddr(19.33 KB)
📄 ipmievd(488.98 KB)
📄 iprconfig(394.37 KB)
📄 iprdbg(135.94 KB)
📄 iprdump(123.67 KB)
📄 iprinit(123.64 KB)
📄 iprsos(2.18 KB)
📄 iprupdate(123.64 KB)
📄 ipsec(14.96 KB)
📄 ipset(7.02 KB)
📄 iptables(91.52 KB)
📄 iptables-restore(91.52 KB)
📄 iptables-save(91.52 KB)
📄 iptunnel(23.33 KB)
📄 irqbalance(48.5 KB)
📄 isadump(15.02 KB)
📄 isaset(10.98 KB)
📄 isc-hmac-fixup(11.2 KB)
📄 iscsi-iname(11.01 KB)
📄 iscsiadm(794.39 KB)
📄 iscsid(819.81 KB)
📄 iscsistart(361.05 KB)
📄 iscsiuio(182.09 KB)
📄 iso8601(16.04 KB)
📄 iw(157.97 KB)
📄 jk_check(11.2 KB)
📄 jk_chrootlaunch(20.77 KB)
📄 jk_chrootsh(32.73 KB)
📄 jk_cp(4.12 KB)
📄 jk_init(9.68 KB)
📄 jk_jailuser(11.81 KB)
📄 jk_list(4.93 KB)
📄 jk_lsh(24.66 KB)
📄 jk_socketd(29.05 KB)
📄 jk_update(9.11 KB)
📄 kexec(166.06 KB)
📄 key.dns_resolver(19.45 KB)
📄 killall5(23.17 KB)
📄 kpartx(39.47 KB)
📄 kpatch(14.53 KB)
📄 ksmtuned(3.36 KB)
📄 lchage(15.41 KB)
📄 ldattach(27.93 KB)
📄 ldconfig(952.08 KB)
📄 ledctl(61.97 KB)
📄 ledmon(62.15 KB)
📄 lgroupadd(11.28 KB)
📄 lgroupdel(11.26 KB)
📄 lgroupmod(15.44 KB)
📄 libvirtd(506.11 KB)
📄 lid(15.4 KB)
📄 liveinst(5.83 KB)
📄 lldpad(402.72 KB)
📄 lldptool(96.02 KB)
📄 lnewusers(15.46 KB)
📄 lnstat(20.09 KB)
📄 load_policy(10.97 KB)
📄 loaderinfo(40.91 KB)
📄 lockdev(10.95 KB)
📄 logrotate(68.61 KB)
📄 logsave(11.27 KB)
📄 losetup(82.45 KB)
📄 lpadmin(27.09 KB)
📄 lpasswd(15.5 KB)
📄 lpc(15.07 KB)
📄 lpc.cups(15.07 KB)
📄 lpinfo(14.96 KB)
📄 lpmove(10.98 KB)
📄 lsmod(143.24 KB)
📄 lsof(150.57 KB)
📄 lspci(73.67 KB)
📄 luseradd(15.38 KB)
📄 luserdel(11.3 KB)
📄 lusermod(19.43 KB)
📄 lvchange(2.15 MB)
📄 lvconvert(2.15 MB)
📄 lvcreate(2.15 MB)
📄 lvdisplay(2.15 MB)
📄 lvextend(2.15 MB)
📄 lvm(2.15 MB)
📄 lvmconf(12.55 KB)
📄 lvmconfig(2.15 MB)
📄 lvmdiskscan(2.15 MB)
📄 lvmdump(10.07 KB)
📄 lvmetad(71.66 KB)
📄 lvmpolld(64.07 KB)
📄 lvmsadc(2.15 MB)
📄 lvmsar(2.15 MB)
📄 lvreduce(2.15 MB)
📄 lvremove(2.15 MB)
📄 lvrename(2.15 MB)
📄 lvresize(2.15 MB)
📄 lvs(2.15 MB)
📄 lvscan(2.15 MB)
📄 lwresd(768.03 KB)
📄 mailstats(79.11 KB)
📄 makedumpfile(376.52 KB)
📄 makemap.sendmail(95.63 KB)
📄 matchpathcon(11.19 KB)
📄 mcelog(152.67 KB)
📄 mdadm(593.45 KB)
📄 mdmon(331.55 KB)
📄 mii-diag(20.08 KB)
📄 mii-tool(19.51 KB)
📄 milter-greylist(253.3 KB)
📄 mkdict(246 B)
📄 mkdosfs(28.05 KB)
📄 mkdumprd(13.99 KB)
📄 mke2fs(94.08 KB)
📄 mkfs(11.25 KB)
📄 mkfs.btrfs(366.45 KB)
📄 mkfs.cramfs(36.16 KB)
📄 mkfs.ext2(94.08 KB)
📄 mkfs.ext3(94.08 KB)
📄 mkfs.ext4(94.08 KB)
📄 mkfs.fat(28.05 KB)
📄 mkfs.minix(36.27 KB)
📄 mkfs.msdos(28.05 KB)
📄 mkfs.vfat(28.05 KB)
📄 mkfs.xfs(359.8 KB)
📄 mkhomedir_helper(19.05 KB)
📄 mklost+found(11.11 KB)
📄 mkswap(69.64 KB)
📄 modinfo(143.24 KB)
📄 modprobe(143.24 KB)
📄 mount.cifs(40.05 KB)
📄 mount.fuse(11.1 KB)
📄 mount.nfs(114.68 KB)
📄 mount.nfs4(114.68 KB)
📄 mountstats(40.59 KB)
📄 mpathconf(10.6 KB)
📄 mpathpersist(27.91 KB)
📄 mtr(83.18 KB)
📄 mtx(49.87 KB)
📄 multipath(22.99 KB)
📄 multipathd(84.37 KB)
📄 named(768.03 KB)
📄 named-checkconf(32.25 KB)
📄 named-checkzone(32.06 KB)
📄 named-compilezone(32.06 KB)
📄 named-journalprint(11.13 KB)
📄 nameif(15.32 KB)
📄 netreport(10.96 KB)
📄 netscsid(19.55 KB)
📄 new-kernel-pkg(24.96 KB)
📄 newusers(93.45 KB)
📄 nfsdcltrack(40.11 KB)
📄 nfsidmap(19.32 KB)
📄 nfsiostat(23.64 KB)
📄 nfsstat(29.84 KB)
📄 nl-class-add(11.7 KB)
📄 nl-class-delete(11.55 KB)
📄 nl-class-list(11.48 KB)
📄 nl-classid-lookup(11.29 KB)
📄 nl-cls-add(11.76 KB)
📄 nl-cls-delete(11.68 KB)
📄 nl-cls-list(11.58 KB)
📄 nl-link-list(11.52 KB)
📄 nl-pktloc-lookup(11.36 KB)
📄 nl-qdisc-add(11.6 KB)
📄 nl-qdisc-delete(11.54 KB)
📄 nl-qdisc-list(11.63 KB)
📄 nmbd(249.07 KB)
📄 nologin(7.01 KB)
📄 nsec3hash(11.13 KB)
📄 nstat(23.88 KB)
📄 ntpdate(107.58 KB)
📄 ntsysv(36.24 KB)
📄 ocft(22.04 KB)
📄 oddjobd(72.11 KB)
📄 opendkim(158.3 KB)
📄 opendkim-default-keygen(1.4 KB)
📄 opendkim-genkey(6.29 KB)
📄 opendkim-genzone(66.68 KB)
📄 opendkim-reportstats(14.16 KB)
📄 opendkim-testkey(70.98 KB)
📄 opendkim-testmsg(15.27 KB)
📄 osd_login(2.55 KB)
📄 ownership(15.04 KB)
📄 pacemakerd(59.74 KB)
📄 packer(11.06 KB)
📄 pam_console_apply(39.69 KB)
📄 pam_tally2(15.05 KB)
📄 pam_timestamp_check(10.97 KB)
📄 paperconfig(4.07 KB)
📄 parted(77.22 KB)
📄 partprobe(11.23 KB)
📄 partx(86.55 KB)
📄 pcs(292 B)
📄 pdata_tools(1.23 MB)
📄 pethtool(8.94 KB)
📄 php-fpm(5.03 MB)
📄 pidof(23.17 KB)
📄 pifconfig(3.03 KB)
📄 ping6(64.63 KB)
📄 pivot_root(11.19 KB)
📄 plipconfig(11.06 KB)
📄 pluginviewer(15.23 KB)
📄 plymouth-set-default-theme(6.21 KB)
📄 plymouthd(84.22 KB)
📄 pm-hibernate(2.86 KB)
📄 pm-powersave(2.09 KB)
📄 pm-suspend(2.86 KB)
📄 pm-suspend-hybrid(2.86 KB)
📄 pm-utils-bugreport-info.sh(1.47 KB)
📄 portrelease(15.02 KB)
📄 portreserve(15.02 KB)
📄 postalias(253.87 KB)
📄 postcat(136.08 KB)
📄 postconf(363.19 KB)
📄 postdrop(213.44 KB)
📄 postfix(119.17 KB)
📄 postgrey(37.94 KB)
📄 postgreyreport(23.8 KB)
📄 postkick(131.43 KB)
📄 postlock(127.38 KB)
📄 postlog(119.38 KB)
📄 postmap(257.69 KB)
📄 postmulti(135.89 KB)
📄 postqueue(257.94 KB)
📄 postsuper(139.95 KB)
📄 poweroff(704.8 KB)
📄 ppp-watch(23.2 KB)
📄 pppd(372.98 KB)
📄 pppdump(52.77 KB)
📄 pppoe-discovery(18.04 KB)
📄 pppstats(14.99 KB)
📄 praliases(95.64 KB)
📄 proftpd(988.23 KB)
📄 pvchange(2.15 MB)
📄 pvck(2.15 MB)
📄 pvcreate(2.15 MB)
📄 pvdisplay(2.15 MB)
📄 pvmove(2.15 MB)
📄 pvremove(2.15 MB)
📄 pvresize(2.15 MB)
📄 pvs(2.15 MB)
📄 pvscan(2.15 MB)
📄 pwck(51.71 KB)
📄 pwconv(47.57 KB)
📄 pwhistory_helper(15.44 KB)
📄 pwmconfig(22.92 KB)
📄 pwunconv(47.59 KB)
📄 qb-blackbox(7.02 KB)
📄 quot(70.66 KB)
📄 quotacheck(107.29 KB)
📄 quotaoff(75.03 KB)
📄 quotaon(75.03 KB)
📄 quotastats(14.03 KB)
📄 radvd(101.59 KB)
📄 radvdump(23.64 KB)
📄 raid-check(3.7 KB)
📄 ras-mc-ctl(38.48 KB)
📄 rasdaemon(185.11 KB)
📄 rdisc(23.17 KB)
📄 rdma(73.42 KB)
📄 rdma-ndd(15.36 KB)
📄 readprofile(15.46 KB)
📄 realm(138.77 KB)
📄 reboot(704.8 KB)
📄 regdbdump(7.12 KB)
📄 reject(10.95 KB)
📄 repquota(75.16 KB)
📄 request-key(19.41 KB)
📄 resize2fs(48.41 KB)
📄 resizepart(32.36 KB)
📄 restorecon(27.16 KB)
📄 rfkill(11.29 KB)
📄 rmmod(143.24 KB)
📄 rndc(35.88 KB)
📄 rndc-confgen(19.44 KB)
📄 rngd(42.39 KB)
📄 rotatelogs(19.04 KB)
📄 route(66.6 KB)
📄 routef(173 B)
📄 routel(1.59 KB)
📄 rpc.gssd(88.73 KB)
📄 rpc.idmapd(48.13 KB)
📄 rpc.mountd(128.91 KB)
📄 rpc.nfsd(40.2 KB)
📄 rpc.rquotad(78.95 KB)
📄 rpc.statd(97.59 KB)
📄 rpcbind(60.07 KB)
📄 rpcdebug(18.05 KB)
📄 rpcinfo(27.3 KB)
📄 rsyslogd(648.45 KB)
📄 rtacct(41.93 KB)
📄 rtcwake(31.96 KB)
📄 rtkitctl(10.88 KB)
📄 rtmon(48.67 KB)
📄 rtpr(37 B)
📄 rtstat(20.09 KB)
📄 runlevel(704.8 KB)
📄 runuser(32.21 KB)
📄 sa(36.77 KB)
📄 safe_finger(11.08 KB)
📄 saned(47.41 KB)
📄 sasl2-shared-mechlist(10.98 KB)
📄 saslauthd(92.59 KB)
📄 sasldblistusers2(19.26 KB)
📄 saslpasswd2(15.09 KB)
📄 scsieject(41.07 KB)
📄 scsitape(45.38 KB)
📄 sedispatch(15.56 KB)
📄 sefcontext_compile(60.53 KB)
📄 selabel_digest(11.17 KB)
📄 selabel_lookup(11.14 KB)
📄 selabel_lookup_best_match(11.16 KB)
📄 selabel_partial_match(11.09 KB)
📄 selinux_restorecon(15.21 KB)
📄 selinuxconlist(11.1 KB)
📄 selinuxdefcon(11.12 KB)
📄 selinuxenabled(6.98 KB)
📄 selinuxexeccon(7.09 KB)
📄 semanage(42.76 KB)
📄 semodule(23.77 KB)
📄 sendmail(242.11 KB)
📄 sendmail.postfix(242.11 KB)
📄 sendmail.sendmail(817.3 KB)
📄 sensors-detect(207.11 KB)
📄 service(3.17 KB)
📄 sestatus(15.02 KB)
📄 setcap(11.13 KB)
📄 setenforce(7.05 KB)
📄 setfiles(27.16 KB)
📄 setpci(23.4 KB)
📄 setquota(83.16 KB)
📄 setregdomain(1.7 KB)
📄 setroubleshootd(3.22 KB)
📄 setsebool(14.99 KB)
📄 setup(15.38 KB)
📄 sfdisk(83.25 KB)
📄 sgdisk(168.33 KB)
📄 sgpio(15.63 KB)
📄 showmount(19.56 KB)
📄 shutdown(704.8 KB)
📄 skdump(15.2 KB)
📄 sktest(6.98 KB)
📄 slattach(42.4 KB)
📄 sln(743.78 KB)
📄 sm-notify(68.43 KB)
📄 smartctl(864.48 KB)
📄 smartd(670.63 KB)
📄 smbd(91.84 KB)
📄 smrsh(74.97 KB)
📄 smtp-sink(90.91 KB)
📄 smtp-source(77.79 KB)
📄 sosreport(561 B)
📄 spice-vdagentd(43.73 KB)
📄 ss(128.44 KB)
📄 sshd(832.9 KB)
📄 sshd-keygen(3.53 KB)
📄 start-statd(842 B)
📄 stinit(35.52 KB)
📄 stonith_admin(25.69 KB)
📄 suexec(15.01 KB)
📄 sulogin(40.53 KB)
📄 sushell(67 B)
📄 swaplabel(15.31 KB)
📄 swapoff(15.53 KB)
📄 swapon(53.29 KB)
📄 switch_root(15.35 KB)
📄 sys-unconfig(184 B)
📄 sysctl(23.57 KB)
📄 tapeinfo(45 KB)
📄 tc(384.66 KB)
📄 tcpd(36.62 KB)
📄 tcpdmatch(40.83 KB)
📄 tcpdump(920.16 KB)
📄 tcpslice(23.64 KB)
📄 tcsd(300.27 KB)
📄 telinit(704.8 KB)
📄 testsaslauthd(15.09 KB)
📄 thin_check(1.23 MB)
📄 thin_delta(1.23 MB)
📄 thin_dump(1.23 MB)
📄 thin_ls(1.23 MB)
📄 thin_metadata_size(1.23 MB)
📄 thin_repair(1.23 MB)
📄 thin_restore(1.23 MB)
📄 thin_rmap(1.23 MB)
📄 thin_trim(1.23 MB)
📄 tracepath(15.05 KB)
📄 tracepath6(15.05 KB)
📄 try-from(23.47 KB)
📄 tsig-keygen(19.44 KB)
📄 tune2fs(69.41 KB)
📄 tuned(3.29 KB)
📄 tuned-adm(5.22 KB)
📄 udevadm(414.27 KB)
📄 umount.nfs(114.68 KB)
📄 umount.nfs4(114.68 KB)
📄 umount.udisks2(10.98 KB)
📄 unbound-anchor(55.62 KB)
📄 unix_chkpwd(35.42 KB)
📄 unix_update(35.42 KB)
📄 update-alternatives(27.61 KB)
📄 update-pciids(1.71 KB)
📄 update-smart-drivedb(14.34 KB)
📄 usb_modeswitch(57.61 KB)
📄 usb_modeswitch_dispatcher(236.66 KB)
📄 usbmuxd(69.72 KB)
📄 useradd(134.39 KB)
📄 userdel(93.5 KB)
📄 userhelper(39.38 KB)
📄 usermod(130.33 KB)
📄 usernetctl(11.03 KB)
📄 vdptool(48.96 KB)
📄 vgcfgbackup(2.15 MB)
📄 vgcfgrestore(2.15 MB)
📄 vgchange(2.15 MB)
📄 vgck(2.15 MB)
📄 vgconvert(2.15 MB)
📄 vgcreate(2.15 MB)
📄 vgdisplay(2.15 MB)
📄 vgexport(2.15 MB)
📄 vgextend(2.15 MB)
📄 vgimport(2.15 MB)
📄 vgimportclone(2.15 MB)
📄 vgmerge(2.15 MB)
📄 vgmknodes(2.15 MB)
📄 vgreduce(2.15 MB)
📄 vgremove(2.15 MB)
📄 vgrename(2.15 MB)
📄 vgs(2.15 MB)
📄 vgscan(2.15 MB)
📄 vgsplit(2.15 MB)
📄 vigr(62.54 KB)
📄 vipw(62.54 KB)
📄 virt-what(11.57 KB)
📄 virtlockd(723.38 KB)
📄 virtlogd(719.13 KB)
📄 virtualmin(1.3 KB)
📄 visudo(200.89 KB)
📄 vmcore-dmesg(19.28 KB)
📄 vpddecode(15.33 KB)
📄 weak-modules(31.9 KB)
📄 wipefs(28.05 KB)
📄 wpa_cli(128.06 KB)
📄 wpa_passphrase(56.79 KB)
📄 wpa_supplicant(1.93 MB)
📄 xfs_admin(1.35 KB)
📄 xfs_bmap(638 B)
📄 xfs_copy(339.33 KB)
📄 xfs_db(576.38 KB)
📄 xfs_estimate(11.16 KB)
📄 xfs_freeze(767 B)
📄 xfs_fsr(31.83 KB)
📄 xfs_growfs(327.2 KB)
📄 xfs_info(472 B)
📄 xfs_io(122.68 KB)
📄 xfs_logprint(355.81 KB)
📄 xfs_mdrestore(314.81 KB)
📄 xfs_metadump(747 B)
📄 xfs_mkfile(1007 B)
📄 xfs_ncheck(650 B)
📄 xfs_quota(84.88 KB)
📄 xfs_repair(563.2 KB)
📄 xfs_rtcp(15.25 KB)
📄 xfsdump(291.69 KB)
📄 xfsinvutil(61.87 KB)
📄 xfsrestore(353.2 KB)
📄 xqmstats(14.03 KB)
📄 xtables-multi(91.52 KB)
📄 yum-complete-transaction(9.22 KB)
📄 yumdb(8.67 KB)
📄 zdump(14.02 KB)
📄 zic(50.02 KB)
📄 zramctl(82.23 KB)

Editing: ras-mc-ctl

#!/usr/bin/perl -w

#******************************************************************************
# Copyright (c) 2013 Mauro Carvalho Chehab <mchehab@redhat.com>
#
# This tool is a modification of the edac-ctl, written as part of the
# edac-utils:
#  Copyright (C) 2003-2006 The Regents of the University of California.
#  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
#  Written by Mark Grondona <mgrondona@llnl.gov>
#  UCRL-CODE-230739.
#
#  This version uses the new EDAC v 3.0.0 and upper API, with adds proper
#  representation for the memory controllers found on Intel designs after
#  2002. It requires Linux Kernel 3.5 or upper to work.
#
#  This is free software; you can redistribute it and/or modify it
#  under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
#
#  This is distributed in the hope that it will be useful, but WITHOUT
#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
#  for more details.
#
#  You should have received a copy of the GNU General Public License along
#  with this program; if not, write to the Free Software Foundation, Inc.,
#  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
#****************************************************************************/

use strict;
use File::Basename;
use File::Find;
use Getopt::Long;
use POSIX;

my $dbname      = "/var/lib/rasdaemon/ras-mc_event.db";
my $prefix      = "/usr";
my $sysconfdir  = "/etc";
my $dmidecode   = find_prog ("dmidecode");

my %conf        = ();
my %bus         = ();
my %dimm_size   = ();
my %dimm_node   = ();
my %dimm_label_file = ();
my %dimm_location = ();
my %csrow_size  = ();
my %rank_size   = ();
my %csrow_ranks = ();
my %dimm_ce_count = ();
my %dimm_ue_count = ();

my @layers;
my @max_pos;
my @max_csrow;
my $item_size;

my $prog        = basename $0;
$conf{labeldb}  = "$sysconfdir/ras/dimm_labels.db";
$conf{labeldir} = "$sysconfdir/ras/dimm_labels.d";
$conf{mbconfig} = "$sysconfdir/ras/mainboard";

my $status      = 0;

my $usage       = <<EOF;
Usage: $prog [OPTIONS...]
 --quiet            Quiet operation.
 --mainboard        Print mainboard vendor and model for this hardware.
 --status           Print status of EDAC drivers.
 --print-labels     Print Motherboard DIMM labels to stdout.
 --guess-labels     Print DMI labels, when bank locator is available.
 --register-labels  Load Motherboard DIMM labels into EDAC driver.
 --delay=N          Delay N seconds before writing DIMM labels.
 --labeldb=DB       Load label database from file DB.
 --layout           Display the memory layout.
 --summary          Presents a summary of the logged errors.
 --errors           Shows the errors stored at the error database.
 --error-count      Shows the corrected and uncorrected error counts using sysfs.
 --help             This help message.
EOF

parse_cmdline();

if (  $conf{opt}{mainboard} || $conf{opt}{print_labels}
   || $conf{opt}{register_labels} || $conf{opt}{display_memory_layout}
   || $conf{opt}{guess_dimm_label} || $conf{opt}{error_count}) {

get_mainboard_info();

if ($conf{opt}{mainboard} eq "report") {
        print "$prog: mainboard: ",
              "$conf{mainboard}{vendor} model $conf{mainboard}{model}\n";
    }

if ($conf{opt}{print_labels}) {
        print_dimm_labels ();

}
    if ($conf{opt}{register_labels}) {
        register_dimm_labels ();
    }
    if ($conf{opt}{display_memory_layout}) {
        display_memory_layout ();
    }
    if ($conf{opt}{guess_dimm_label}) {
        guess_dimm_label ();
    }
    if ($conf{opt}{error_count}) {
        display_error_count ();
    }
}

if ($conf{opt}{status}) {
    $status = print_status ();
    exit ($status ? 0 : 1);
}

if ($conf{opt}{summary}) {
    summary ();
}

if ($conf{opt}{errors}) {
    errors ();
}

exit (0);

sub parse_cmdline
{
    $conf{opt}{mainboard} = '';
    $conf{opt}{print_labels} = 0;
    $conf{opt}{register_labels} = 0;
    $conf{opt}{status} = 0;
    $conf{opt}{quiet} = 0;
    $conf{opt}{delay} = 0;
    $conf{opt}{display_memory_layout} = 0;
    $conf{opt}{guess_dimm_label} = 0;
    $conf{opt}{summary} = 0;
    $conf{opt}{errors} = 0;
    $conf{opt}{error_count} = 0;

my $rref = \$conf{opt}{report};
    my $mref = \$conf{opt}{mainboard};

Getopt::Long::Configure ("bundling");
    my $rc = GetOptions ("mainboard:s" =>     sub { $$mref = $_[1]||"report" },
                         "help" =>            sub {usage (0)},
                         "quiet" =>           \$conf{opt}{quiet},
                         "print-labels" =>    \$conf{opt}{print_labels},
                         "guess-labels" =>    \$conf{opt}{guess_dimm_label},
                         "register-labels" => \$conf{opt}{register_labels},
                         "delay:s" =>         \$conf{opt}{delay},
                         "labeldb=s" =>       \$conf{labeldb},
                         "status" =>          \$conf{opt}{status},
                         "layout" =>          \$conf{opt}{display_memory_layout},
                         "summary" =>         \$conf{opt}{summary},
                         "errors" =>          \$conf{opt}{errors},
                         "error-count" =>     \$conf{opt}{error_count}
            );

usage(1) if !$rc;

usage (0) if !grep $conf{opt}{$_}, keys %{$conf{opt}};

if ($conf{opt}{delay} && !$conf{opt}{register_labels}) {
        log_error ("Only use --delay with --register-labels\n");
        exit (1);
    }
}

sub usage
{
    my ($rc) = @_;
    print "$usage\n";
    exit ($rc);
}

sub run_cmd
{
    my @args = @_;
    system ("@args");
    return ($?>>8);
}

sub print_status
{
    my $status = 0;
    open (MODULES, "/proc/modules")
         or die "Unable to open /proc/modules: $!\n";

while (<MODULES>) {
       $status = 1 if /_edac/;
    }

print "$prog: drivers ", ($status ? "are" : "not"), " loaded.\n"
        unless $conf{opt}{quiet};

return ($status);
}

sub parse_dimm_nodes
{
    my $file = $File::Find::name;

if (($file =~ /max_location$/)) {
        open IN, $file;
        my $location = <IN>;
        close IN;
        my @temp = split(/ /, $location);

$layers[0] = "mc";

if (m,/mc/mc(\d+),) {
                $max_pos[0] = $1 if (!exists($max_pos[0]) || $1 > $max_pos[0]);
        } else {
                $max_pos[0] = 0 if (!exists($max_pos[0]));
        }
        for (my $i = 0; $i < scalar(@temp); $i += 2) {
            $layers[$i / 2 + 1] = $temp[$i];
            $max_pos[$i / 2 + 1] = $temp[$i + 1];
        }

return;
    }
    if ($file =~ /size_mb$/) {
        my $mc = $file;
        $mc =~ s,.*mc(\d+).*,$1,;

my $csrow = $file;
        $csrow =~ s,.*csrow(\d+).*,$1,;

open IN, $file;
        my $size = <IN>;
        close IN;

my $str_loc = join(':', $mc, $csrow);
        $csrow_size{$str_loc} = $size;

return;
    }
    if ($file =~ /location$/) {
        my $mc = $file;
        $mc =~ s,.*mc(\d+).*,$1,;

my $dimm = $file;
        $dimm =~ s,.*dimm(\d+).*,$1,;

open IN, $file;
        my $location = <IN>;
        close IN;

my @pos;

# Get the name of the hierarchy labels
        if (!@layers) {
                my @temp = split(/ /, $location);
                $max_pos[0] = 0;
                $layers[0] = "mc";
                for (my $i = 0; $i < scalar(@temp); $i += 2) {
                $layers[$i / 2 + 1] = $temp[$i];
                $max_pos[$i / 2 + 1] = 0;
                }
        }

my @temp = split(/ /, $location);
        for (my $i = 1; $i < scalar(@temp); $i += 2) {
                $pos[$i / 2] = $temp[$i];

if ($pos[$i / 2] > $max_pos[$i / 2]) {
                $max_pos[$i / 2 + 1] = $pos[$i / 2];
                }
        }
        if ($mc > $max_pos[0]) {
                $max_pos[0] = $mc;
        }

# Get DIMM size

$file =~ s/dimm_location/size/;
        open IN, $file;
        my $size = <IN>;
        close IN;

my $str_loc = join(':', $mc, @pos);
        $dimm_size{$str_loc} = $size;
        $dimm_node{$str_loc} = $dimm;
        $file =~ s/size/dimm_label/;
        $dimm_label_file{$str_loc} = $file;
        $dimm_location{$str_loc} = $location;

my $count;

$file =~s/dimm_label/dimm_ce_count/;
        if (-e $file) {
                open IN, $file;
                chomp($count = <IN>);
                close IN;
        } else {
                log_error ("dimm_ce_count not found in sysfs. Old kernel?\n");
                exit -1;
        }
        $dimm_ce_count{$str_loc} = $count;

$file =~s/dimm_ce_count/dimm_ue_count/;
        if (-e $file) {
                open IN, $file;
                chomp($count = <IN>);
                close IN;
        } else {
                log_error ("dimm_ue_count not found in sysfs. Old kernel?\n");
                exit -1;
        }
        $dimm_ue_count{$str_loc} = $count;

return;
    }
}

sub guess_product {
    my $pvendor = undef;
    my $pname = undef;

if (open (VENDOR, "/sys/class/dmi/id/product_vendor")) {
        $pvendor = <VENDOR>;
        close VENDOR;
        chomp($pvendor);
    }
    if (open (NAME, "/sys/class/dmi/id/product_name")) {
        $pname = <NAME>;
        close NAME;
        chomp($pname);
    }

return ($pvendor, $pname);
}

sub get_mainboard_info {
    my ($vendor, $model);
    my ($pvendor, $pname);

if ($conf{opt}{mainboard} && $conf{opt}{mainboard} ne "report") {
        ($vendor, $model) = split (/[: ]/, $conf{opt}{mainboard}, 2);
    }

if (!$vendor || !$model) {
        ($vendor, $model) = guess_vendor_model ();
    }

$conf{mainboard}{vendor} = $vendor;
    $conf{mainboard}{model}  = $model;

($pvendor, $pname) = guess_product ();
    # since product vendor is rare, use mainboard's vendor
    if ($pvendor) {
        $conf{mainboard}{product_vendor} = $pvendor;
    } else {
        $conf{mainboard}{product_vendor} = $vendor;
    }
    $conf{mainboard}{product_name} = $pname if $pname;
}

sub guess_vendor_model_dmidecode {
    my ($vendor, $model);
    my ($system_vendor, $system_model);
    my $line = 0;

$< == 0 || die "Must be root to run dmidecode\n";

open (DMI, "$dmidecode |") or die "failed to run $dmidecode: $!\n";

$vendor = $model = "";

LINE:
    while (<DMI>) {
        $line++;

/^(\s*)(board|base board|system) information/i || next LINE;
        my $indent = $1;
	my $type = $2;

while ( <DMI> ) {
            /^(\s*)/;
            $1 lt $indent && last LINE;
            $indent = $1;
            if ($type eq "system") {
                /(?:manufacturer|vendor):\s*(.*\S)\s*/i && ( $system_vendor = $1 );
                /product(?: name)?:\s*(.*\S)\s*/i       && ( $system_model  = $1 );
            } else {
                /(?:manufacturer|vendor):\s*(.*\S)\s*/i && ( $vendor = $1 );
                /product(?: name)?:\s*(.*\S)\s*/i       && ( $model  = $1 );
            }
            last LINE if ($vendor && $model);
        }
    }

close (DMI);

$vendor = $system_vendor if ($vendor eq "");
    $model = $system_model if ($model eq "");

return ($vendor, $model);
}

sub guess_vendor_model_sysfs {
    #
    #  Try to look up DMI information in sysfs
    #
    open (VENDOR, "/sys/class/dmi/id/board_vendor") or return undef;
    open (MODEL,  "/sys/class/dmi/id/board_name")   or return undef;

my ($vendor, $model) = (<VENDOR>, <MODEL>);

close (VENDOR);
    close (MODEL);

return undef unless ($vendor && $model);

chomp ($vendor, $model);

return ($vendor, $model);
}

sub parse_mainboard_config
{
    my ($file) = @_;
    my %hash = ();
    my $line = 0;

open (CFG, "$file") or die "Failed to read mainboard config: $file: $!\n";
    while (<CFG>) {
        $line++;
        chomp;                                          # remove newline
        s/^((?:[^'"#]*(?:(['"])[^\2]*\2)*)*)#.*/$1/;    # remove comments
        s/^\s+//;                                       # remove leading space
        s/\s+$//;                                       # remove trailing space
        next unless length;                             # skip blank lines
        if (my ($key, $val) = /^\s*([-\w]+)\s*=\s*(.*)/) {
            $hash{$key}{val} = $val;
            $hash{$key}{line} = $line;
            next;
        }
        return undef;
    }
    close (CFG) or &log_error ("close $file: $!\n");
    return \%hash;
}

sub guess_vendor_model {
    my ($vendor, $model);
    #
    #  If mainboard config file exists then parse it
    #   to get the vendor and model information.
    #
    if (-f $conf{mbconfig} ) {
        my $cfg = &parse_mainboard_config ($conf{mbconfig});

#  If mainboard config file specified a script, then try to
        #   run the specified script or executable:
        #
        if ($cfg->{"script"}) {
            $cfg = &parse_mainboard_config ("$cfg->{script}{val} |");
            die "Failed to run mainboard script\n" if (!$cfg);
        }
        return ($cfg->{vendor}{val}, $cfg->{model}{val});
    }

($vendor, $model) = &guess_vendor_model_sysfs ();

return ($vendor, $model) if ($vendor && $model);

return (&guess_vendor_model_dmidecode ());
}

sub guess_dimm_label {
    open (DMI, "$dmidecode |") or die "failed to run $dmidecode: $!\n";

LINE:
    while (<DMI>) {
        /^(\s*)memory device$/i || next LINE;
	my ($dimm_label, $dimm_addr);

while (<DMI>) {
	    if (/^\s*(locator|bank locator)/i) {
		my $indent = $1;
		$indent =~ tr/A-Z/a-z/;

if ($indent eq "locator") {
			/(?:locator):\s*(.*\S)\s*/i && ( $dimm_label = $1 );
		}
		if ($indent eq "bank locator") {
			/(?:bank locator):\s*(.*\S)\s*/i && ( $dimm_addr = $1 );
		}
	    }
	    if ($dimm_label && $dimm_addr) {
		printf "memory stick '%s' is located at '%s'\n",
			$dimm_label, $dimm_addr;
		next LINE;
	    }
	    next LINE if (/^\s*\n/);
        }
    }

close (DMI);
}

sub parse_dimm_labels_file
{
    my ($lh, $num_layers, $lh_prod, $num_layers_prod, $file) = (@_);
    my $line = -1;
    my $vendor = "";
    my @models = ();
    my @products = ();
    my $num;

open (LABELS, "$file")
        or die "Unable to open label database: $file: $!\n";

while (<LABELS>) {
        $line++;
        next if /^#/;
        chomp;
        s/^\s+//;
        s/\s+$//;
        next unless length;

if (/vendor\s*:\s*(.*\S)\s*/i) {
            $vendor = lc $1;
            @models = ();
            @products = ();
            $num = 0;
            next;
        }
        if (/(model|board)\s*:\s*(.*)$/i) {
            !$vendor && die "$file: line $line: MB model without vendor\n";
            @models = grep { s/\s*(.*)\s*$/$1/ } split(/[,;]+/, $2);
            @products = ();
            $num = 0;
            next;
        }
        if (/(product)\s*:\s*(.*)$/i) {
            !$vendor && die "$file: line $line: product without vendor\n";
            @models = ();
            @products = grep { s/\s*(.*)\s*$/$1/ } split(/[,;]+/, $2);
            $num = 0;
            next;
        }

# Allow multiple labels to be specified on a single line,
        #  separated by ;
        for my $str (split /;/) {
            $str =~ s/^\s*(.*)\s*$/$1/;

next unless (my ($label, $info) = ($str =~ /^(.*)\s*:\s*(.*)$/i));

unless ($info =~ /\d+(?:[\.\:]\d+)*/) {
                log_error ("$file: $line: Invalid syntax, ignoring: \"$_\"\n");
                next;
            }

for my $target (split (/[, ]+/, $info)) {
                my $n;
                my ($mc, $top, $mid, $low, $extra) = ($target =~ /(\d+)(?:[\.\:](\d+)){0,1}(?:[\.\:](\d+)){0,1}(?:[\.\:](\d+)){0,1}(?:[\.\:](\d+)){0,1}/);

if (defined($extra)) {
                        die ("Error: Only up to 3 layers are currently supported on label db \"$file\"\n");
                        return;
                } elsif (!defined($top)) {
                        die ("Error: The label db \"$file\" is defining a zero-layers machine\n");
                        return;
                } else {
                    $n = 3;
                    if (!defined($low)) {
                        $low = 0;
                        $n--;
                    }
                    if (!defined($mid)) {
                        $mid = 0;
                        $n--;
                    }
                    map { $lh->{$vendor}{lc $_}{$mc}{$top}{$mid}{$low} = $label }
                            @models;
                    map { $lh_prod->{$vendor}{lc $_}{$mc}{$top}{$mid}{$low} = $label }
                            @products;
                }
                if (!$num) {
                        $num = $n;
                        map { $num_layers->{$vendor}{lc $_} = $num } @models;
                        map { $num_layers_prod->{$vendor}{lc $_} = $num } @products;
                } elsif ($num != $n) {
                        die ("Error: Inconsistent number of layers at label db \"$file\"\n");
                }
            }
        }
    }

close (LABELS) or die "Error from label db \"$file\" : $!\n";
}

sub parse_dimm_labels
{
    my %labels = ();
    my %num_layers = ();
    my %labels_prod = ();
    my %num_layers_prod = ();

#
    #  Accrue all DIMM labels from the labels.db file, as
    #   well as any files under the labels dir
    #
    for my $file ($conf{labeldb}, <$conf{labeldir}/*>) {
        next unless -r $file;
        parse_dimm_labels_file (\%labels, \%num_layers, \%labels_prod, \%num_layers_prod, $file);
    }

return (\%labels, \%num_layers, \%labels_prod, \%num_layers_prod);
}

sub read_dimm_label
{
    my ($num_layers, $mc, $top, $mid, $low) = @_;
    my $sysfs = "/sys/devices/system/edac/mc";
    my $pos;

$pos = "$mc:$top:$mid:$low" if ($num_layers == 3);
    $pos = "$mc:$top:$mid" if ($num_layers == 2);
    $pos = "$mc:$top" if ($num_layers == 1);

if (!defined($dimm_node{$pos})) {
        my $label = "$pos missing";
        $pos = "";
        return ($label, $pos);
    }

my $dimm = $dimm_node{$pos};

my $dimm_label_file = $dimm_label_file{$pos};

my $location = $dimm_location{$pos};

return ("label missing", "$pos missing") unless -f $dimm_label_file;

if (!open (LABEL, "$dimm_label_file")) {
        warn "Failed to open $dimm_label_file: $!\n";
        return ("Error");
    }

chomp (my $label = <LABEL> || "");

close (LABEL);

$pos = "mc$mc $location";

return ($label, $pos);
}

sub get_dimm_label_node
{
    my ($num_layers, $mc, $top, $mid, $low) = @_;
    my $sysfs = "/sys/devices/system/edac/mc";
    my $pos = "$mc:$top:$mid:$low";

$pos = "$mc:$top:$mid:$low" if ($num_layers == 3);
    $pos = "$mc:$top:$mid" if ($num_layers == 2);
    $pos = "$mc:$top" if ($num_layers == 1);

return "" if (!defined($dimm_node{$pos}));

return "$dimm_label_file{$pos}";
}

sub _print_dimm_labels
{
    my ($lref, $num_layers, $vendor, $model, $fh, $format) = @_;

for my $mc (sort keys %{$$lref{$vendor}{$model}}) {
        for my $top (sort keys %{$$lref{$vendor}{$model}{$mc}}) {
            for my $mid (sort keys %{$$lref{$vendor}{$model}{$mc}{$top}}) {
                for my $low (sort keys %{$$lref{$vendor}{$model}{$mc}{$top}{$mid}}) {
                    my $label = $$lref{$vendor}{$model}{$mc}{$top}{$mid}{$low};
                    my ($rlabel,$loc) = read_dimm_label ($$num_layers{$vendor}{$model}, $mc, $top, $mid, $low);

printf $fh $format, $loc, $label, $rlabel;
                }
            }
        }
    }
    print $fh "\n";
}

sub print_dimm_labels
{
    my $fh = shift || *STDOUT;
    my ($lref, $num_layers, $lref_prod, $num_layers_prod) = parse_dimm_labels ();
    my $vendor = lc $conf{mainboard}{vendor};
    my $model  = lc $conf{mainboard}{model};
    my $pvendor = lc $conf{mainboard}{product_vendor};
    my $pname = lc $conf{mainboard}{product_name};
    my $format = "%-35s %-20s %-20s\n";

if (!exists $$lref{$vendor}{$model} && !exists $$lref_prod{$pvendor}{$pname}) {
        log_error ("No dimm labels for $conf{mainboard}{vendor} " .
                   "model $conf{mainboard}{model}\n");
        return;
    }

my $sysfs_dir = "/sys/devices/system/edac/mc";

find({wanted => \&parse_dimm_nodes, no_chdir => 1}, $sysfs_dir);

printf $fh $format, "LOCATION", "CONFIGURED LABEL", "SYSFS CONTENTS";

if (exists $$lref{$vendor}{$model}) {
        _print_dimm_labels($lref, $num_layers, $vendor, $model, $fh, $format);
    } elsif (exists $$lref_prod{$pvendor}{$pname}) {
        _print_dimm_labels($lref_prod, $num_layers_prod, $pvendor, $pname, $fh, $format);
    }
}

sub write_dimm_labels
{
    my ($lref, $num_layers, $vendor, $model) = @_;

my $file = get_dimm_label_node($$num_layers{$vendor}{$model}, $mc, $top, $mid, $low);

# Ignore sysfs files that don't exist. Might just be
                    #  unpopulated bank.
                    next unless -f $file;

if (!open (DL, ">$file")) {
                        warn ("Unable to open $file\n");
                        next;
                    }

syswrite DL, $$lref{$vendor}{$model}{$mc}{$top}{$mid}{$low};

close (DL);
                }
            }
        }
    }
}

sub register_dimm_labels
{
    my ($lref, $num_layers, $lref_prod, $num_layers_prod) = parse_dimm_labels ();
    my $vendor = lc $conf{mainboard}{vendor};
    my $model  = lc $conf{mainboard}{model};
    my $pvendor = lc $conf{mainboard}{product_vendor};
    my $pname = lc $conf{mainboard}{product_name};
    my $sysfs  = "/sys/devices/system/edac/mc";

if (!exists $$lref{$vendor}{$model} && !exists $$lref_prod{$pvendor}{$pname}) {
        log_error ("No dimm labels for $conf{mainboard}{vendor} " .
                                      "model $conf{mainboard}{model}\n");
        return 0;
    }
    my $sysfs_dir = "/sys/devices/system/edac/mc";

find({wanted => \&parse_dimm_nodes, no_chdir => 1}, $sysfs_dir);

select (undef, undef, undef, $conf{opt}{delay});

if (exists $$lref{$vendor}{$model}) {
        write_dimm_labels($lref, $num_layers, $vendor, $model);
    } else {
        write_dimm_labels($lref_prod, $num_layers_prod, $pvendor, $pname);
    }

return 1;
}

sub dimm_display_layer_rev($@);

sub dimm_display_layer_rev($@)
{
    my $layer = shift;
    my @pos = @_;

$layer++;
    if ($layer >= scalar(@pos) - 1) {
        my $str_loc = join(':', @pos);
        my $size = $dimm_size{$str_loc};
        if (!$size) {
            $size = 0;
        }
        my $s = sprintf "  %4i MB  |", $size;
        $item_size = length($s);
        return $s;
    }

my $s;
    for (my $i = 0; $i <= $max_pos[$layer]; $i++) {
        $pos[$layer] = $i;
        $s .= dimm_display_layer_rev($layer, @pos);
    }

return $s;
}

sub dimm_display_layer(@)
{
    my @pos = @_;

my $s;
    for (my $i = 0; $i <= $max_pos[0]; $i++) {
        $pos[0] = $i;
        $s .= dimm_display_layer_rev(0, @pos);
    }

return $s;
}

sub dimm_display_layer_header($$)
{
    my $n_items = 1;
    my $scale;
    my $layer = shift;
    my $tot_items = shift;

my $s;
    for (my $i = 0; $i <= $layer; $i++) {
        $n_items *= $max_pos[$i] + 1;
    }
    $scale = $tot_items / $n_items;

my $d = 0;
    for (my $i = 0; $i < $n_items; $i++) {
        my $val = sprintf("%s%d", $layers[$layer], $d);
        $val = substr($val, 0, $scale * $item_size - 2);
        my $fillsize =  $scale * $item_size - 1 - length($val);
        $s .= "|";
        $s .= " " x ($fillsize / 2);
        $s .= $val;
        $s .= " " x ($fillsize - floor($fillsize / 2));

$d++;
        if ($d > $max_pos[$layer]) {
            $d = 0;
        }
    }
    $s .= "|";
    return $s;
}

sub dimm_display_mem()
{
    my @pos = @max_pos;
    my $sep = "";
    my $tot_items = 1;
    my $first = 1;

for (my $i = 0; $i < scalar(@pos) - 1; $i++) {
        $pos[$i] = 0;
        $tot_items *= $max_pos[$i] + 1;
    }

my $is_even = $max_pos[scalar(@max_pos) - 1] % 2;
    for (my $d = $max_pos[scalar(@max_pos) - 1]; $d >= 0; $d--) {
        my $len;

my $s = sprintf("%s%d: |", $layers[scalar(@max_pos) - 1], $d);
        my $p1 = length($s) - 1;

$pos[scalar(@pos) - 1] = $d;
        $s .= dimm_display_layer(@pos);
        $len += length($s);

$sep = "-" x $p1;
        $sep .= "+";
        $sep .= "-" x ($len - $p1 - 2);
        $sep .= "+";

if ($first) {
            my $sep1 = " " x $p1;
            $sep1 .= "+";
            $sep1 .= "-" x ($len - $p1 - 2);
            $sep1 .= "+";
            printf "$sep1\n";
            for (my $layer = 0; $layer < scalar(@pos) - 1; $layer++) {
                my $s = sprintf("%s%d: |", $layers[scalar(@max_pos) - 1], 0);
                my $p1 = length($s) - 1;
                my $msg = " " x $p1;
                $msg .= dimm_display_layer_header($layer, $tot_items);
                printf "$msg\n";
            }
            printf "$sep\n" if (!$is_even);
            $first = 0;
        }

if ($is_even && (($max_pos[scalar(@max_pos) - 1] - $d) % 2 == 0)) {
            printf "$sep\n";
        }

printf "$s\n";
    }
    printf "$sep\n";
}

sub fill_csrow_size()
{
    foreach my $str_loc (keys %rank_size) {
        my @temp = split(/:/, $str_loc);
        my $csrow = join(':', $temp[0], $temp[1]);
        if ($csrow_ranks{$csrow}) {
            $rank_size{$str_loc} = $csrow_size{$csrow} / $csrow_ranks{$csrow};
        }
    }
}

sub display_memory_layout
{
    my $sysfs_dir = "/sys/devices/system/edac/mc";

find({wanted => \&parse_dimm_nodes, no_chdir => 1}, $sysfs_dir);

if (!scalar(%csrow_size)) {
        log_error ("No memories found at via edac.\n");
        exit -1;
    } elsif (!scalar(%dimm_size)) {
        fill_csrow_size;
        $layers[0] = "mc";
        $layers[1] = "csrow";
        $layers[2] = "channel";
        @max_pos = @max_csrow;
        %dimm_size = %rank_size;
    }
    dimm_display_mem();
}

sub display_error_count
{
    my $sysfs_dir = "/sys/devices/system/edac/mc";
    my $key;
    my $max_width = 0;
    my %dimm_labels = ();

find ({wanted => \&parse_dimm_nodes, no_chdir => 1}, $sysfs_dir);

if (!scalar(keys %dimm_node)) {
        log_error ("No DIMMs found in /sys or new sysfs EDAC interface not found.\n");
        exit -1;
    }

foreach $key (keys %dimm_node) {
        my $label_width;

open IN, $dimm_label_file{$key};
        chomp(my $label = <IN>);
        close IN;
        $label_width = length $label;

if ($label_width > $max_width) {
            $max_width = $label_width;
        }
        $dimm_labels{$key} = $label;
    }
    my $string = "Label";
    $string .= " " x ($max_width - length $string);
    print($string . "\tCE\tUE\n");

foreach $key (keys %dimm_node) {
        my $ce_count = $dimm_ce_count{$key};
        my $ue_count = $dimm_ue_count{$key};

print("$dimm_labels{$key}\t$ce_count\t$ue_count\n");
    }
}

sub find_prog
{
    my ($file) = @_;
    for my $dir ("/sbin", "/usr/sbin", split ':', $ENV{PATH}) {
        return "$dir/$file" if -x "$dir/$file";
    }
    # log_error ("Failed to find $file in PATH\n");
    return "";
}

sub get_extlog_type
{
    my @types;

if ($_[0] < 0 || $_[0] > 15) {
        return "unknown-type";
    }

@types = ("unknown",
              "no error",
              "single-bit ECC",
              "multi-bit ECC",
              "single-symbol chipkill ECC",
              "multi-symbol chipkill ECC",
              "master abort",
              "target abort",
              "parity error",
              "watchdog timeout",
              "invalid address",
              "mirror Broken",
              "memory sparing",
              "scrub corrected error",
              "scrub uncorrected error",
              "physical memory map-out event",
              "unknown-type");
    return $types[$_[0]];
}

sub get_extlog_severity
{
    my @sev;

if ($_[0] < 0 || $_[0] > 3) {
        return "unknown-severity";
    }

@sev = ("recoverable",
            "fatal",
            "corrected",
            "informational",
            "unknown-severity");
    return $sev[$_[0]];
}

use constant {
    CPER_MEM_VALID_NODE => 0x0008,
    CPER_MEM_VALID_CARD => 0x0010,
    CPER_MEM_VALID_MODULE => 0x0020,
    CPER_MEM_VALID_BANK => 0x0040,
    CPER_MEM_VALID_DEVICE => 0x0080,
    CPER_MEM_VALID_ROW => 0x0100,
    CPER_MEM_VALID_COLUMN => 0x0200,
    CPER_MEM_VALID_BIT_POSITION => 0x0400,
    CPER_MEM_VALID_REQUESTOR_ID => 0x0800,
    CPER_MEM_VALID_RESPONDER_ID => 0x1000,
    CPER_MEM_VALID_TARGET_ID => 0x2000,
    CPER_MEM_VALID_ERROR_TYPE => 0x4000,
    CPER_MEM_VALID_RANK_NUMBER => 0x8000,
    CPER_MEM_VALID_CARD_HANDLE => 0x10000,
    CPER_MEM_VALID_MODULE_HANDLE => 0x20000,
};

sub get_cper_data_text
{
    my $cper_data = $_[0];
    my ($validation_bits, $node, $card, $module, $bank, $device, $row, $column, $bit_pos, $requestor_id, $responder_id, $target_id, $rank, $mem_array_handle, $mem_dev_handle) = unpack 'QSSSSSSSSQQQSSS', $cper_data;
    my @out;

if ($validation_bits & CPER_MEM_VALID_NODE) {
        push @out, (sprintf "node=%d", $node);
    }
    if ($validation_bits & CPER_MEM_VALID_CARD) {
        push @out, (sprintf "card=%d", $card);
    }
    if ($validation_bits & CPER_MEM_VALID_MODULE) {
        push @out, (sprintf "module=%d", $module);
    }
    if ($validation_bits & CPER_MEM_VALID_BANK) {
        push @out, (sprintf "bank=%d", $bank);
    }
    if ($validation_bits & CPER_MEM_VALID_DEVICE) {
        push @out, (sprintf "device=%d", $device);
    }
    if ($validation_bits & CPER_MEM_VALID_ROW) {
        push @out, (sprintf "row=%d", $row);
    }
    if ($validation_bits & CPER_MEM_VALID_COLUMN) {
        push @out, (sprintf "column=%d", $column);
    }
    if ($validation_bits & CPER_MEM_VALID_BIT_POSITION) {
        push @out, (sprintf "bit_position=%d", $bit_pos);
    }
    if ($validation_bits & CPER_MEM_VALID_REQUESTOR_ID) {
        push @out, (sprintf "0x%08x", $requestor_id);
    }
    if ($validation_bits & CPER_MEM_VALID_RESPONDER_ID) {
        push @out, (sprintf "0x%08x", $responder_id);
    }
    if ($validation_bits & CPER_MEM_VALID_TARGET_ID) {
        push @out, (sprintf "0x%08x", $target_id);
    }
    if ($validation_bits & CPER_MEM_VALID_RANK_NUMBER) {
        push @out, (sprintf "rank=%d", $rank);
    }
    if ($validation_bits & CPER_MEM_VALID_CARD_HANDLE) {
        push @out, (sprintf "mem_array_handle=%d", $mem_array_handle);
    }
    if ($validation_bits & CPER_MEM_VALID_MODULE_HANDLE) {
        push @out, (sprintf "mem_dev_handle=%d", $mem_dev_handle);
    }

return join (", ", @out);
}

sub get_uuid_le
{
    my $out = "";
    my @bytes = unpack "C*", $_[0];
    my @le16_table = (3, 2, 1, 0, 5, 4, 7, 6, 8, 9, 10, 11, 12, 13, 14, 15);

for (my $i = 0; $i < 16; $i++) {
        $out .= sprintf "%.2x", $bytes[$le16_table[$i]];
        if ($i == 3 or $i == 5 or $i == 7 or $i == 9) {
            $out .= "-";
        }
    }
    return $out;
}

sub summary
{
    require DBI;
    my ($query, $query_handle, $out);
    my ($err_type, $label, $mc, $top, $mid, $low, $count, $msg);
    my ($etype, $severity, $etype_string, $severity_string);

my $dbh = DBI->connect("dbi:SQLite:dbname=$dbname", "", "", {});

# Memory controller mc_event errors
    $query = "select err_type, label, mc, top_layer,middle_layer,lower_layer, count(*) from mc_event group by err_type, label, mc, top_layer, middle_layer, lower_layer";
    $query_handle = $dbh->prepare($query);
    $query_handle->execute();
    $query_handle->bind_columns(\($err_type, $label, $mc, $top, $mid, $low, $count));
    $out = "";
    while($query_handle->fetch()) {
        $out .= "\t$err_type on DIMM Label(s): '$label' location: $mc:$top:$mid:$low errors: $count\n";
    }
    if ($out ne "") {
        print "Memory controller events summary:\n$out\n";
    } else {
        print "No Memory errors.\n\n";
    }
    $query_handle->finish;

# PCIe AER aer_event errors
    $query = "select err_type, err_msg, count(*) from aer_event group by err_type, err_msg";
    $query_handle = $dbh->prepare($query);
    $query_handle->execute();
    $query_handle->bind_columns(\($err_type, $msg, $count));
    $out = "";
    while($query_handle->fetch()) {
        $out .= "\t$count $err_type errors: $msg\n";
    }
    if ($out ne "") {
        print "PCIe AER events summary:\n$out\n";
    } else {
        print "No PCIe AER errors.\n\n";
    }
    $query_handle->finish;

# extlog errors
    $query = "select etype, severity, count(*) from extlog_event group by etype, severity";
    $query_handle = $dbh->prepare($query);
    $query_handle->execute();
    $query_handle->bind_columns(\($etype, $severity, $count));
    $out = "";
    while($query_handle->fetch()) {
        $etype_string = get_extlog_type($etype);
        $severity_string = get_extlog_severity($severity);
        $out .= "\t$count $etype_string $severity_string errors\n";
    }
    if ($out ne "") {
        print "Extlog records summary:\n$out";
    } else {
        print "No Extlog errors.\n";
    }
    $query_handle->finish;

# MCE mce_record errors
    $query = "select error_msg, count(*) from mce_record group by error_msg";
    $query_handle = $dbh->prepare($query);
    $query_handle->execute();
    $query_handle->bind_columns(\($msg, $count));
    $out = "";
    while($query_handle->fetch()) {
        $out .= "\t$count $msg errors\n";
    }
    if ($out ne "") {
        print "MCE records summary:\n$out";
    } else {
        print "No MCE errors.\n";
    }
    $query_handle->finish;

undef($dbh);
}

sub errors
{
    require DBI;
    my ($query, $query_handle, $id, $time, $count, $type, $msg, $label, $mc, $top, $mid, $low, $addr, $grain, $syndrome, $detail, $out);
    my ($mcgcap,$mcgstatus, $status, $misc, $ip, $tsc, $walltime, $cpu, $cpuid, $apicid, $socketid, $cs, $bank, $cpuvendor, $bank_name, $mcgstatus_msg, $mcistatus_msg, $user_action, $mc_location);
    my ($timestamp, $etype, $severity, $etype_string, $severity_string, $fru_id, $fru_text, $cper_data);

my $dbh = DBI->connect("dbi:SQLite:dbname=$dbname", "", "", {});

# Memory controller mc_event errors
    $query = "select id, timestamp, err_count, err_type, err_msg, label, mc, top_layer,middle_layer,lower_layer, address, grain, syndrome, driver_detail from mc_event order by id";
    $query_handle = $dbh->prepare($query);
    if (!$query_handle) {
        log_error ("mc_event table missing from $dbname. Run 'rasdaemon --record'.\n");
        exit -1
    }
    $query_handle->execute();
    $query_handle->bind_columns(\($id, $time, $count, $type, $msg, $label, $mc, $top, $mid, $low, $addr, $grain, $syndrome, $detail));
    $out = "";
    while($query_handle->fetch()) {
        $out .= "$id $time $count $type error(s): $msg at $label location: $mc:$top:$mid:$low, addr $addr, grain $grain, syndrome $syndrome $detail\n";
    }
    if ($out ne "") {
        print "Memory controller events:\n$out\n";
    } else {
        print "No Memory errors.\n\n";
    }
    $query_handle->finish;

# PCIe AER aer_event errors
    $query = "select id, timestamp, err_type, err_msg from aer_event order by id";
    $query_handle = $dbh->prepare($query);
    $query_handle->execute();
    $query_handle->bind_columns(\($id, $time, $type, $msg));
    $out = "";
    while($query_handle->fetch()) {
        $out .= "$id $time $type error: $msg\n";
    }
    if ($out ne "") {
        print "PCIe AER events:\n$out\n";
    } else {
        print "No PCIe AER errors.\n\n";
    }
    $query_handle->finish;

# Extlog errors
    $query = "select id, timestamp, etype, severity, address, fru_id, fru_text, cper_data from extlog_event order by id";
    $query_handle = $dbh->prepare($query);
    $query_handle->execute();
    $query_handle->bind_columns(\($id, $timestamp, $etype, $severity, $addr, $fru_id, $fru_text, $cper_data));
    $out = "";
    while($query_handle->fetch()) {
        $etype_string = get_extlog_type($etype);
        $severity_string = get_extlog_severity($severity);
        $out .= "$id $timestamp error: ";
        $out .= "type=$etype_string, ";
        $out .= "severity=$severity_string, ";
        $out .= sprintf "address=0x%08x, ", $addr;
        $out .= sprintf "fru_id=%s, ", get_uuid_le($fru_id);
        $out .= "fru_text='$fru_text', ";
        $out .= get_cper_data_text($cper_data) if ($cper_data);
        $out .= "\n";
    }
    if ($out ne "") {
        print "Extlog events:\n$out\n";
    } else {
        print "No Extlog errors.\n\n";
    }
    $query_handle->finish;

# MCE mce_record errors
    $query = "select id, timestamp, mcgcap, mcgstatus, status, addr, misc, ip, tsc, walltime, cpu, cpuid, apicid, socketid, cs, bank, cpuvendor, bank_name, error_msg, mcgstatus_msg, mcistatus_msg, user_action, mc_location from mce_record order by id";
    $query_handle = $dbh->prepare($query);
    $query_handle->execute();
    $query_handle->bind_columns(\($id, $time, $mcgcap,$mcgstatus, $status, $addr, $misc, $ip, $tsc, $walltime, $cpu, $cpuid, $apicid, $socketid, $cs, $bank, $cpuvendor, $bank_name, $msg, $mcgstatus_msg, $mcistatus_msg, $user_action, $mc_location));
    $out = "";
    while($query_handle->fetch()) {
        $out .= "$id $time error: $msg";
	$out .= ", CPU $cpuvendor" if ($cpuvendor);
	$out .= ", bank $bank_name" if ($bank_name);
	$out .= ", mcg $mcgstatus_msg" if ($mcgstatus_msg);
	$out .= ", mci $mcistatus_msg" if ($mcistatus_msg);
	$out .= ", $mc_location" if ($mc_location);
	$out .= ", $user_action" if ($user_action);
	$out .= sprintf ", mcgcap=0x%08x", $mcgcap if ($mcgcap);
	$out .= sprintf ", mcgstatus=0x%08x", $mcgstatus if ($mcgstatus);
	$out .= sprintf ", status=0x%08x", $status if ($status);
	$out .= sprintf ", addr=0x%08x", $addr if ($addr);
	$out .= sprintf ", misc=0x%08x", $misc if ($misc);
	$out .= sprintf ", ip=0x%08x", $ip if ($ip);
	$out .= sprintf ", tsc=0x%08x", $tsc if ($tsc);
	$out .= sprintf ", walltime=0x%08x", $walltime if ($walltime);
	$out .= sprintf ", cpu=0x%08x", $cpu if ($cpu);
	$out .= sprintf ", cpuid=0x%08x", $cpuid if ($cpuid);
	$out .= sprintf ", apicid=0x%08x", $apicid if ($apicid);
	$out .= sprintf ", socketid=0x%08x", $socketid if ($socketid);
	$out .= sprintf ", cs=0x%08x", $cs if ($cs);
	$out .= sprintf ", bank=0x%08x", $bank if ($bank);

$out .= "\n";
    }
    if ($out ne "") {
        print "MCE events:\n$out\n";
    } else {
        print "No MCE errors.\n\n";
    }
    $query_handle->finish;

undef($dbh);
}

sub log_msg   { print STDERR "$prog: ", @_ unless $conf{opt}{quiet}; }
sub log_error { log_msg ("Error: @_"); }

# vi: ts=4 sw=4 expandtab

X7ROOT File Manager

Editing: ras-mc-ctl

Upload File

Create Folder