From 0f0f4d1502ef5ca3728605888645c136e358b26a Mon Sep 17 00:00:00 2001 From: Leonid Pliushch Date: Thu, 4 Feb 2021 20:23:42 +0000 Subject: [PATCH] e2fsprogs: update to 1.46.0 --- packages/e2fsprogs/build.sh | 5 +- packages/e2fsprogs/qsort.patch | 225 +++++++++++++++++++++++++++++++++ 2 files changed, 227 insertions(+), 3 deletions(-) create mode 100644 packages/e2fsprogs/qsort.patch diff --git a/packages/e2fsprogs/build.sh b/packages/e2fsprogs/build.sh index c45e067a2..e99c63c4c 100644 --- a/packages/e2fsprogs/build.sh +++ b/packages/e2fsprogs/build.sh @@ -3,10 +3,9 @@ TERMUX_PKG_DESCRIPTION="EXT 2/3/4 filesystem utilities" TERMUX_PKG_LICENSE="GPL-2.0, LGPL-2.0, MIT" TERMUX_PKG_LICENSE_FILE="NOTICE" TERMUX_PKG_MAINTAINER="Leonid Pliushch " -TERMUX_PKG_VERSION=1.45.6 -TERMUX_PKG_REVISION=2 +TERMUX_PKG_VERSION=1.46.0 TERMUX_PKG_SRCURL=https://www.kernel.org/pub/linux/kernel/people/tytso/e2fsprogs/v$TERMUX_PKG_VERSION/e2fsprogs-$TERMUX_PKG_VERSION.tar.xz -TERMUX_PKG_SHA256=ffa7ae6954395abdc50d0f8605d8be84736465afc53b8938ef473fcf7ff44256 +TERMUX_PKG_SHA256=91d61cef9a251a18e49a700be0028a8d35b0549a25d2bc263af6fa5d9f7c7d13 TERMUX_PKG_CONFFILES="etc/mke2fs.conf" TERMUX_PKG_NO_STATICSPLIT=true diff --git a/packages/e2fsprogs/qsort.patch b/packages/e2fsprogs/qsort.patch new file mode 100644 index 000000000..b99c6fc00 --- /dev/null +++ b/packages/e2fsprogs/qsort.patch @@ -0,0 +1,225 @@ +diff -uNr e2fsprogs-1.46.0/e2fsck/Makefile.in e2fsprogs-1.46.0.mod/e2fsck/Makefile.in +--- e2fsprogs-1.46.0/e2fsck/Makefile.in 2021-01-29 22:02:31.000000000 +0000 ++++ e2fsprogs-1.46.0.mod/e2fsck/Makefile.in 2021-02-04 20:29:41.269850057 +0000 +@@ -59,14 +59,14 @@ + # + #MCHECK= -DMCHECK + +-OBJS= unix.o e2fsck.o super.o pass1.o pass1b.o pass2.o \ ++OBJS= qsort.o unix.o e2fsck.o super.o pass1.o pass1b.o pass2.o \ + pass3.o pass4.o pass5.o journal.o badblocks.o util.o dirinfo.o \ + dx_dirinfo.o ehandler.o problem.o message.o quota.o recovery.o \ + region.o revoke.o ea_refcount.o rehash.o \ + logfile.o sigcatcher.o $(MTRACE_OBJ) readahead.o \ + extents.o encrypted_files.o + +-PROFILED_OBJS= profiled/unix.o profiled/e2fsck.o \ ++PROFILED_OBJS= profiled/qsort.o profiled/unix.o profiled/e2fsck.o \ + profiled/super.o profiled/pass1.o profiled/pass1b.o \ + profiled/pass2.o profiled/pass3.o profiled/pass4.o profiled/pass5.o \ + profiled/journal.o profiled/badblocks.o profiled/util.o \ +@@ -105,7 +105,7 @@ + $(srcdir)/logfile.c \ + $(srcdir)/quota.c \ + $(srcdir)/extents.c \ +- $(srcdir)/encrypted_files.c \ ++ $(srcdir)/encrypted_files.c $(srcdir)/qsort.c \ + $(MTRACE_SRC) + + all:: profiled $(PROGS) e2fsck $(MANPAGES) $(FMANPAGES) +diff -uNr e2fsprogs-1.46.0/e2fsck/qsort.c e2fsprogs-1.46.0.mod/e2fsck/qsort.c +--- e2fsprogs-1.46.0/e2fsck/qsort.c 1970-01-01 00:00:00.000000000 +0000 ++++ e2fsprogs-1.46.0.mod/e2fsck/qsort.c 2021-02-04 20:32:48.839098611 +0000 +@@ -0,0 +1,192 @@ ++/*- ++ * Copyright (c) 1992, 1993 ++ * The Regents of the University of California. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 4. Neither the name of the University nor the names of its contributors ++ * may be used to endorse or promote products derived from this software ++ * without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ */ ++ ++#include ++#include ++ ++#define I_AM_QSORT_R ++ ++#ifdef I_AM_QSORT_R ++typedef int cmp_t(void *, const void *, const void *); ++#else ++typedef int cmp_t(const void *, const void *); ++#endif ++static inline char *med3(char *, char *, char *, cmp_t *, void *); ++static inline void swapfunc(char *, char *, int, int); ++ ++#define min(a, b) (a) < (b) ? a : b ++ ++/* ++ * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function". ++ */ ++#define swapcode(TYPE, parmi, parmj, n) { \ ++ long i = (n) / sizeof (TYPE); \ ++ TYPE *pi = (TYPE *) (parmi); \ ++ TYPE *pj = (TYPE *) (parmj); \ ++ do { \ ++ TYPE t = *pi; \ ++ *pi++ = *pj; \ ++ *pj++ = t; \ ++ } while (--i > 0); \ ++} ++ ++#define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \ ++ es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1; ++ ++static inline void ++swapfunc(a, b, n, swaptype) ++ char *a, *b; ++ int n, swaptype; ++{ ++ if(swaptype <= 1) ++ swapcode(long, a, b, n) ++ else ++ swapcode(char, a, b, n) ++} ++ ++#define swap(a, b) \ ++ if (swaptype == 0) { \ ++ long t = *(long *)(a); \ ++ *(long *)(a) = *(long *)(b); \ ++ *(long *)(b) = t; \ ++ } else \ ++ swapfunc(a, b, es, swaptype) ++ ++#define vecswap(a, b, n) if ((n) > 0) swapfunc(a, b, n, swaptype) ++ ++#ifdef I_AM_QSORT_R ++#define CMP(t, x, y) (cmp((t), (x), (y))) ++#else ++#define CMP(t, x, y) (cmp((x), (y))) ++#endif ++ ++static inline char * ++med3(char *a, char *b, char *c, cmp_t *cmp, void *thunk ++#ifndef I_AM_QSORT_R ++__unused ++#endif ++) ++{ ++ return CMP(thunk, a, b) < 0 ? ++ (CMP(thunk, b, c) < 0 ? b : (CMP(thunk, a, c) < 0 ? c : a )) ++ :(CMP(thunk, b, c) > 0 ? b : (CMP(thunk, a, c) < 0 ? a : c )); ++} ++ ++#ifdef I_AM_QSORT_R ++void ++qsort_r(void *a, size_t n, size_t es, void *thunk, cmp_t *cmp) ++#else ++#define thunk NULL ++void ++qsort(void *a, size_t n, size_t es, cmp_t *cmp) ++#endif ++{ ++ char *pa, *pb, *pc, *pd, *pl, *pm, *pn; ++ size_t d, r; ++ int cmp_result; ++ int swaptype, swap_cnt; ++ ++loop: SWAPINIT(a, es); ++ swap_cnt = 0; ++ if (n < 7) { ++ for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es) ++ for (pl = pm; ++ pl > (char *)a && CMP(thunk, pl - es, pl) > 0; ++ pl -= es) ++ swap(pl, pl - es); ++ return; ++ } ++ pm = (char *)a + (n / 2) * es; ++ if (n > 7) { ++ pl = a; ++ pn = (char *)a + (n - 1) * es; ++ if (n > 40) { ++ d = (n / 8) * es; ++ pl = med3(pl, pl + d, pl + 2 * d, cmp, thunk); ++ pm = med3(pm - d, pm, pm + d, cmp, thunk); ++ pn = med3(pn - 2 * d, pn - d, pn, cmp, thunk); ++ } ++ pm = med3(pl, pm, pn, cmp, thunk); ++ } ++ swap(a, pm); ++ pa = pb = (char *)a + es; ++ ++ pc = pd = (char *)a + (n - 1) * es; ++ for (;;) { ++ while (pb <= pc && (cmp_result = CMP(thunk, pb, a)) <= 0) { ++ if (cmp_result == 0) { ++ swap_cnt = 1; ++ swap(pa, pb); ++ pa += es; ++ } ++ pb += es; ++ } ++ while (pb <= pc && (cmp_result = CMP(thunk, pc, a)) >= 0) { ++ if (cmp_result == 0) { ++ swap_cnt = 1; ++ swap(pc, pd); ++ pd -= es; ++ } ++ pc -= es; ++ } ++ if (pb > pc) ++ break; ++ swap(pb, pc); ++ swap_cnt = 1; ++ pb += es; ++ pc -= es; ++ } ++ if (swap_cnt == 0) { /* Switch to insertion sort */ ++ for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es) ++ for (pl = pm; ++ pl > (char *)a && CMP(thunk, pl - es, pl) > 0; ++ pl -= es) ++ swap(pl, pl - es); ++ return; ++ } ++ ++ pn = (char *)a + n * es; ++ r = min(pa - (char *)a, pb - pa); ++ vecswap(a, pb - r, r); ++ r = min(pd - pc, pn - pd - (int)es); ++ vecswap(pb, pn - r, r); ++ if ((r = pb - pa) > es) ++#ifdef I_AM_QSORT_R ++ qsort_r(a, r / es, es, thunk, cmp); ++#else ++ qsort(a, r / es, es, cmp); ++#endif ++ if ((r = pd - pc) > es) { ++ /* Iterate rather than recurse to save stack space */ ++ a = pn - r; ++ n = r / es; ++ goto loop; ++ } ++/* qsort(pn - r, r / es, es, cmp);*/ ++}