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: amvault

#! /usr/bin/perl
# Copyright (c) 2008-2012 Zmanda, Inc.  All Rights Reserved.
#
# This program 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 program 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.,
# 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
#
# Contact information: Zmanda Inc., 465 S. Mathilda Ave., Suite 300
# Sunnyvale, CA 94086, USA, or: http://www.zmanda.com

use lib '/usr/lib64/perl5/vendor_perl';
use strict;
use warnings;

package main::Interactivity;
use POSIX qw( :errno_h );
use Amanda::MainLoop qw( :GIOCondition );
use vars qw( @ISA );
@ISA = qw( Amanda::Interactivity );

sub new {
    my $class = shift;

my $self = {
	input_src => undef};
    return bless ($self, $class);
}

sub abort() {
    my $self = shift;

if ($self->{'input_src'}) {
	$self->{'input_src'}->remove();
	$self->{'input_src'} = undef;
    }
}

sub user_request {
    my $self = shift;
    my %params = @_;
    my %subs;
    my $buffer = "";

my $message  = $params{'message'};
    my $label    = $params{'label'};
    my $err      = $params{'err'};
    my $chg_name = $params{'chg_name'};

$subs{'data_in'} = sub {
	my $b;
	my $n_read = POSIX::read(0, $b, 1);
	if (!defined $n_read) {
	    return if ($! == EINTR);
	    $self->abort();
	    return $params{'request_cb'}->(
		Amanda::Changer::Error->new('fatal',
			message => "Fail to read from stdin"));
	} elsif ($n_read == 0) {
	    $self->abort();
	    return $params{'request_cb'}->(
		Amanda::Changer::Error->new('fatal',
			message => "Aborted by user"));
	} else {
	    $buffer .= $b;
	    if ($b eq "\n") {
		my $line = $buffer;
		chomp $line;
		$buffer = "";
		$self->abort();
		return $params{'request_cb'}->(undef, $line);
	    }
	}
    };

print STDERR "$err\n";
    print STDERR "Insert volume labeled '$label' in $chg_name\n";
    print STDERR "and press enter, or ^D to abort.\n";

$self->{'input_src'} = Amanda::MainLoop::fd_source(0, $G_IO_IN|$G_IO_HUP|$G_IO_ERR);
    $self->{'input_src'}->set_callback($subs{'data_in'});
    return;
};

package Amvault;

use Amanda::Config qw( :getconf config_dir_relative );
use Amanda::Debug qw( :logging debug );
use Amanda::Xfer qw( :constants );
use Amanda::Header qw( :constants );
use Amanda::MainLoop;
use Amanda::Util qw( quote_string );
use Amanda::DB::Catalog;
use Amanda::Recovery::Planner;
use Amanda::Recovery::Scan;
use Amanda::Recovery::Clerk;
use Amanda::Taper::Scan;
use Amanda::Taper::Scribe qw( get_splitting_args_from_config );
use Amanda::Changer qw( :constants );
use Amanda::Cmdline;
use Amanda::Paths;
use Amanda::Logfile qw( :logtype_t log_add log_add_full
			log_rename $amanda_log_trace_log make_stats );
use Amanda::Util qw ( match_datestamp match_level );

use base qw(
    Amanda::Recovery::Clerk::Feedback
    Amanda::Taper::Scribe::Feedback
);

sub new {
    my $class = shift;
    my %params = @_;

bless {
	quiet => $params{'quiet'},
	fulls_only => $params{'fulls_only'},
	opt_export => $params{'opt_export'},
	opt_dumpspecs => $params{'opt_dumpspecs'},
	opt_dry_run => $params{'opt_dry_run'},
	config_name => $params{'config_name'},

src_write_timestamp => $params{'src_write_timestamp'},

dst_changer => $params{'dst_changer'},
	dst_autolabel => $params{'dst_autolabel'},
	dst_write_timestamp => $params{'dst_write_timestamp'},

src => undef,
	dst => undef,
	cleanup => {},

exporting => 0, # is an export in progress?
	call_after_export => undef, # call this when export complete
	config_overrides_opts => $params{'config_overrides_opts'},
	trace_log_filename => getconf($CNF_LOGDIR) . "/log",

# called when the operation is complete, with the exit
	# status
	exit_cb => undef,
    }, $class;
}

sub run_subprocess {
    my ($proc, @args) = @_;

my $pid = POSIX::fork();
    if ($pid == 0) {
	my $null = POSIX::open("/dev/null", POSIX::O_RDWR);
	POSIX::dup2($null, 0);
	POSIX::dup2($null, 1);
	POSIX::dup2($null, 2);
	exec $proc, @args;
	die "Could not exec $proc: $!";
    }
    waitpid($pid, 0);
    my $s = $? >> 8;
    debug("$proc exited with code $s: $!");
}

sub do_amcleanup {
    my $self = shift;

return 1 unless -f $self->{'trace_log_filename'};

# logfiles are still around.  First, try an amcleanup -p to see if
    # the actual processes are already dead
    debug("runing amcleanup -p");
    run_subprocess("$sbindir/amcleanup", '-p', $self->{'config_name'},
		   $self->{'config_overrides_opts'});

return 1 unless -f $self->{'trace_log_filename'};

return 0;
}

sub bail_already_running() {
    my $self = shift;
    my $msg = "An Amanda process is already running - please run amcleanup manually";
    print "$msg\n";
    debug($msg);
    $self->{'exit_cb'}->(1);
}

sub run {
    my $self = shift;
    my ($exit_cb) = @_;

die "already called" if $self->{'exit_cb'};
    $self->{'exit_cb'} = $exit_cb;

# check that the label template is valid
    my $dst_label_template = $self->{'dst_autolabel'}->{'template'};
    return $self->failure("Invalid label template '$dst_label_template'")
	if ($dst_label_template =~ /%[^%]+%/
	    or $dst_label_template =~ /^[^%]+$/);

# open up a trace log file and put our imprimatur on it, unless dry_runing
    if (!$self->{'opt_dry_run'}) {
	if (!$self->do_amcleanup()) {
	    return $self->bail_already_running();
	}
	log_add($L_INFO, "amvault pid $$");

# Check we own the log file
	open(my $tl, "<", $self->{'trace_log_filename'})
	    or die("could not open trace log file '$self->{'trace_log_filename'}': $!");
	if (<$tl> !~ /^INFO amvault amvault pid $$/) {
	    debug("another amdump raced with this one, and won");
	    close($tl);
	    return $self->bail_already_running();
	}
	close($tl);
	log_add($L_START, "date " . $self->{'dst_write_timestamp'});
	Amanda::Debug::add_amanda_log_handler($amanda_log_trace_log);
	$self->{'cleanup'}{'roll_trace_log'} = 1;
    }

$self->setup_src();
}

sub setup_src {
    my $self = shift;

my $src = $self->{'src'} = {};

# put together a clerk, which of course requires a changer, scan,
    # interactivity, and feedback
    my $chg = Amanda::Changer->new();
    return $self->failure("Error opening source changer: $chg")
	if $chg->isa('Amanda::Changer::Error');
    $src->{'chg'} = $chg;

$src->{'seen_labels'} = {};

$src->{'interactivity'} = main::Interactivity->new();

$src->{'scan'} = Amanda::Recovery::Scan->new(
	    chg => $src->{'chg'},
	    interactivity => $src->{'interactivity'});

$src->{'clerk'} = Amanda::Recovery::Clerk->new(
	    changer => $src->{'chg'},
	    feedback => $self,
	    scan => $src->{'scan'});
    $self->{'cleanup'}{'quit_clerk'} = 1;

# translate "latest" into the most recent timestamp that wasn't created by amvault
    if (defined $self->{'src_write_timestamp'} && $self->{'src_write_timestamp'} eq "latest") {
	my $ts = $self->{'src_write_timestamp'} =
	    Amanda::DB::Catalog::get_latest_write_timestamp(types => ['amdump', 'amflush']);
	return $self->failure("No dumps found")
	    unless defined $ts;

$self->vlog("Using latest timestamp: $ts");
    }

# we need to combine fulls_only, src_write_timestamp, and the set
    # of dumpspecs.  If they contradict one another, then drop the
    # non-matching dumpspec with a warning.
    my @dumpspecs;
    if ($self->{'opt_dumpspecs'}) {
	my $level = $self->{'fulls_only'}? "0" : undef;
	my $swt = $self->{'src_write_timestamp'};

# filter and adjust the dumpspecs
	for my $ds (@{$self->{'opt_dumpspecs'}}) {
	    my $ds_host = $ds->{'host'};
	    my $ds_disk = $ds->{'disk'};
	    my $ds_datestamp = $ds->{'datestamp'};
	    my $ds_level = $ds->{'level'};
	    my $ds_write_timestamp = $ds->{'write_timestamp'};

if ($swt) {
		# it's impossible for parse_dumpspecs to set write_timestamp,
		# so there's no risk of overlap here
		$ds_write_timestamp = $swt;
	    }

if (defined $level) {
		if (defined $ds_level &&
		    !match_level($ds_level, $level)) {
		    $self->vlog("WARNING: dumpspec " . $ds->format() .
			    " specifies non-full dumps, contradicting --fulls-only;" .
			    " ignoring dumpspec");
		    next;
		}
		$ds_level = $level;
	    }

# create a new dumpspec, since dumpspecs are immutable
	    push @dumpspecs, Amanda::Cmdline::dumpspec_t->new(
		$ds_host, $ds_disk, $ds_datestamp, $ds_level, $ds_write_timestamp);
	}
    } else {
	# convert the timestamp and level to a dumpspec
	my $level = $self->{'fulls_only'}? "0" : undef;
	push @dumpspecs, Amanda::Cmdline::dumpspec_t->new(
		undef, undef, undef, $level, $self->{'src_write_timestamp'});
    }

# if we ignored all of the dumpspecs and didn't create any, then dump
    # nothing.  We do *not* want the wildcard "vault it all!" behavior.
    if (!@dumpspecs) {
	return $self->failure("No dumps to vault");
    }

if (!$self->{'opt_dry_run'}) {
	# summarize the requested dumps
	my $request;
	if ($self->{'src_write_timestamp'}) {
	    $request = "vaulting from volumes written " . $self->{'src_write_timestamp'};
	} else {
	    $request = "vaulting";
	}
	if ($self->{'opt_dumpspecs'}) {
	    $request .= " dumps matching dumpspecs:";
	}
	if ($self->{'fulls_only'}) {
	    $request .= " (fulls only)";
	}
	log_add($L_INFO, $request);

# and log the dumpspecs if they were given
	if ($self->{'opt_dumpspecs'}) {
	    for my $ds (@{$self->{'opt_dumpspecs'}}) {
		log_add($L_INFO, "  " . $ds->format());
	    }
	}
    }

Amanda::Recovery::Planner::make_plan(
	    dumpspecs => \@dumpspecs,
	    changer => $src->{'chg'},
	    plan_cb => sub { $self->plan_cb(@_) });
}

sub plan_cb {
    my $self = shift;
    my ($err, $plan) = @_;
    my $src = $self->{'src'};

return $self->failure($err) if $err;

$src->{'plan'} = $plan;

if ($self->{'opt_dry_run'}) {
	my $total_kb = Math::BigInt->new(0);

# iterate over each part of each dump, printing out the basic information
	for my $dump (@{$plan->{'dumps'}}) {
	    my @parts = @{$dump->{'parts'}};
	    shift @parts; # skip partnum 0
	    for my $part (@parts) {
		print STDOUT
		      ($part->{'label'} || $part->{'holding_file'}) . " " .
		      ($part->{'filenum'} || '') . " " .
		      $dump->{'hostname'} . " " .
		      $dump->{'diskname'} . " " .
		      $dump->{'dump_timestamp'} . " " .
		      $dump->{'level'} . "\n";
	    }
	    $total_kb += int $dump->{'kb'};
	}

print STDOUT "Total Size: $total_kb KB\n";

return $self->quit(0);
    }

# output some 'DISK amvault' lines to indicate the disks we will be vaulting
    my %seen;
    for my $dump (@{$plan->{'dumps'}}) {
	my $key = $dump->{'hostname'}."\0".$dump->{'diskname'};
	next if $seen{$key};
	$seen{$key} = 1;
	log_add($L_DISK, quote_string($dump->{'hostname'})
		 . " " . quote_string($dump->{'diskname'}));
    }

if (@{$plan->{'dumps'}} == 0) {
	return $self->failure("No dumps to vault");
    }

$self->setup_dst();
}

sub setup_dst {
    my $self = shift;
    my $dst = $self->{'dst'} = {};
    my $tlf = Amanda::Config::config_dir_relative(getconf($CNF_TAPELIST));
    my $tl = Amanda::Tapelist->new($tlf);

$dst->{'label'} = undef;
    $dst->{'tape_num'} = 0;

my $chg = Amanda::Changer->new($self->{'dst_changer'},
				   tapelist => $tl,
				   labelstr => getconf($CNF_LABELSTR),
				   autolabel => $self->{'dst_autolabel'});
    return $self->failure("Error opening destination changer: $chg")
	if $chg->isa('Amanda::Changer::Error');
    $dst->{'chg'} = $chg;

my $interactivity = Amanda::Interactivity->new(
					name => getconf($CNF_INTERACTIVITY));
    my $scan_name = getconf($CNF_TAPERSCAN);
    $dst->{'scan'} = Amanda::Taper::Scan->new(
	algorithm => $scan_name,
	changer => $dst->{'chg'},
	interactivity => $interactivity,
	tapelist => $tl,
	labelstr => getconf($CNF_LABELSTR),
	autolabel => $self->{'dst_autolabel'});

$dst->{'scribe'} = Amanda::Taper::Scribe->new(
	taperscan => $dst->{'scan'},
	feedback => $self);

$dst->{'scribe'}->start(
	write_timestamp => $self->{'dst_write_timestamp'},
	finished_cb => sub { $self->scribe_started(@_); })
}

sub scribe_started {
    my $self = shift;
    my ($err) = @_;

return $self->failure($err) if $err;

$self->{'cleanup'}{'quit_scribe'} = 1;

my $xfers_finished = sub {
	my ($err) = @_;
	return $self->failure($err) if $err;
	$self->quit(0);
    };

$self->xfer_dumps($xfers_finished);
}

sub xfer_dumps {
    my $self = shift;
    my ($finished_cb) = @_;

my $src = $self->{'src'};
    my $dst = $self->{'dst'};
    my ($xfer_src, $xfer_dst, $xfer, $n_threads, $last_partnum);
    my $current;

my $steps = define_steps
	    cb_ref => \$finished_cb;

step get_dump => sub {
	# reset tracking for teh current dump
	$self->{'current'} = $current = {
	    src_result => undef,
	    src_errors => undef,

dst_result => undef,
	    dst_errors => undef,

size => 0,
	    duration => 0.0,
	    total_duration => 0.0,
	    nparts => 0,
	    header => undef,
	    dump => undef,
	};

my $dump = $src->{'plan'}->shift_dump();
	if (!$dump) {
	    return $finished_cb->();
	}

$current->{'dump'} = $dump;

$steps->{'get_xfer_src'}->();
    };

step get_xfer_src => sub {
	$src->{'clerk'}->get_xfer_src(
	    dump => $current->{'dump'},
	    xfer_src_cb => $steps->{'got_xfer_src'})
    };

step got_xfer_src => sub {
        my ($errors, $header, $xfer_src_, $directtcp_supported) = @_;
	$xfer_src = $xfer_src_;

return $finished_cb->(join("\n", @$errors))
	    if $errors;

$current->{'header'} = $header;

# set up splitting args from the tapetype only, since we have no DLEs
	my $tt = lookup_tapetype(getconf($CNF_TAPETYPE));
	sub empty2undef { $_[0]? $_[0] : undef }
	my %xfer_dest_args;
	if ($tt) {
	    %xfer_dest_args = get_splitting_args_from_config(
		part_size_kb =>
		    empty2undef(tapetype_getconf($tt, $TAPETYPE_PART_SIZE)),
		part_cache_type_enum =>
		    empty2undef(tapetype_getconf($tt, $TAPETYPE_PART_CACHE_TYPE)),
		part_cache_dir =>
		    empty2undef(tapetype_getconf($tt, $TAPETYPE_PART_CACHE_DIR)),
		part_cache_max_size =>
		    empty2undef(tapetype_getconf($tt, $TAPETYPE_PART_CACHE_MAX_SIZE)),
	    );
	}
	# (else leave %xfer_dest_args empty, for no splitting)

$xfer_dst = $dst->{'scribe'}->get_xfer_dest(
	    max_memory => getconf($CNF_DEVICE_OUTPUT_BUFFER_SIZE),
	    can_cache_inform => 0,
	    %xfer_dest_args,
	);

# create and start the transfer
	$xfer = Amanda::Xfer->new([ $xfer_src, $xfer_dst ]);
	my $size = 0;
	$size = $current->{'dump'}->{'bytes'} if exists $current->{'dump'}->{'bytes'};
	$xfer->start($steps->{'handle_xmsg'}, 0, $size);

# count the "threads" running here (clerk and scribe)
	$n_threads = 2;

# and let both the scribe and the clerk know that data is in motion
	$src->{'clerk'}->start_recovery(
	    xfer => $xfer,
	    recovery_cb => $steps->{'recovery_cb'});
	$dst->{'scribe'}->start_dump(
	    xfer => $xfer,
	    dump_header => $header,
	    dump_cb => $steps->{'dump_cb'});
    };

step handle_xmsg => sub {
	$src->{'clerk'}->handle_xmsg(@_);
	$dst->{'scribe'}->handle_xmsg(@_);
    };

step recovery_cb => sub {
	my %params = @_;
	$current->{'src_result'} = $params{'result'};
	$current->{'src_errors'} = $params{'errors'};
	$steps->{'maybe_done'}->();
    };

step dump_cb => sub {
	my %params = @_;
	$current->{'dst_result'} = $params{'result'};
	$current->{'dst_errors'} = $params{'device_errors'};
	$current->{'size'} = $params{'size'};
	$current->{'duration'} = $params{'duration'};
	$current->{'nparts'} = $params{'nparts'};
	$current->{'total_duration'} = $params{'total_duration'};
	$steps->{'maybe_done'}->();
    };

step maybe_done => sub {
	return unless --$n_threads == 0;
	my @errors = (@{$current->{'src_errors'}}, @{$current->{'dst_errors'}});

# figure out how to log this, based on the results from the clerk (src)
	# and scribe (dst)
	my $logtype;
	if ($current->{'src_result'} eq 'DONE') {
	    if ($current->{'dst_result'} eq 'DONE') {
		$logtype = $L_DONE;
	    } elsif ($current->{'dst_result'} eq 'PARTIAL') {
		$logtype = $L_PARTIAL;
	    } else { # ($current->{'dst_result'} eq 'FAILED')
		$logtype = $L_FAIL;
	    }
	} else {
	    if ($current->{'size'} > 0) {
		$logtype = $L_PARTIAL;
	    } else {
		$logtype = $L_FAIL;
	    }
	}

my $dump = $current->{'dump'};
	my $stats = make_stats($current->{'size'}, $current->{'total_duration'},
				$dump->{'orig_kb'});
	my $msg = quote_string(join("; ", @errors));

# write a DONE/PARTIAL/FAIL log line
	if ($logtype == $L_FAIL) {
	    log_add_full($L_FAIL, "taper", sprintf("%s %s %s %s %s %s",
		quote_string($dump->{'hostname'}.""), # " is required for SWIG..
		quote_string($dump->{'diskname'}.""),
		$dump->{'dump_timestamp'},
		$dump->{'level'},
		'error',
		$msg));
	} else {
	    log_add_full($logtype, "taper", sprintf("%s %s %s %s %s %s%s",
		quote_string($dump->{'hostname'}.""), # " is required for SWIG..
		quote_string($dump->{'diskname'}.""),
		$dump->{'dump_timestamp'},
		$current->{'nparts'},
		$dump->{'level'},
		$stats,
		($logtype == $L_PARTIAL and @errors)? " $msg" : ""));
	}

if (@errors) {
	    return $finished_cb->("transfer failed: " .  join("; ", @errors));
	} else {
	    # rinse, wash, and repeat
	    return $steps->{'get_dump'}->();
	}
    };
}

sub quit {
    my $self = shift;
    my ($exit_status) = @_;
    my $exit_cb = $self->{'exit_cb'};

my $steps = define_steps
	    cb_ref => \$exit_cb;

# the export may not start until we quit the scribe, so wait for it now..
    step check_exporting => sub {
	# if we're exporting the final volume, wait for that to complete
	if ($self->{'exporting'}) {
	    $self->{'call_after_export'} = $steps->{'quit_scribe'};
	} else {
	    $steps->{'quit_scribe'}->();
	}
    };

# we may have several resources to clean up..
    step quit_scribe => sub {
	if ($self->{'cleanup'}{'quit_scribe'}) {
	    debug("quitting scribe..");
	    $self->{'dst'}{'scribe'}->quit(
		finished_cb => $steps->{'quit_scribe_finished'});
	} else {
	    $steps->{'quit_clerk'}->();
	}
    };

step quit_scribe_finished => sub {
	$self->{'dst'}{'scan'}->quit();
	my ($err) = @_;
	if ($err) {
	    print STDERR "$err\n";
	    $exit_status = 1;
	}

$steps->{'quit_clerk'}->();
    };

step quit_clerk => sub {
	if ($self->{'cleanup'}{'quit_clerk'}) {
	    debug("quitting clerk..");
	    $self->{'src'}{'clerk'}->quit(
		finished_cb => $steps->{'quit_clerk_finished'});
	} else {
	    $steps->{'roll_log'}->();
	}
    };

step quit_clerk_finished => sub {
	my ($err) = @_;
	if ($err) {
	    print STDERR "$err\n";
	    $exit_status = 1;
	}

$steps->{'roll_log'}->();
    };

step roll_log => sub {
	if (defined $self->{'src'}->{'chg'}) {
	    $self->{'src'}->{'chg'}->quit();
	    $self->{'src'}->{'chg'} = undef;
	}
	if (defined $self->{'dst'}->{'chg'}) {
	    $self->{'dst'}->{'chg'}->quit();
	    $self->{'dst'}->{'chg'} = undef;
	}
	if ($self->{'cleanup'}{'roll_trace_log'}) {
	    log_add_full($L_FINISH, "driver", "fake driver finish");
	    log_add($L_INFO, "pid-done $$");

my @amreport_cmd = ("$sbindir/amreport", $self->{'config_name'}, "--from-amdump",
				 @{$self->{'config_overrides_opts'}});
	    debug("invoking amreport (" . join(" ", @amreport_cmd) . ")");
	    system(@amreport_cmd);

debug("rolling logfile..");
	    log_rename($self->{'dst_write_timestamp'});
	}

$exit_cb->($exit_status);
    };
}

## utilities

sub failure {
    my $self = shift;
    my ($msg) = @_;
    print STDERR "$msg\n";

debug("failure: $msg");

# if we've got a logfile open that will be rolled, we might as well log
    # an error.
    if ($self->{'cleanup'}{'roll_trace_log'}) {
	log_add($L_FATAL, "$msg");
    }
    $self->quit(1);
}

sub vlog {
    my $self = shift;
    if (!$self->{'quiet'}) {
	print @_, "\n";
    }
}

## scribe feedback methods

# note that the trace log calls here all add "taper", as we're dry_runing
# to be the taper in the logfiles.

sub request_volume_permission {
    my $self = shift;
    my %params = @_;

# sure, use all the volumes you want, no problem!
    # TODO: limit to a vaulting-specific value of runtapes
    $self->{'dst'}->{'scribe'}->start_scan();
    $params{'perm_cb'}->(allow => 1);
}

sub scribe_notif_new_tape {
    my $self = shift;
    my %params = @_;

if ($params{'volume_label'}) {
	$self->{'dst'}->{'label'} = $params{'volume_label'};

# add to the trace log
	log_add_full($L_START, "taper", sprintf("datestamp %s label %s tape %s",
		$self->{'dst_write_timestamp'},
		quote_string($self->{'dst'}->{'label'}),
		++$self->{'dst'}->{'tape_num'}));
    } else {
	$self->{'dst'}->{'label'} = undef;

print STDERR "Could not start new destination volume: $params{error}";
    }
}

sub scribe_notif_part_done {
    my $self = shift;
    my %params = @_;

$self->{'last_partnum'} = $params{'partnum'};

my $stats = make_stats($params{'size'}, $params{'duration'}, $self->{'orig_kb'});

# log the part, using PART or PARTPARTIAL
    my $hdr = $self->{'current'}->{'header'};
    my $logbase = sprintf("%s %s %s %s %s %s/%s %s %s",
	quote_string($self->{'dst'}->{'label'}),
	$params{'fileno'},
	quote_string($hdr->{'name'}.""), # " is required for SWIG..
	quote_string($hdr->{'disk'}.""),
	$hdr->{'datestamp'}."",
	$params{'partnum'}, -1, # totalparts is always -1
	$hdr->{'dumplevel'},
	$stats);
    if ($params{'successful'}) {
	log_add_full($L_PART, "taper", $logbase);
    } else {
	log_add_full($L_PARTPARTIAL, "taper",
		"$logbase \"No space left on device\"");
    }

if ($params{'successful'}) {
	$self->vlog("Wrote $self->{dst}->{label}:$params{'fileno'}: " . $hdr->summary());
    }
}

sub scribe_notif_log_info {
    my $self = shift;
    my %params = @_;

debug("$params{'message'}");
    log_add_full($L_INFO, "taper", $params{'message'});
}

sub scribe_notif_tape_done {
    my $self = shift;
    my %params = @_;

# immediately flag that we are busy exporting, to prevent amvault from
    # quitting too soon.  The 'done' step will clear this flag.  We increment
    # and decrement this to allow for the (unlikely) situation that multiple
    # exports are going on simultaneously.
    $self->{'exporting'}++;

my $finished_cb = $params{'finished_cb'};
    my $steps = define_steps
	cb_ref => \$finished_cb;

step check_option => sub {
	if (!$self->{'opt_export'}) {
	    return $steps->{'done'}->();
	}

$steps->{'get_inventory'}->();
    };
    step get_inventory => sub {
	$self->{'dst'}->{'chg'}->inventory(
	    inventory_cb => $steps->{'inventory_cb'});
    };

step inventory_cb => sub {
	my ($err, $inventory) = @_;
	if ($err) {
	    print STDERR "Could not get destination inventory: $err\n";
	    return $steps->{'done'}->();
	}

# find the slots we want in the inventory
	my ($ie_slot, $from_slot);
	for my $info (@$inventory) {
	    if (defined $info->{'state'}
		&& $info->{'state'} != Amanda::Changer::SLOT_FULL
		&& $info->{'import_export'}) {
		$ie_slot = $info->{'slot'};
	    }
	    if ($info->{'label'} and $info->{'label'} eq $params{'volume_label'}) {
		$from_slot = $info->{'slot'};
	    }
	}

if (!$ie_slot) {
	    print STDERR "No import/export slots available; skipping export\n";
	    return $steps->{'done'}->();
	} elsif (!$from_slot) {
	    print STDERR "Could not find the just-written tape; skipping export\n";
	    return $steps->{'done'}->();
	} else {
	    return $steps->{'do_move'}->($ie_slot, $from_slot);
	}
    };

step do_move => sub {
	my ($ie_slot, $from_slot) = @_;

# TODO: there is a risk here that the volume is no longer in the slot
	# where we expect it to be, because the taperscan has moved it.  A
	# failure from move() is not fatal, though, so this will only cause the
	# volume to be left un-exported.

$self->{'dst'}->{'chg'}->move(
	    from_slot => $from_slot,
	    to_slot => $ie_slot,
	    finished_cb => $steps->{'moved'});
    };

step moved => sub {
	my ($err) = @_;
	if ($err) {
	    print STDERR "While exporting just-written tape: $err (ignored)\n";
	}
	$steps->{'done'}->();
    };

step done => sub {
	if (--$self->{'exporting'} == 0) {
	    if ($self->{'call_after_export'}) {
		my $cae = $self->{'call_after_export'};
		$self->{'call_after_export'} = undef;
		$cae->();
	    }
	}
	$finished_cb->();
    };
}

## clerk feedback methods

sub clerk_notif_part {
    my $self = shift;
    my ($label, $fileno, $header) = @_;

# see if this is a new label
    if (!exists $self->{'src'}->{'seen_labels'}->{$label}) {
	$self->{'src'}->{'seen_labels'}->{$label} = 1;
	log_add($L_INFO, "reading from source volume '$label'");
    }

$self->vlog("Reading $label:$fileno: ", $header->summary());
}

sub clerk_notif_holding {
    my $self = shift;
    my ($filename, $header) = @_;

# this used to give the fd from which the holding file was being read.. why??
    $self->vlog("Reading '$filename'", $header->summary());
}

## Application initialization
package main;

use Amanda::Config qw( :init :getconf );
use Amanda::Debug qw( :logging );
use Amanda::Util qw( :constants );
use Getopt::Long;
use Amanda::Cmdline qw( :constants parse_dumpspecs );

sub usage {
    my ($msg) = @_;

print STDERR <<EOF;
**NOTE** this interface is under development and will change in future releases!

Usage: amvault [-o configoption...] [-q] [--quiet] [-n] [--dry-run]
	   [--fulls-only] [--export] [--src-timestamp src-timestamp]
	   [--exact-match]
	   --label-template label-template --dst-changer dst-changer
	   [--autolabel autolabel-arg...]
	   config
	   [hostname [ disk [ date [ level [ hostname [...] ] ] ] ]]

-o: configuration override (see amanda(8))
    -q: quiet progress messages
    --fulls-only: only copy full (level-0) dumps
    --export: move completed destination volumes to import/export slots
    --src-timestamp: the timestamp of the Amanda run that should be vaulted
    --label-template: the template to use for new volume labels
    --dst-changer: the changer to which dumps should be written
    --autolabel: similar to the amanda.conf parameter; may be repeated (default: empty)

Copies data from the run with timestamp <src-timestamp> onto volumes using
the changer <dst-changer>, labeling new volumes with <label-template>.  If
<src-timestamp> is "latest", then the most recent run of amdump or amflush
will be used.  If any dumpspecs are included (<host-expr> and so on), then only
dumps matching those dumpspecs will be dumped.  At least one of --fulls-only,
--src-timestamp, or a dumpspec must be specified.

EOF
    if ($msg) {
	print STDERR "ERROR: $msg\n";
    }
    exit(1);
}

Amanda::Util::setup_application("amvault", "server", $CONTEXT_CMDLINE);

my $config_overrides = new_config_overrides($#ARGV+1);
my @config_overrides_opts;
my $opt_quiet = 0;
my $opt_dry_run = 0;
my $opt_fulls_only = 0;
my $opt_exact_match = 0;
my $opt_export = 0;
my $opt_autolabel = {};
my $opt_autolabel_seen = 0;
my $opt_src_write_timestamp;
my $opt_dst_changer;

sub set_label_template {
    usage("only one --label-template allowed") if $opt_autolabel->{'template'};
    $opt_autolabel->{'template'} = $_[1];
}

sub add_autolabel {
    my ($opt, $val) = @_;
    $val = lc($val);
    $val =~ s/-/_/g;

$opt_autolabel_seen = 1;
    my @ok = qw(other_config non_amanda volume_error empty);
    for (@ok) {
	if ($val eq $_) {
	    $opt_autolabel->{$_} = 1;
	    return;
	}
    }
    if ($val eq 'any') {
	for (@ok) {
	    $opt_autolabel->{$_} = 1;
	}
	return;
    }
    usage("unknown --autolabel value '$val'");
}

debug("Arguments: " . join(' ', @ARGV));
Getopt::Long::Configure(qw{ bundling });
GetOptions(
    'o=s' => sub {
	push @config_overrides_opts, "-o" . $_[1];
	add_config_override_opt($config_overrides, $_[1]);
    },
    'q|quiet' => \$opt_quiet,
    'n|dry-run' => \$opt_dry_run,
    'fulls-only' => \$opt_fulls_only,
    'exact-match' => \$opt_exact_match,
    'export' => \$opt_export,
    'label-template=s' => \&set_label_template,
    'autolabel=s' => \&add_autolabel,
    'src-timestamp=s' => \$opt_src_write_timestamp,
    'dst-changer=s' => \$opt_dst_changer,
    'version' => \&Amanda::Util::version_opt,
    'help' => \&usage,
) or usage("usage error");
$opt_autolabel->{'empty'} = 1 unless $opt_autolabel_seen;

usage("not enough arguments") unless (@ARGV >= 1);

my $config_name = shift @ARGV;
my $cmd_flags = $CMDLINE_PARSE_DATESTAMP|$CMDLINE_PARSE_LEVEL;
$cmd_flags |= $CMDLINE_EXACT_MATCH if $opt_exact_match;
my @opt_dumpspecs = parse_dumpspecs(\@ARGV, $cmd_flags)
    if (@ARGV);

usage("no --label-template given") unless $opt_autolabel->{'template'};
usage("no --dst-changer given") unless $opt_dst_changer;
usage("specify something to select the source dumps") unless
    $opt_src_write_timestamp or $opt_fulls_only or @opt_dumpspecs;

set_config_overrides($config_overrides);
config_init($CONFIG_INIT_EXPLICIT_NAME, $config_name);
my ($cfgerr_level, @cfgerr_errors) = config_errors();
if ($cfgerr_level >= $CFGERR_WARNINGS) {
    config_print_errors();
    if ($cfgerr_level >= $CFGERR_ERRORS) {
	print STDERR "errors processing config file\n";
	exit(1);
    }
}

Amanda::Util::finish_setup($RUNNING_AS_DUMPUSER);

my $exit_status;
my $exit_cb = sub {
    ($exit_status) = @_;
    Amanda::MainLoop::quit();
};

my $vault = Amvault->new(
    config_name => $config_name,
    src_write_timestamp => $opt_src_write_timestamp,
    dst_changer => $opt_dst_changer,
    dst_autolabel => $opt_autolabel,
    dst_write_timestamp => Amanda::Util::generate_timestamp(),
    opt_dumpspecs => @opt_dumpspecs? \@opt_dumpspecs : undef,
    opt_dry_run => $opt_dry_run,
    quiet => $opt_quiet,
    fulls_only => $opt_fulls_only,
    opt_export => $opt_export,
    config_overrides_opts => \@config_overrides_opts);
Amanda::MainLoop::call_later(sub { $vault->run($exit_cb) });
Amanda::MainLoop::run();

Amanda::Util::finish_application();
exit($exit_status);

X7ROOT File Manager

Editing: amvault

Upload File

Create Folder