From 8704d8f1d8a0e93255cdfe0e8cb50597f262ac1d Mon Sep 17 00:00:00 2001 From: Troy Dawson Date: Thu, 15 Oct 2020 14:00:19 -0700 Subject: [PATCH] RHEL 9.0.0 Alpha bootstrap The content of this branch was automatically imported from Fedora ELN with the following as its source: https://src.fedoraproject.org/rpms/xfsdump#4fe9e0d20cdda9617ef07340832416b7729e2b3d --- .gitignore | 11 ++ sources | 1 + xfsdump-ancient-getdents-code.patch | 284 ++++++++++++++++++++++++++++ xfsdump-getdents-ifdef-hell.patch | 214 +++++++++++++++++++++ xfsdump.spec | 224 ++++++++++++++++++++++ 5 files changed, 734 insertions(+) create mode 100644 sources create mode 100644 xfsdump-ancient-getdents-code.patch create mode 100644 xfsdump-getdents-ifdef-hell.patch create mode 100644 xfsdump.spec diff --git a/.gitignore b/.gitignore index e69de29..88103e0 100644 --- a/.gitignore +++ b/.gitignore @@ -0,0 +1,11 @@ +xfsdump-3.0.4.tar.gz +/xfsdump-3.0.5.tar.gz +/xfsdump-3.0.6.tar.gz +/xfsdump-3.1.0.tar.gz +/xfsdump-3.1.1.tar.gz +/xfsdump-3.1.2.tar.gz +/xfsdump-3.1.3.tar.gz +/xfsdump-3.1.4.tar.gz +/xfsdump-3.1.6.tar.gz +/xfsdump-3.1.8.tar.xz +/xfsdump-3.1.9.tar.xz diff --git a/sources b/sources new file mode 100644 index 0000000..908cb57 --- /dev/null +++ b/sources @@ -0,0 +1 @@ +SHA512 (xfsdump-3.1.9.tar.xz) = e8f9811d16fc06ab49fe2c109de0546c989575eca6e68b579c6d219a745f935952020069f58b357c5c87b944c5097ca2894466d328d09f06beb8a55880142351 diff --git a/xfsdump-ancient-getdents-code.patch b/xfsdump-ancient-getdents-code.patch new file mode 100644 index 0000000..cdbd7bc --- /dev/null +++ b/xfsdump-ancient-getdents-code.patch @@ -0,0 +1,284 @@ +commit b1d6979f1fae82acc79d27cf0add4d55da6d83cc +Author: Kyle McMartin +Date: Tue Apr 8 10:35:34 2014 +1000 + + remove ancient sys_getdents code paths + + Everything since 2.4.1 has supported getdents64... so let's remove all + the legacy code paths to handle it and just rely on getdents64 existing + everywhere. Also re-indent the function to not look entirely awful. + + Signed-off-by: Kyle McMartin + Reviewed-by: Christoph Hellwig + Signed-off-by: Dave Chinner + +diff --git a/common/getdents.c b/common/getdents.c +index 49d0d03..957bb5a 100644 +--- a/common/getdents.c ++++ b/common/getdents.c +@@ -35,47 +35,13 @@ + + #include + +-/* For Linux we need a special version of this file since the +- definition of `struct dirent' is not the same for the kernel and +- the libc. There is one additional field which might be introduced +- in the kernel structure in the future. +- +- Here is the kernel definition of `struct dirent' as of 2.1.20: */ +- +-struct kernel_dirent +- { +- long int d_ino; +- __kernel_off_t d_off; +- unsigned short int d_reclen; +- char d_name[256]; +- }; +- +-struct kernel_dirent64 +- { +- uint64_t d_ino; +- int64_t d_off; +- unsigned short int d_reclen; +- unsigned char d_type; +- char d_name[256]; +- }; +- +-#define DIRENT_SET_DP_INO(dp, value) (dp)->d_ino = (value) +- +-#define __set_errno(e) (errno = (e)) +- +-int __have_no_getdents64; +- +-#ifdef __NR_getdents64 +-# define __SYS_GETDENTS64(fd, buf, len) (syscall(SYS_getdents64, fd, buf, len)) +-#else +-# define __SYS_GETDENTS64(fd, buf, len) ({ __set_errno(ENOSYS); -1; }) +-#endif +- +-#ifdef __NR_getdents +-# define __SYS_GETDENTS(fd, buf, len) (syscall(SYS_getdents, fd, buf, len)) +-#else +-# define __SYS_GETDENTS(fd, buf, len) ({ __set_errno(ENOSYS); -1; }) +-#endif ++struct kernel_dirent64 { ++ uint64_t d_ino; ++ int64_t d_off; ++ unsigned short int d_reclen; ++ unsigned char d_type; ++ char d_name[256]; ++}; + + /* The problem here is that we cannot simply read the next NBYTES + bytes. We need to take the additional field into account. We use +@@ -85,148 +51,74 @@ int __have_no_getdents64; + reasonable number of bytes to read. If we should be wrong, we can + reset the file descriptor. In practice the kernel is limiting the + amount of data returned much more then the reduced buffer size. */ +-int +-getdents_wrap (int fd, char *buf, size_t nbytes) ++int getdents_wrap(int fd, char *buf, size_t nbytes) + { +- struct dirent *dp; +- off64_t last_offset = -1; +- ssize_t retval; +- +- if (!__have_no_getdents64) +- { +- int saved_errno = errno; +- char *kbuf = buf; +- size_t kbytes = nbytes; +- if (offsetof (struct dirent, d_name) +- < offsetof (struct kernel_dirent64, d_name) +- && nbytes <= sizeof (struct dirent)) +- { +- kbytes = nbytes + offsetof (struct kernel_dirent64, d_name) +- - offsetof (struct dirent, d_name); +- kbuf = alloca(kbytes); ++ struct dirent *dp; ++ struct kernel_dirent64 *kdp; ++ off64_t last_offset = -1; ++ ssize_t retval; ++ char *kbuf = buf; ++ size_t kbytes = nbytes; ++ const size_t size_diff = (offsetof(struct kernel_dirent64, d_name) ++ - offsetof(struct dirent, d_name)); ++ ++ if (offsetof(struct dirent, d_name) ++ < offsetof(struct kernel_dirent64, d_name) ++ && nbytes <= sizeof(struct dirent)) { ++ kbytes = nbytes + size_diff; ++ kbuf = alloca(kbytes); + } +- retval = __SYS_GETDENTS64(fd, kbuf, kbytes); +- if (retval != -1) +- { +- struct kernel_dirent64 *kdp; +- const size_t size_diff = (offsetof (struct kernel_dirent64, d_name) +- - offsetof (struct dirent, d_name)); +- +- /* If the structure returned by the kernel is identical to what we +- need, don't do any conversions. */ +- if (offsetof (struct dirent, d_name) +- == offsetof (struct kernel_dirent64, d_name) +- && sizeof (dp->d_ino) == sizeof (kdp->d_ino) +- && sizeof (dp->d_off) == sizeof (kdp->d_off)) +- return retval; +- +- dp = (struct dirent *)buf; +- kdp = (struct kernel_dirent64 *) kbuf; +- while ((char *) kdp < kbuf + retval) +- { +- const size_t alignment = __alignof__ (struct dirent); +- /* Since kdp->d_reclen is already aligned for the kernel +- structure this may compute a value that is bigger +- than necessary. */ +- size_t old_reclen = kdp->d_reclen; +- size_t new_reclen = ((old_reclen - size_diff + alignment - 1) +- & ~(alignment - 1)); +- uint64_t d_ino = kdp->d_ino; +- int64_t d_off = kdp->d_off; +- unsigned char d_type = kdp->d_type; + +- DIRENT_SET_DP_INO (dp, d_ino); +- dp->d_off = d_off; +- if ((sizeof (dp->d_ino) != sizeof (kdp->d_ino) +- && dp->d_ino != d_ino) +- || (sizeof (dp->d_off) != sizeof (kdp->d_off) +- && dp->d_off != d_off)) +- { +- /* Overflow. If there was at least one entry +- before this one, return them without error, +- otherwise signal overflow. */ +- if (last_offset != -1) +- { +- lseek64 (fd, last_offset, SEEK_SET); +- return (char *) dp - buf; +- } +- __set_errno (EOVERFLOW); +- return -1; ++ retval = syscall(SYS_getdents64, fd, kbuf, kbytes); ++ if (retval != -1) ++ return retval; ++ ++ /* If the structure returned by the kernel is identical to what we ++ need, don't do any conversions. */ ++ if (offsetof(struct dirent, d_name) ++ == offsetof(struct kernel_dirent64, d_name) ++ && sizeof(dp->d_ino) == sizeof(kdp->d_ino) ++ && sizeof(dp->d_off) == sizeof(kdp->d_off)) ++ return retval; ++ ++ dp = (struct dirent *)buf; ++ kdp = (struct kernel_dirent64 *)kbuf; ++ while ((char *)kdp < kbuf + retval) { ++ const size_t alignment = __alignof__(struct dirent); ++ /* Since kdp->d_reclen is already aligned for the kernel ++ structure this may compute a value that is bigger ++ than necessary. */ ++ size_t old_reclen = kdp->d_reclen; ++ size_t new_reclen = ((old_reclen - size_diff + alignment - 1) ++ & ~(alignment - 1)); ++ uint64_t d_ino = kdp->d_ino; ++ int64_t d_off = kdp->d_off; ++ unsigned char d_type = kdp->d_type; ++ ++ dp->d_ino = d_ino; ++ dp->d_off = d_off; ++ if ((sizeof(dp->d_ino) != sizeof(kdp->d_ino)) ++ || (sizeof(dp->d_off) != sizeof(kdp->d_off))) { ++ /* Overflow. If there was at least one entry ++ before this one, return them without error, ++ otherwise signal overflow. */ ++ if (last_offset != -1) { ++ lseek64(fd, last_offset, SEEK_SET); ++ return (char *)dp - buf; ++ } ++ errno = EOVERFLOW; ++ return -1; + } + +- last_offset = d_off; +- dp->d_reclen = new_reclen; +- dp->d_type = d_type; +- memmove (dp->d_name, kdp->d_name, +- old_reclen - offsetof (struct kernel_dirent64, d_name)); ++ last_offset = d_off; ++ dp->d_reclen = new_reclen; ++ dp->d_type = d_type; ++ memmove(dp->d_name, kdp->d_name, ++ old_reclen - offsetof(struct kernel_dirent64, d_name)); + +- dp = (struct dirent *) ((char *) dp + new_reclen); +- kdp = (struct kernel_dirent64 *) ((char *) kdp + old_reclen); +- } +- +- return (char *) dp - buf; ++ dp = (struct dirent *)((char *)dp + new_reclen); ++ kdp = (struct kernel_dirent64 *)((char *)kdp + old_reclen); + } + +- __set_errno (saved_errno); +- __have_no_getdents64 = 1; +- } +- +- /* fallback to getdents */ +- { +- size_t red_nbytes; +- struct kernel_dirent *skdp, *kdp; +- const size_t size_diff = (offsetof (struct dirent, d_name) +- - offsetof (struct kernel_dirent, d_name)); +- +- red_nbytes = MIN (nbytes +- - ((nbytes / (offsetof (struct dirent, d_name) + 14)) +- * size_diff), +- nbytes - size_diff); +- +- dp = (struct dirent *) buf; +- skdp = kdp = alloca (red_nbytes); +- +- retval = __SYS_GETDENTS(fd, kdp, red_nbytes); +- if (retval == -1) +- return -1; +- +- while ((char *) kdp < (char *) skdp + retval) +- { +- const size_t alignment = __alignof__ (struct dirent); +- /* Since kdp->d_reclen is already aligned for the kernel structure +- this may compute a value that is bigger than necessary. */ +- size_t new_reclen = ((kdp->d_reclen + size_diff + alignment - 1) +- & ~(alignment - 1)); +- if ((char *) dp + new_reclen > buf + nbytes) +- { +- /* Our heuristic failed. We read too many entries. Reset +- the stream. */ +- assert (last_offset != -1); +- lseek64 (fd, last_offset, SEEK_SET); +- +- if ((char *) dp == buf) +- { +- /* The buffer the user passed in is too small to hold even +- one entry. */ +- __set_errno (EINVAL); +- return -1; +- } +- +- break; +- } +- +- last_offset = kdp->d_off; +- DIRENT_SET_DP_INO(dp, kdp->d_ino); +- dp->d_off = kdp->d_off; +- dp->d_reclen = new_reclen; +- dp->d_type = DT_UNKNOWN; +- memcpy (dp->d_name, kdp->d_name, +- kdp->d_reclen - offsetof (struct kernel_dirent, d_name)); +- +- dp = (struct dirent *) ((char *) dp + new_reclen); +- kdp = (struct kernel_dirent *) (((char *) kdp) + kdp->d_reclen); +- } +- } +- +- return (char *) dp - buf; ++ return (char *)dp - buf; + } diff --git a/xfsdump-getdents-ifdef-hell.patch b/xfsdump-getdents-ifdef-hell.patch new file mode 100644 index 0000000..b6fe794 --- /dev/null +++ b/xfsdump-getdents-ifdef-hell.patch @@ -0,0 +1,214 @@ +commit 9ed517b63df35876681e8883388fbf154afda0c1 +Author: Kyle McMartin +Date: Tue Apr 8 10:33:57 2014 +1000 + + xfsdump: getdents.c: clean up ifdef-hell around sys_getdents + + Remove the ifdef-hell imported from glibc around getdents64. Everything + since 2.4.1 supports things properly and this seems like a sensible + clean up, so lets just assume it exists and handle it by falling back + if not. + + Additionally, if the old getdents syscall doesn't exist, just stub out + the actual syscall and return ENOSYS. + + Signed-off-by: Kyle McMartin + Reviewed-by: Christoph Hellwig + Signed-off-by: Dave Chinner + +diff --git a/common/getdents.c b/common/getdents.c +index e9ba25a..49d0d03 100644 +--- a/common/getdents.c ++++ b/common/getdents.c +@@ -35,44 +35,6 @@ + + #include + +-/* Copied from kernel-features.h for __ASSUME_GETDENTS64_SYSCALL */ +-#ifndef __LINUX_KERNEL_VERSION +-/* We assume the worst; all kernels should be supported. */ +-# define __LINUX_KERNEL_VERSION 0 +-#endif +-/* The getdents64 syscall was introduced in 2.4.0-test7. We test for +- 2.4.1 for the earliest version we know the syscall is available. */ +-#if __LINUX_KERNEL_VERSION >= 132097 +-# define __ASSUME_GETDENTS64_SYSCALL 1 +-#endif +-/* There are an infinite number of PA-RISC kernel versions numbered +- 2.4.0. But they've not really been released as such. We require +- and expect the final version here. */ +-#ifdef __hppa__ +-# define __ASSUME_GETDENTS64_SYSCALL 1 +-#endif +- +-#ifndef __set_errno +-#define __set_errno(e) (errno = (e)) +-#endif +- +- +-#ifdef __NR_getdents64 +-# ifndef __ASSUME_GETDENTS64_SYSCALL +-# ifndef __GETDENTS +-/* The variable is shared between all *getdents* calls. */ +-int __have_no_getdents64; +-# else +-extern int __have_no_getdents64; +-# endif +-# endif +-/* Earlier versions of glibc don't define SYS_getdents64 at all */ +-# ifndef SYS_getdents64 +-# define SYS_getdents64 __NR_getdents64 +-# endif +-#endif +- +- + /* For Linux we need a special version of this file since the + definition of `struct dirent' is not the same for the kernel and + the libc. There is one additional field which might be introduced +@@ -97,11 +59,22 @@ struct kernel_dirent64 + char d_name[256]; + }; + +-#ifndef DIRENT_TYPE +-# define DIRENT_TYPE struct dirent ++#define DIRENT_SET_DP_INO(dp, value) (dp)->d_ino = (value) ++ ++#define __set_errno(e) (errno = (e)) ++ ++int __have_no_getdents64; ++ ++#ifdef __NR_getdents64 ++# define __SYS_GETDENTS64(fd, buf, len) (syscall(SYS_getdents64, fd, buf, len)) ++#else ++# define __SYS_GETDENTS64(fd, buf, len) ({ __set_errno(ENOSYS); -1; }) + #endif +-#ifndef DIRENT_SET_DP_INO +-# define DIRENT_SET_DP_INO(dp, value) (dp)->d_ino = (value) ++ ++#ifdef __NR_getdents ++# define __SYS_GETDENTS(fd, buf, len) (syscall(SYS_getdents, fd, buf, len)) ++#else ++# define __SYS_GETDENTS(fd, buf, len) ({ __set_errno(ENOSYS); -1; }) + #endif + + /* The problem here is that we cannot simply read the next NBYTES +@@ -115,50 +88,43 @@ struct kernel_dirent64 + int + getdents_wrap (int fd, char *buf, size_t nbytes) + { +- DIRENT_TYPE *dp; ++ struct dirent *dp; + off64_t last_offset = -1; + ssize_t retval; + +-#ifdef __NR_getdents64 +-# ifndef __ASSUME_GETDENTS64_SYSCALL + if (!__have_no_getdents64) +-# endif + { +-# ifndef __ASSUME_GETDENTS64_SYSCALL + int saved_errno = errno; +-# endif + char *kbuf = buf; + size_t kbytes = nbytes; +- if (offsetof (DIRENT_TYPE, d_name) ++ if (offsetof (struct dirent, d_name) + < offsetof (struct kernel_dirent64, d_name) +- && nbytes <= sizeof (DIRENT_TYPE)) ++ && nbytes <= sizeof (struct dirent)) + { + kbytes = nbytes + offsetof (struct kernel_dirent64, d_name) +- - offsetof (DIRENT_TYPE, d_name); ++ - offsetof (struct dirent, d_name); + kbuf = alloca(kbytes); + } +- retval = syscall(SYS_getdents64, fd, kbuf, kbytes); +-# ifndef __ASSUME_GETDENTS64_SYSCALL +- if (retval != -1 && errno != -EINVAL) +-# endif ++ retval = __SYS_GETDENTS64(fd, kbuf, kbytes); ++ if (retval != -1) + { + struct kernel_dirent64 *kdp; + const size_t size_diff = (offsetof (struct kernel_dirent64, d_name) +- - offsetof (DIRENT_TYPE, d_name)); ++ - offsetof (struct dirent, d_name)); + + /* If the structure returned by the kernel is identical to what we + need, don't do any conversions. */ +- if (offsetof (DIRENT_TYPE, d_name) ++ if (offsetof (struct dirent, d_name) + == offsetof (struct kernel_dirent64, d_name) + && sizeof (dp->d_ino) == sizeof (kdp->d_ino) + && sizeof (dp->d_off) == sizeof (kdp->d_off)) + return retval; + +- dp = (DIRENT_TYPE *)buf; ++ dp = (struct dirent *)buf; + kdp = (struct kernel_dirent64 *) kbuf; + while ((char *) kdp < kbuf + retval) + { +- const size_t alignment = __alignof__ (DIRENT_TYPE); ++ const size_t alignment = __alignof__ (struct dirent); + /* Since kdp->d_reclen is already aligned for the kernel + structure this may compute a value that is bigger + than necessary. */ +@@ -194,41 +160,39 @@ getdents_wrap (int fd, char *buf, size_t nbytes) + memmove (dp->d_name, kdp->d_name, + old_reclen - offsetof (struct kernel_dirent64, d_name)); + +- dp = (DIRENT_TYPE *) ((char *) dp + new_reclen); ++ dp = (struct dirent *) ((char *) dp + new_reclen); + kdp = (struct kernel_dirent64 *) ((char *) kdp + old_reclen); + } + + return (char *) dp - buf; + } + +-# ifndef __ASSUME_GETDENTS64_SYSCALL + __set_errno (saved_errno); + __have_no_getdents64 = 1; +-# endif + } +-#endif ++ ++ /* fallback to getdents */ + { + size_t red_nbytes; + struct kernel_dirent *skdp, *kdp; +- const size_t size_diff = (offsetof (DIRENT_TYPE, d_name) ++ const size_t size_diff = (offsetof (struct dirent, d_name) + - offsetof (struct kernel_dirent, d_name)); + + red_nbytes = MIN (nbytes +- - ((nbytes / (offsetof (DIRENT_TYPE, d_name) + 14)) ++ - ((nbytes / (offsetof (struct dirent, d_name) + 14)) + * size_diff), + nbytes - size_diff); + +- dp = (DIRENT_TYPE *) buf; ++ dp = (struct dirent *) buf; + skdp = kdp = alloca (red_nbytes); + +- retval = syscall(SYS_getdents, fd, kdp, red_nbytes); +- ++ retval = __SYS_GETDENTS(fd, kdp, red_nbytes); + if (retval == -1) + return -1; + + while ((char *) kdp < (char *) skdp + retval) + { +- const size_t alignment = __alignof__ (DIRENT_TYPE); ++ const size_t alignment = __alignof__ (struct dirent); + /* Since kdp->d_reclen is already aligned for the kernel structure + this may compute a value that is bigger than necessary. */ + size_t new_reclen = ((kdp->d_reclen + size_diff + alignment - 1) +@@ -259,7 +223,7 @@ getdents_wrap (int fd, char *buf, size_t nbytes) + memcpy (dp->d_name, kdp->d_name, + kdp->d_reclen - offsetof (struct kernel_dirent, d_name)); + +- dp = (DIRENT_TYPE *) ((char *) dp + new_reclen); ++ dp = (struct dirent *) ((char *) dp + new_reclen); + kdp = (struct kernel_dirent *) (((char *) kdp) + kdp->d_reclen); + } + } diff --git a/xfsdump.spec b/xfsdump.spec new file mode 100644 index 0000000..db62747 --- /dev/null +++ b/xfsdump.spec @@ -0,0 +1,224 @@ +Summary: Administrative utilities for the XFS filesystem +Name: xfsdump +Version: 3.1.9 +Release: 3%{?dist} +# Licensing based on generic "GNU GENERAL PUBLIC LICENSE" +# in source, with no mention of version. +License: GPL+ +URL: http://oss.sgi.com/projects/xfs/ +Source0: http://kernel.org/pub/linux/utils/fs/xfs/%{name}/%{name}-%{version}.tar.xz +BuildRequires: gcc +BuildRequires: libtool, gettext, gawk +BuildRequires: xfsprogs-devel, libuuid-devel, libattr-devel ncurses-devel +Requires: xfsprogs >= 2.6.30, attr >= 2.0.0 + +%description +The xfsdump package contains xfsdump, xfsrestore and a number of +other utilities for administering XFS filesystems. + +xfsdump examines files in a filesystem, determines which need to be +backed up, and copies those files to a specified disk, tape or other +storage medium. It uses XFS-specific directives for optimizing the +dump of an XFS filesystem, and also knows how to backup XFS extended +attributes. Backups created with xfsdump are "endian safe" and can +thus be transfered between Linux machines of different architectures +and also between IRIX machines. + +xfsrestore performs the inverse function of xfsdump; it can restore a +full backup of a filesystem. Subsequent incremental backups can then +be layered on top of the full backup. Single files and directory +subtrees may be restored from full or partial backups. + +%prep +%setup -q + +%build +%configure + +make V=1 %{?_smp_mflags} + +%install +rm -rf $RPM_BUILD_ROOT +make DIST_ROOT=$RPM_BUILD_ROOT install +# remove non-versioned docs location +rm -rf $RPM_BUILD_ROOT/%{_datadir}/doc/xfsdump/ + +# Bit of a hack to move files from /sbin to /usr/sbin +(cd $RPM_BUILD_ROOT/%{_sbindir}; mv ../../sbin/xfsdump .) +(cd $RPM_BUILD_ROOT/%{_sbindir}; mv ../../sbin/xfsrestore .) + +# Create inventory dir (otherwise created @ runtime) +mkdir -p $RPM_BUILD_ROOT/%{_sharedstatedir}/xfsdump/inventory + +%find_lang %{name} + +%files -f %{name}.lang +%doc README doc/COPYING doc/CHANGES doc/README.xfsdump doc/xfsdump_ts.txt +%{_mandir}/man8/* +%{_sbindir}/* +%{_sharedstatedir}/xfsdump/inventory + +%changelog +* Sat Aug 01 2020 Fedora Release Engineering - 3.1.9-3 +- Second attempt - Rebuilt for + https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Wed Jul 29 2020 Fedora Release Engineering - 3.1.9-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Fri Jan 31 2020 Eric Sandeen 3.1.9-1 +- New upstream release + +* Fri Jan 31 2020 Fedora Release Engineering - 3.1.8-7 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_32_Mass_Rebuild + +* Sat Jul 27 2019 Fedora Release Engineering - 3.1.8-6 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild + +* Sun Feb 03 2019 Fedora Release Engineering - 3.1.8-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild + +* Sat Jul 14 2018 Fedora Release Engineering - 3.1.8-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild + +* Mon Feb 26 2018 Eric Sandeen 3.1.8-3 +- BuildRequires: gcc + +* Fri Feb 09 2018 Fedora Release Engineering - 3.1.8-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild + +* Thu Sep 21 2017 Eric Sandeen 3.1.8-1 +- New upstream release + +* Thu Aug 03 2017 Fedora Release Engineering - 3.1.6-6 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild + +* Thu Jul 27 2017 Fedora Release Engineering - 3.1.6-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild + +* Thu Jun 08 2017 Eric Sandeen 3.1.6-4 +- Build with largefile support on 32-bit platforms + +* Sat Feb 11 2017 Fedora Release Engineering - 3.1.6-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_26_Mass_Rebuild + +* Fri Feb 05 2016 Fedora Release Engineering - 3.1.6-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild + +* Tue Nov 10 2015 Eric Sandeen 3.1.6-1 +- New upstream release + +* Fri Jun 19 2015 Fedora Release Engineering - 3.1.4-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_23_Mass_Rebuild + +* Mon Aug 18 2014 Fedora Release Engineering - 3.1.4-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_22_Mass_Rebuild + +* Thu Jul 17 2014 Eric Sandeen 3.1.4-1 +- New upstream release + +* Mon Jun 16 2014 Eric Sandeen 3.1.3-5 +- Fix aarch64 build (#926800) + +* Sun Jun 08 2014 Fedora Release Engineering - 3.1.3-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_Mass_Rebuild + +* Mon Jan 20 2014 Eric Sandeen 3.1.3-3 +- Add /var/lib/xfsdump/inventory to file list (was created runtime) + +* Sun Aug 04 2013 Fedora Release Engineering - 3.1.3-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_20_Mass_Rebuild + +* Wed May 08 2013 Eric Sandeen 3.1.3-1 +- New upstream release + +* Fri Feb 15 2013 Fedora Release Engineering - 3.1.2-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_19_Mass_Rebuild + +* Thu Dec 13 2012 Eric Sandeen 3.1.2-1 +- New upstream release, with non-broken tarball + +* Thu Dec 13 2012 Eric Sandeen 3.1.1-1 +- New upstream release + +* Sun Jul 22 2012 Fedora Release Engineering - 3.1.0-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild + +* Wed Mar 28 2012 Eric Sandeen 3.1.0-2 +- Move files out of /sbin to /usr/sbin + +* Fri Mar 23 2012 Eric Sandeen 3.1.0-1 +- New upstream release + +* Sat Jan 14 2012 Fedora Release Engineering - 3.0.6-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_17_Mass_Rebuild + +* Mon Oct 17 2011 Eric Sandeen 3.0.6-1 +- New upstream release + +* Thu Mar 31 2011 Eric Sandeen 3.0.5-1 +- New upstream release + +* Mon Feb 07 2011 Fedora Release Engineering - 3.0.4-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_15_Mass_Rebuild + +* Wed Jan 13 2010 Eric Sandeen 3.0.4-1 +- New upstream release + +* Mon Nov 30 2009 Dennis Gregorovic - 3.0.1-3.1 +- Rebuilt for RHEL 6 + +* Mon Jul 27 2009 Fedora Release Engineering - 3.0.1-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_12_Mass_Rebuild + +* Tue Jun 30 2009 Eric Sandeen 3.0.1-2 +- Fix up build-requires after e2fsprogs splitup + +* Tue May 05 2009 Eric Sandeen 3.0.1-1 +- New upstream release + +* Thu Feb 26 2009 Fedora Release Engineering - 3.0.0-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_11_Mass_Rebuild + +* Wed Feb 04 2009 Eric Sandeen 3.0.0-1 +- New upstream release + +* Wed Nov 12 2008 Eric Sandeen 2.2.48-2 +- Enable parallel builds + +* Sun Feb 10 2008 Eric Sandeen - 2.2.48-1 +- Update to xfsdump version 2.2.48 +- First build with gcc-4.3 + +* Mon Sep 10 2007 Eric Sandeen - 2.2.46-1 +- Update to xfsdump version 2.2.46 +- Dropped O_CREAT patch, now upstream + +* Fri Aug 24 2007 Eric Sandeen - 2.2.45-3 +- Update license tag +- Fix up O_CREAT opens with no mode +- Add gawk to buildrequires + +* Tue Jun 19 2007 Eric Sandeen - 2.2.45-2 +- Remove readline-devel & libtermcap-devel BuildRequires + +* Thu May 31 2007 Eric Sandeen - 2.2.45-1 +- Update to xfsdump 2.2.45 + +* Thu Aug 31 2006 Russell Cattelan - 2.2.42-2 +- Remove Distribution: tag + +* Wed Aug 23 2006 Russell Cattelan - 2.2.42-1 +- update to version 2.2.42 + +* Tue Aug 22 2006 Russell Cattelan - 2.2.38-3 +- Fix the /usr/sbin sym links to relative links +- Add the Distribution tag +- Add ncurses-devel to buildrequires + +* Wed Aug 16 2006 Russell Cattelan - 2.2.38-2 +- install removes the makefile installed version of the docs + package the docs based in the version specfic directory + +* Wed Aug 9 2006 Russell Cattelan - 2.2.38-1 +- Add xfsdump to Fedora