.coreutils.metadata

@@ -1 +0,0 @@
-bd5d495c162730873a2774acd1c5091fbf0c55a4 SOURCES/coreutils-8.30.tar.xz

.fmf/version

@@ -0,0 +1 @@
+1

.gitignore

@@ -1 +1 @@
-SOURCES/coreutils-8.30.tar.xz
+/coreutils-[0-9.]*.tar.xz

STAGE1-coreutils

@@ -0,0 +1,7 @@
+srpm coreutils
+mcd $BUILDDIR/$1
+(cd $SRC/${1}-*/ ; autoreconf -vif)
+$SRC/${1}-*/configure $TCONFIGARGS --disable-pam
+notparallel
+make $J man1_MANS= V=1
+make $J man1_MANS= install DESTDIR=${ROOTFS}

ci.fmf

@@ -0,0 +1 @@
+resultsdb-testcase: separate

coreutils-8.30-du-fts-xfs-sigabrt.patch

@@ -0,0 +1,163 @@
+From 9a8a119858b8df497155cd2948494ea8580b4de4 Mon Sep 17 00:00:00 2001
+From: Paul Eggert <eggert@cs.ucla.edu>
+Date: Wed, 15 Apr 2020 20:50:32 -0700
+Subject: [PATCH] fts: remove NOSTAT_LEAF_OPTIMIZATION
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+It caused ‘find’ and ‘du’ to dump core, and it was useful
+only for obsolescent Linux filesystems anyway.  Problem reported in:
+https://lists.gnu.org/r/bug-gnulib/2020-04/msg00068.html
+Quite possibly there is still a serious underlying fts bug with
+tight-loop-check and mutating file systems, but if so this patch
+should cause the bug to be triggered less often.
+* lib/fts.c (enum leaf_optimization): Remove
+NOSTAT_LEAF_OPTIMIZATION, as it’s problematic.
+(S_MAGIC_REISERFS, S_MAGIC_XFS): Remove; no longer needed.
+(leaf_optimization): Remove special cases for ReiserFS and XFS.
+(fts_read): Remove NOSTAT_LEAF_OPTIMIZATION code.
+* lib/fts_.h (struct _ftsent.fts_n_dirs_remaining):
+Remove.  All uses removed.
+
+Cherry-picked-by: Lukáš Zaoral <lzaoral@redhat.com>
+Upstream-commit: 47bf2cf3184027c1eb9c1dfeea5c5b8b2d69710d
+---
+ lib/fts.c  | 56 ++++++++----------------------------------------------
+ lib/fts_.h |  5 -----
+ 2 files changed, 8 insertions(+), 53 deletions(-)
+
+diff --git a/lib/fts.c b/lib/fts.c
+index 1ccc78c..e469ea3 100644
+--- a/lib/fts.c
++++ b/lib/fts.c
+@@ -471,7 +471,6 @@ fts_open (char * const *argv,
+                 if ((parent = fts_alloc(sp, "", 0)) == NULL)
+                         goto mem2;
+                 parent->fts_level = FTS_ROOTPARENTLEVEL;
+-                parent->fts_n_dirs_remaining = -1;
+           }
+ 
+         /* The classic fts implementation would call fts_stat with
+@@ -660,9 +659,8 @@ fts_close (FTS *sp)
+ }
+ 
+ /* Minimum link count of a traditional Unix directory.  When leaf
+-   optimization is OK and MIN_DIR_NLINK <= st_nlink, then st_nlink is
+-   an upper bound on the number of subdirectories (counting "." and
+-   "..").  */
++   optimization is OK and a directory's st_nlink == MIN_DIR_NLINK,
++   then the directory has no subdirectories.  */
+ enum { MIN_DIR_NLINK = 2 };
+ 
+ /* Whether leaf optimization is OK for a directory.  */
+@@ -671,12 +669,8 @@ enum leaf_optimization
+     /* st_nlink is not reliable for this directory's subdirectories.  */
+     NO_LEAF_OPTIMIZATION,
+ 
+-    /* Leaf optimization is OK, but is not useful for avoiding stat calls.  */
+-    OK_LEAF_OPTIMIZATION,
+-
+-    /* Leaf optimization is not only OK: it is useful for avoiding
+-       stat calls, because dirent.d_type does not work.  */
+-    NOSTAT_LEAF_OPTIMIZATION
++    /* st_nlink == 2 means the directory lacks subdirectories.  */
++    OK_LEAF_OPTIMIZATION
+   };
+ 
+ #if defined __linux__ \
+@@ -689,9 +683,7 @@ enum leaf_optimization
+ # define S_MAGIC_CIFS 0xFF534D42
+ # define S_MAGIC_NFS 0x6969
+ # define S_MAGIC_PROC 0x9FA0
+-# define S_MAGIC_REISERFS 0x52654973
+ # define S_MAGIC_TMPFS 0x1021994
+-# define S_MAGIC_XFS 0x58465342
+ 
+ # ifdef HAVE___FSWORD_T
+ typedef __fsword_t fsword;
+@@ -808,23 +800,15 @@ dirent_inode_sort_may_be_useful (FTSENT const *p, int dir_fd)
+ }
+ 
+ /* Given an FTS entry P for a directory with descriptor DIR_FD,
+-   return true if it is both useful and valid to apply leaf optimization.
+-   The optimization is useful only for file systems that lack usable
+-   dirent.d_type info.  The optimization is valid if an st_nlink value
+-   of at least MIN_DIR_NLINK is an upper bound on the number of
+-   subdirectories of D, counting "." and ".."  as subdirectories.
++   return whether it is valid to apply leaf optimization.
++   The optimization is valid if a directory's st_nlink value equal
++   to MIN_DIR_NLINK means the directory has no subdirectories.
+    DIR_FD is negative if unavailable.  */
+ static enum leaf_optimization
+ leaf_optimization (FTSENT const *p, int dir_fd)
+ {
+   switch (filesystem_type (p, dir_fd))
+     {
+-      /* List here the file system types that may lack usable dirent.d_type
+-         info, yet for which the optimization does apply.  */
+-    case S_MAGIC_REISERFS:
+-    case S_MAGIC_XFS: /* XFS lacked it until 2013-08-22 commit.  */
+-      return NOSTAT_LEAF_OPTIMIZATION;
+-
+     case 0:
+       /* Leaf optimization is unsafe if the file system type is unknown.  */
+       FALLTHROUGH;
+@@ -1049,26 +1033,7 @@ check_for_dir:
+                 if (p->fts_info == FTS_NSOK)
+                   {
+                     if (p->fts_statp->st_size == FTS_STAT_REQUIRED)
+-                      {
+-                        FTSENT *parent = p->fts_parent;
+-                        if (parent->fts_n_dirs_remaining == 0
+-                            && ISSET(FTS_NOSTAT)
+-                            && ISSET(FTS_PHYSICAL)
+-                            && (leaf_optimization (parent, sp->fts_cwd_fd)
+-                                == NOSTAT_LEAF_OPTIMIZATION))
+-                          {
+-                            /* nothing more needed */
+-                          }
+-                        else
+-                          {
+-                            p->fts_info = fts_stat(sp, p, false);
+-                            if (S_ISDIR(p->fts_statp->st_mode)
+-                                && p->fts_level != FTS_ROOTLEVEL
+-                                && 0 < parent->fts_n_dirs_remaining
+-                                && parent->fts_n_dirs_remaining != (nlink_t) -1)
+-                                  parent->fts_n_dirs_remaining--;
+-                          }
+-                      }
++                      p->fts_info = fts_stat(sp, p, false);
+                     else
+                       fts_assert (p->fts_statp->st_size == FTS_NO_STAT_REQUIRED);
+                   }
+@@ -1853,11 +1818,6 @@ err:            memset(sbp, 0, sizeof(struct stat));
+         }
+ 
+         if (S_ISDIR(sbp->st_mode)) {
+-                p->fts_n_dirs_remaining
+-                  = ((sbp->st_nlink < MIN_DIR_NLINK
+-                      || p->fts_level <= FTS_ROOTLEVEL)
+-                     ? -1
+-                     : sbp->st_nlink - (ISSET (FTS_SEEDOT) ? 0 : MIN_DIR_NLINK));
+                 if (ISDOT(p->fts_name)) {
+                         /* Command-line "." and ".." are real directories. */
+                         return (p->fts_level == FTS_ROOTLEVEL ? FTS_D : FTS_DOT);
+diff --git a/lib/fts_.h b/lib/fts_.h
+index 70cc9e3..d78eabb 100644
+--- a/lib/fts_.h
++++ b/lib/fts_.h
+@@ -221,11 +221,6 @@ typedef struct _ftsent {
+ 
+         size_t fts_namelen;             /* strlen(fts_name) */
+ 
+-        /* If not (nlink_t) -1, an upper bound on the number of
+-           remaining subdirectories of interest.  If this becomes
+-           zero, some work can be avoided.  */
+-        nlink_t fts_n_dirs_remaining;
+-
+ # define FTS_D           1              /* preorder directory */
+ # define FTS_DC          2              /* directory that causes cycles */
+ # define FTS_DEFAULT     3              /* none of the above */
+-- 
+2.51.1

coreutils-8.30.tar.xz.sig

@@ -0,0 +1,17 @@
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v2
+
+iQIcBAABCAAGBQJbOYLXAAoJEN9v2XEwYDfZFRwP/1xKMtXTqCOnP3ECRze+bYnX
+GB5Mm57kcP2NXwzo62+9C+FToEfkRTALtlU95edIRlsjLGBoDvv12fsOKdsyO/c5
+7paI3NoaUFyJxby9w91mNOcgN6eR5WZ/LHm2VbTs5VFpsNcSVyHSvhiqgPXtRrVp
+ZrnUKbg9iWjn8jcJHIS7qrIO4GsoFzfhn9gVh8Xxp4AYx0btn3BwPTWCxg53Ie0p
+OgrMmMnOe3wrpwrlJOgfvpk5na7yKRt7GYsyGMaKB7OxbHlVg4UCx4LuRBnaUPZr
+QmlX37sIR/sEJne0zR4iMorPi5IsErMT39VaBDLnsAjyccbmYQ/RmFYASiM5Zijw
+d94fk+TocyDBrOMsO5fzKUID5Uf4c5vJlhCXBsPBykNiKsQTb3M7fZ+gjYrMJmoS
+4DDgAMryoB5yc2i9HcNj8WMNHy4RGIrRWxOAUZf5j2zEEVwKaRcoNosFoycUotEA
+yoWdRIwyCkVwlemVhx0zQTm8WbtFl0kkAFKTqu7uHGUGOKSS4dzTi000cJ4qHSyY
+ODrouvKgqKwB+Q7IfpQ72i6DLpTzNjLKNMipBPsSkSW+RaWC67+smo1vL9V5ZlfX
+ypzjMF++r3cRuIWG9IwAwedl/sH7iqjHwdMf4y+8sGxRzW5Oeyvx20TvqxMqRLGD
+nU0Y2GCLW7C2Idw+I5QM
+=pibq
+-----END PGP SIGNATURE-----

coreutils-8.5-dircolors.patch

@@ -0,0 +1,13 @@
+diff -urNp coreutils-8.5-orig/src/dircolors.hin coreutils-8.5/src/dircolors.hin
+--- coreutils-8.5-orig/src/dircolors.hin	2010-04-20 21:52:04.000000000 +0200
++++ coreutils-8.5/src/dircolors.hin	2010-07-22 16:18:41.978036926 +0200
+@@ -127,6 +127,9 @@ EXEC 01;32
+ .deb 01;31
+ .rpm 01;31
+ .jar 01;31
++.war 01;31
++.ear 01;31
++.sar 01;31
+ .rar 01;31
+ .ace 01;31
+ .zoo 01;31

coreutils-i18n-cut.patch

@@ -0,0 +1,587 @@
+(sb) lin18nux/lsb compliance - cut - not stable enough, not applied
+
+--- coreutils-8.24/src/cut.c	2015-06-26 19:05:22.000000000 +0200
++++ cut.c	2016-01-15 10:15:04.863804121 +0100
+@@ -28,6 +28,11 @@
+ #include <assert.h>
+ #include <getopt.h>
+ #include <sys/types.h>
++
++#include <mbfile.h>
++#include <mbiter.h>
++#include <string.h>
++
+ #include "system.h"
+ 
+ #include "error.h"
+@@ -61,25 +66,16 @@
+    CURRENT_RP.HI then we make CURRENT_RP to point to the next range pair. */
+ static struct field_range_pair *current_rp;
+ 
+-/* This buffer is used to support the semantics of the -s option
+-   (or lack of same) when the specified field list includes (does
+-   not include) the first field.  In both of those cases, the entire
+-   first field must be read into this buffer to determine whether it
+-   is followed by a delimiter or a newline before any of it may be
+-   output.  Otherwise, cut_fields can do the job without using this
+-   buffer.  */
+-static char *field_1_buffer;
+-
+-/* The number of bytes allocated for FIELD_1_BUFFER.  */
+-static size_t field_1_bufsize;
+-
+ enum operating_mode
+   {
+     undefined_mode,
+ 
+-    /* Output characters that are in the given bytes. */
++    /* Output the given bytes. */
+     byte_mode,
+ 
++    /* Output characters that are in the given positions . */
++    char_mode,
++
+     /* Output the given delimiter-separated fields. */
+     field_mode
+   };
+@@ -91,12 +87,16 @@ static enum operating_mode operating_mode;
+    with field mode.  */
+ static bool suppress_non_delimited;
+ 
++/* Unless true, we do not recognize multibyte characters in byte-splitting
++   mode.  */
++static bool no_break_mb_chars;
++
+ /* If true, print all bytes, characters, or fields _except_
+    those that were specified.  */
+ static bool complement;
+ 
+ /* The delimiter character for field mode. */
+-static unsigned char delim;
++static mbf_char_t delim;
+ 
+ /* The delimiter for each line/record. */
+ static unsigned char line_delim = '\n';
+@@ -109,7 +109,7 @@ static size_t output_delimiter_length;
+ 
+ /* The output field separator string.  Defaults to the 1-character
+    string consisting of the input delimiter.  */
+-static char *output_delimiter_string;
++static char const *output_delimiter_string;
+ 
+ /* True if we have ever read standard input. */
+ static bool have_read_stdin;
+@@ -164,7 +164,7 @@ Print selected parts of lines from each FILE to standard output.\n\
+   -f, --fields=LIST       select only these fields;  also print any line\n\
+                             that contains no delimiter character, unless\n\
+                             the -s option is specified\n\
+-  -n                      (ignored)\n\
++  -n                      with -b, don't split multibyte characters\n\
+ "), stdout);
+       fputs (_("\
+       --complement        complement the set of selected bytes, characters\n\
+@@ -211,6 +211,12 @@ next_item (size_t *item_idx)
+     current_rp++;
+ }
+ 
++static inline void
++next_item_n (size_t *item_idx, size_t n)
++{
++  while (n-- > 0)
++    next_item (item_idx);
++}
+ /* Return nonzero if the K'th field or byte is printable. */
+ 
+ static inline bool
+@@ -219,6 +225,15 @@ print_kth (size_t k)
+   return current_rp->lo <= k;
+ }
+ 
++/* The lo and hi params should be used for the current characters byte position
++ * and byte size, respectively. */
++static inline bool
++rp_intersect (size_t lo, size_t hi)
++{
++  return ((current_rp->lo <= lo && current_rp->hi >= lo)
++	  || (current_rp->lo <= hi && current_rp->hi >= hi));
++}
++
+ /* Return nonzero if K'th byte is the beginning of a range. */
+ 
+ static inline bool
+@@ -281,23 +296,215 @@ cut_bytes (FILE *stream)
+ }
+ 
+ /* Read from stream STREAM, printing to standard output any selected fields.  */
++extern ssize_t
++mb_getndelim2 (mbf_char_t **lineptr, size_t *linesize, size_t nmax,
++	       mbf_char_t delim1, mbf_char_t delim2, mb_file_t *stream)
++{
++/* The maximum value that getndelim2 can return without suffering from
++   overflow problems, either internally (because of pointer
++   subtraction overflow) or due to the API (because of ssize_t).  */
++#define GETNDELIM2_MAXIMUM (PTRDIFF_MAX < SSIZE_MAX ? PTRDIFF_MAX : SSIZE_MAX)
++
++/* Try to add at least this many bytes when extending the buffer.
++   MIN_CHUNK must be no greater than GETNDELIM2_MAXIMUM.  */
++#define MIN_CHUNK 64
++  size_t nchars_avail;          /* Allocated but unused chars in *LINEPTR.  */
++  mbf_char_t *read_pos;               /* Where we're reading into *LINEPTR. */
++  ssize_t chars_stored = -1;
++  mbf_char_t *ptr = *lineptr;
++  size_t size = *linesize;
++  bool found_delimiter;
++
++  if (!ptr)
++    {
++      size = nmax < MIN_CHUNK ? nmax : MIN_CHUNK;
++      ptr = malloc (size * sizeof (mbf_char_t));
++      if (!ptr)
++        return -1;
++    }
++
++  if (size < 0)
++    goto done;
++
++  nchars_avail = size;
++  read_pos = ptr;
++
++  if (nchars_avail == 0 && nmax <= size)
++    goto done;
++
++  /* Normalize delimiters, since memchr2 doesn't handle EOF.  */
++  if (mb_iseof (delim1))
++    mb_copy (&delim1, &delim2);
++  else if (mb_iseof (delim2))
++    mb_copy (&delim2, &delim1);
++
++  flockfile (stream);
++
++  found_delimiter = false;
++  do
++    {
++      /* Here always ptr + size == read_pos + nchars_avail.
++         Also nchars_avail > 0 || size < nmax.  */
++
++      mbf_char_t c IF_LINT (= 0);
++        {
++          mbf_getc (c, *stream);
++          if (mb_iseof (c))
++            {
++              /* Return partial line, if any.  */
++              if (read_pos == ptr)
++                goto unlock_done;
++              else
++                break;
++            }
++          if (mb_equal (c, delim1) || mb_equal (c, delim2))
++            found_delimiter = true;
++        }
++
++      /* We always want at least one byte left in the buffer, since we
++         always (unless we get an error while reading the first byte)
++         NUL-terminate the line buffer.  */
++
++      if (!nchars_avail)
++        {
++          /* Grow size proportionally, not linearly, to avoid O(n^2)
++             running time.  */
++          size_t newsize = size < MIN_CHUNK ? size + MIN_CHUNK : 2 * size;
++          mbf_char_t *newptr;
++
++          /* Respect nmax.  This handles possible integer overflow.  */
++          if (! (size < newsize && newsize <= nmax))
++            newsize = nmax;
++
++          if (GETNDELIM2_MAXIMUM < newsize)
++            {
++              size_t newsizemax = GETNDELIM2_MAXIMUM + 1;
++              if (size == newsizemax)
++                goto unlock_done;
++              newsize = newsizemax;
++            }
++          nchars_avail = newsize - (read_pos - ptr);
++          newptr = realloc (ptr, newsize * sizeof (mbf_char_t));
++          if (!newptr)
++            goto unlock_done;
++          ptr = newptr;
++          size = newsize;
++          read_pos = size - nchars_avail + ptr;
++        }
++
++      /* Here, if size < nmax, nchars_avail >= buffer_len + 1.
++         If size == nmax, nchars_avail > 0.  */
++
++      if (1 < nchars_avail--)
++        {
++          mb_copy(read_pos++, &c);
++        }
++
++    }
++  while (!found_delimiter);
++
++  chars_stored = (read_pos - ptr);
++
++ unlock_done:
++  funlockfile (stream);
++
++ done:
++  *lineptr = ptr;
++  *linesize = size;
++  return chars_stored;
++}
++
++static void
++cut_chars (FILE *stream)
++{
++  size_t char_idx;	/* Number of chars in the line so far. */
++  bool print_delimiter;
++  mbf_char_t c;
++  mb_file_t mbf;
++
++  print_delimiter = false;
++  char_idx = 0;
++  current_rp = frp;
++
++  mbf_init (mbf, stream);
++  while (true)
++    {
++      mbf_getc (c, mbf);
++
++      if (mb_iseq (c, line_delim))
++	{
++	  putc (line_delim, stdout);
++	  char_idx = 0;
++	  print_delimiter = false;
++          current_rp = frp;
++	}
++      else if (mb_iseof (c))
++	{
++	  if (char_idx > 0)
++	    putc (line_delim, stdout);
++	  break;
++	}
++      else
++	{
++	  /* Forward by one byte.  */
++	  next_item (&char_idx);
++
++	  /* Check if the current characters byte range is within
++	   * the argument list.  */
++	  if (rp_intersect (char_idx, char_idx + mb_len (c) - 1))
++	    {
++	      if (output_delimiter_specified)
++		{
++		  if (print_delimiter && is_range_start_index (char_idx))
++		    {
++		      fwrite (output_delimiter_string, sizeof (char),
++			      output_delimiter_length, stdout);
++		    }
++		  print_delimiter = true;
++		}
++	      mb_putc (c, stdout);
++	    }
++
++	  /* Byte mode with multibyte characters uncut (-b -n).  */
++	  if (no_break_mb_chars)
++	    /* Forward by an additional byte_length (c) - 1.  */
++	    next_item_n (&char_idx, mb_len (c) - 1);
++       }
++    }
++}
+ 
+ static void
+ cut_fields (FILE *stream)
+ {
+-  int c;
++
++  /* This buffer is used to support the semantics of the -s option
++     (or lack of same) when the specified field list includes (does
++     not include) the first field.  In both of those cases, the entire
++     first field must be read into this buffer to determine whether it
++     is followed by a delimiter or a newline before any of it may be
++     output.  Otherwise, cut_fields can do the job without using this
++     buffer.  */
++  mbf_char_t *field_1_buffer = 0;
++  /* The number of bytes allocated for FIELD_1_BUFFER.  */
++  size_t field_1_bufsize;
++
++
++  mbf_char_t c, d;
++  mb_file_t mbf;
+   size_t field_idx = 1;
+   bool found_any_selected_field = false;
+   bool buffer_first_field;
+ 
+   current_rp = frp;
+ 
+-  c = getc (stream);
+-  if (c == EOF)
++  mbf_init (mbf, stream);
++  mbf_getc (c, mbf);
++  if (mb_iseof (c))
+     return;
+ 
+-  ungetc (c, stream);
+-  c = 0;
++  mbf_ungetc (c, mbf);
++  mb_setascii (&c, 0);
++  mb_copy (&d, &delim);
+ 
+   /* To support the semantics of the -s flag, we may have to buffer
+      all of the first field to determine whether it is 'delimited.'
+@@ -312,10 +519,14 @@ cut_fields (FILE *stream)
+       if (field_idx == 1 && buffer_first_field)
+         {
+           ssize_t len;
+-          size_t n_bytes;
++          size_t n_chars;
++	  mbf_char_t nl;
++	  mb_setascii (&nl, line_delim);
++
++          len = mb_getndelim2 (&field_1_buffer, &field_1_bufsize,
++			       GETNLINE_NO_LIMIT, d, nl, &mbf);
++
+ 
+-          len = getndelim2 (&field_1_buffer, &field_1_bufsize, 0,
+-                            GETNLINE_NO_LIMIT, delim, line_delim, stream);
+           if (len < 0)
+             {
+               free (field_1_buffer);
+@@ -325,15 +536,15 @@ cut_fields (FILE *stream)
+               xalloc_die ();
+             }
+ 
+-          n_bytes = len;
+-          assert (n_bytes != 0);
++          n_chars = len;
++          //assert (n_chars != 0);
+ 
+-          c = 0;
++	  mb_setascii (&c, 0);
+ 
+           /* If the first field extends to the end of line (it is not
+              delimited) and we are printing all non-delimited lines,
+              print this one.  */
+-          if (to_uchar (field_1_buffer[n_bytes - 1]) != delim)
++          if (!mb_equal (field_1_buffer[n_chars - 1], d))
+             {
+               if (suppress_non_delimited)
+                 {
+@@ -341,26 +552,30 @@ cut_fields (FILE *stream)
+                 }
+               else
+                 {
+-                  fwrite (field_1_buffer, sizeof (char), n_bytes, stdout);
++		  for (int i = 0; i < n_chars; ++i)
++		    mb_putc (field_1_buffer[i], stdout);
++
+                   /* Make sure the output line is newline terminated.  */
+-                  if (field_1_buffer[n_bytes - 1] != line_delim)
++                  if (!mb_iseq (field_1_buffer[n_chars - 1], line_delim))
+                     putchar (line_delim);
+-                  c = line_delim;
++                  mb_setascii (&c, line_delim);
+                 }
+               continue;
+             }
+           if (print_kth (1))
+             {
+               /* Print the field, but not the trailing delimiter.  */
+-              fwrite (field_1_buffer, sizeof (char), n_bytes - 1, stdout);
++	      for (int i = 0; i < n_chars - 1; ++i)
++		mb_putc (field_1_buffer[i], stdout);
+ 
+               /* With -d$'\n' don't treat the last '\n' as a delimiter.  */
+-              if (delim == line_delim)
++              if (mb_iseq (d, line_delim))
+                 {
+-                  int last_c = getc (stream);
+-                  if (last_c != EOF)
++                  mbf_char_t last_c;
++		  mbf_getc (last_c, mbf);
++                  if (!mb_iseof (last_c))
+                     {
+-                      ungetc (last_c, stream);
++                      mbf_ungetc (last_c, mbf);
+                       found_any_selected_field = true;
+                     }
+                 }
+@@ -370,7 +585,8 @@ cut_fields (FILE *stream)
+           next_item (&field_idx);
+         }
+ 
+-      int prev_c = c;
++      mbf_char_t prev_c;
++      mb_copy (&prev_c, &c);
+ 
+       if (print_kth (field_idx))
+         {
+@@ -381,42 +597,46 @@ cut_fields (FILE *stream)
+             }
+           found_any_selected_field = true;
+ 
+-          while ((c = getc (stream)) != delim && c != line_delim && c != EOF)
++	  mbf_getc (c, mbf);
++          while (!mb_equal (c, d) && !mb_iseq (c, line_delim) && !mb_iseof (c))
+             {
+-              putchar (c);
+-              prev_c = c;
++              mb_putc (c, stdout);
++	      mb_copy (&prev_c, &c);
++	      mbf_getc (c, mbf);
+             }
+         }
+       else
+         {
+-          while ((c = getc (stream)) != delim && c != line_delim && c != EOF)
++	  mbf_getc (c, mbf);
++          while (!mb_equal (c, d) && !mb_iseq (c, line_delim) && !mb_iseof (c))
+             {
+-              prev_c = c;
++	      mb_copy (&prev_c, &c);
++	      mbf_getc (c, mbf);
+             }
+         }
+ 
+       /* With -d$'\n' don't treat the last '\n' as a delimiter.  */
+-      if (delim == line_delim && c == delim)
++      if (mb_iseq (d, line_delim) && mb_equal (c, d))
+         {
+-          int last_c = getc (stream);
+-          if (last_c != EOF)
+-            ungetc (last_c, stream);
++	  mbf_char_t last_c;
++	  mbf_getc (last_c, mbf);
++	  if (!mb_iseof (last_c))
++	    mbf_ungetc (last_c, mbf);
+           else
+-            c = last_c;
++	    mb_copy (&c, &last_c);
+         }
+ 
+-      if (c == delim)
++      if (mb_equal (c, d))
+         next_item (&field_idx);
+-      else if (c == line_delim || c == EOF)
++      else if (mb_iseq (c, line_delim) || mb_iseof (c))
+         {
+           if (found_any_selected_field
+               || !(suppress_non_delimited && field_idx == 1))
+             {
+-              if (c == line_delim || prev_c != line_delim
+-                  || delim == line_delim)
++              if (mb_iseq (c, line_delim) || !mb_iseq (prev_c, line_delim) || mb_iseq (d, line_delim))
+                 putchar (line_delim);
+             }
+-          if (c == EOF)
++          if (mb_iseof (c))
+             break;
+           field_idx = 1;
+           current_rp = frp;
+@@ -429,7 +649,14 @@ static void
+ cut_stream (FILE *stream)
+ {
+   if (operating_mode == byte_mode)
+-    cut_bytes (stream);
++    {
++      if (no_break_mb_chars)
++	cut_chars (stream);
++      else
++	cut_bytes (stream);
++    }
++  else if (operating_mode == char_mode)
++    cut_chars (stream);
+   else
+     cut_fields (stream);
+ }
+@@ -483,6 +710,7 @@ main (int argc, char **argv)
+   bool ok;
+   bool delim_specified = false;
+   char *spec_list_string IF_LINT ( = NULL);
++  mbi_iterator_t iter;
+ 
+   initialize_main (&argc, &argv);
+   set_program_name (argv[0]);
+@@ -496,8 +724,10 @@ main (int argc, char **argv)
+ 
+   /* By default, all non-delimited lines are printed.  */
+   suppress_non_delimited = false;
++  /* Default behaviour for -b, unless -n is also specified.  */
++  no_break_mb_chars = false;
+ 
+-  delim = '\0';
++  mb_setascii (&delim, '\0');
+   have_read_stdin = false;
+ 
+   while ((optc = getopt_long (argc, argv, "b:c:d:f:nsz", longopts, NULL)) != -1)
+@@ -505,7 +735,6 @@ main (int argc, char **argv)
+       switch (optc)
+         {
+         case 'b':
+-        case 'c':
+           /* Build the byte list. */
+           if (operating_mode != undefined_mode)
+             FATAL_ERROR (_("only one type of list may be specified"));
+@@ -513,6 +742,14 @@ main (int argc, char **argv)
+           spec_list_string = optarg;
+           break;
+ 
++        case 'c':
++          /* Build the char list. */
++          if (operating_mode != undefined_mode)
++            FATAL_ERROR (_("only one type of list may be specified"));
++          operating_mode = char_mode;
++          spec_list_string = optarg;
++          break;
++
+         case 'f':
+           /* Build the field list. */
+           if (operating_mode != undefined_mode)
+@@ -524,9 +761,17 @@ main (int argc, char **argv)
+         case 'd':
+           /* New delimiter. */
+           /* Interpret -d '' to mean 'use the NUL byte as the delimiter.'  */
+-          if (optarg[0] != '\0' && optarg[1] != '\0')
++	  mbi_init (iter, optarg, strlen (optarg));
++	  if  (!mbi_avail (iter))
++	    mb_setascii (&delim, '\0');
++	  else
++           {
++             mb_copy (&delim, &mbi_cur (iter));
++
++             mbi_advance (iter);
++             if (mbi_avail (iter))
+             FATAL_ERROR (_("the delimiter must be a single character"));
+-          delim = optarg[0];
++           }
+           delim_specified = true;
+           break;
+ 
+@@ -540,6 +785,7 @@ main (int argc, char **argv)
+           break;
+ 
+         case 'n':
++	  no_break_mb_chars = true;
+           break;
+ 
+         case 's':
+@@ -579,15 +825,12 @@ main (int argc, char **argv)
+               | (complement ? SETFLD_COMPLEMENT : 0) );
+ 
+   if (!delim_specified)
+-    delim = '\t';
++    mb_setascii (&delim, '\t');
+ 
+   if (output_delimiter_string == NULL)
+     {
+-      static char dummy[2];
+-      dummy[0] = delim;
+-      dummy[1] = '\0';
+-      output_delimiter_string = dummy;
+-      output_delimiter_length = 1;
++      output_delimiter_string = mb_ptr (delim);
++      output_delimiter_length = mb_len (delim);
+     }
+ 
+   if (optind == argc)

coreutils.spec

@@ -1,7 +1,7 @@
 Summary: A set of basic GNU tools commonly used in shell scripts
 Name:    coreutils
 Version: 8.30
-Release: 15%{?dist}
+Release: 16%{?dist}
 License: GPLv3+
 Group:   System Environment/Base
 Url:     https://www.gnu.org/software/coreutils/
@@ -62,6 +62,9 @@ Patch18:  coreutils-9.0-autofs-no-mount.patch
 # basic support for checking NFSv4 ACLs (#2158747)
 Patch19:  coreutils-nfsv4-acls.patch
 
+# fix du being killed by SIGABRT on mutating xfs systems (RHEL-124174)
+Patch20:  coreutils-8.30-du-fts-xfs-sigabrt.patch
+
 # disable the test-lock gnulib test prone to deadlock
 Patch100: coreutils-8.26-test-lock.patch
 
@@ -293,6 +296,9 @@ fi
 %license COPYING
 
 %changelog
+* Wed Oct 29 2025 Lukáš Zaoral <lzaoral@redhat.com> - 8.30-16
+- fix du being killed by SIGABRT on mutating xfs systems (RHEL-124174)
+
 * Mon Jan 02 2023 Kamil Dudka <kdudka@redhat.com> - 8.30-15
 - basic support for checking NFSv4 ACLs (#2158747)
 

gating.yaml

@@ -0,0 +1,7 @@
+--- !Policy
+product_versions:
+  - rhel-8
+decision_context: osci_compose_gate
+rules:
+  - !PassingTestCaseRule {test_case_name: osci.brew-build./plans/tier1-internal/coreutils-multi.functional}
+  - !PassingTestCaseRule {test_case_name: osci.brew-build./plans/tier1-internal/coreutils-single.functional}

plans/tier1-internal.fmf

@@ -0,0 +1,23 @@
+discover:
+    how: fmf
+    filter: 'tag: CI-Tier-1'
+    url: https://pkgs.devel.redhat.com/git/tests/coreutils
+execute:
+    how: tmt
+adjust:
+    enabled: false
+    when: distro == centos-stream or distro == fedora
+
+/coreutils-multi:
+    summary: Internal Tier1 tests plan - coreutils
+    prepare:
+        how: install
+        exclude:
+            - coreutils-single
+
+/coreutils-single:
+    summary: Internal Tier1 tests plan - coreutils-single
+    prepare:
+        how: install
+        exclude:
+            - coreutils

sources

@@ -0,0 +1 @@
+SHA512 (coreutils-8.30.tar.xz) = 25bc132c0d89ce71c33e417f04649c9fcfce6c5ef8b19f093b2e9e2851bfde9b5a31e20499d9c427332228ba54b88d445ddb445551e1944bb8f5cbff5ffa4eda

upstream-key.gpg

@@ -0,0 +1,123 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: GnuPG v1.4.6 (GNU/Linux)
+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+=zRdO
+-----END PGP PUBLIC KEY BLOCK-----