Mon Apr 8 20:39:32 UTC 201920190408203932

a/glibc-zoneinfo-2019a-noarch-1.txz:  Upgraded.
a/grub-2.02-x86_64-5.txz:  Rebuilt.
  Support F2FS filesystem. Thanks to Nille_kungen.
ap/cups-filters-1.22.5-x86_64-1.txz:  Upgraded.
ap/itstool-2.0.6-x86_64-1.txz:  Upgraded.
d/python-setuptools-41.0.0-x86_64-1.txz:  Upgraded.
l/gobject-introspection-1.60.1-x86_64-1.txz:  Upgraded.
l/imagemagick-6.9.10_39-x86_64-1.txz:  Upgraded.
l/libcroco-0.6.13-x86_64-1.txz:  Upgraded.
l/libnotify-0.7.8-x86_64-1.txz:  Upgraded.
n/cifs-utils-6.9-x86_64-1.txz:  Upgraded.
n/nfs-utils-2.3.3-x86_64-2.txz:  Rebuilt.
  Include recovery directory. Thanks to upnort.
n/samba-4.10.2-x86_64-1.txz:  Upgraded.
  This is a security release in order to address the following defects:
  World writable files in Samba AD DC private/ dir.
  Save registry file outside share as unprivileged user.
  For more information, see:
    https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-3870
    https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-3880
  (* Security fix *)
x/libva-2.4.1-x86_64-1.txz:  Upgraded.
x/pixman-0.38.2-x86_64-1.txz:  Upgraded.
xap/gimp-2.10.10-x86_64-1.txz:  Upgraded.

9 files changed, 1688 insertions, 143 deletions

diff --git a/source/a/grub/grub.SlackBuild b/source/a/grub/grub.SlackBuild
index 4b00083b3..efbb99a7f 100755
--- a/source/a/grub/grub.SlackBuild
+++ b/source/a/grub/grub.SlackBuild
@@ -1,6 +1,6 @@
 #!/bin/bash
 
-# Copyright 2013, 2016, 2017, 2018  Patrick J. Volkerding, Sebeka, Minnesota, USA
+# Copyright 2013, 2016, 2017, 2018, 2019  Patrick J. Volkerding, Sebeka, Minnesota, USA
 # All rights reserved.
 #
 # Redistribution and use of this script, with or without modification, is
@@ -28,7 +28,7 @@ PKGNAM=grub
 VERSION=${VERSION:-$(echo $PKGNAM-*.tar.xz | rev | cut -f 3- -d . | cut -f 1 -d - | rev)}
 # Better to use _ than ~ in the package filenames version:
 PKGVER=$(echo $VERSION | tr '~' '_')
-BUILD=${BUILD:-4}
+BUILD=${BUILD:-5}
 
 # Automatically determine the architecture we're building on:
 if [ -z "$ARCH" ]; then
@@ -121,6 +121,12 @@ zcat $CWD/grub.xfs.sparse.inodes.patch.gz | patch -p1 --verbose || exit 1
 # Fix breakage when compiled with recent binutils:
 zcat $CWD/grub.binutils.fix.diff.gz | patch -p1 --verbose || exit 1
 
+# Support F2FS filesystem:
+zcat $CWD/grub.f2fs.patch.gz | patch -p1 --verbose || exit 1
+
+# Regenerate build system to fix dependency on outdated automake:
+autoreconf -vif
+
 build_grub() {
   EFI_DO="$*"
   # Configure:
diff --git a/source/a/grub/grub.f2fs.patch b/source/a/grub/grub.f2fs.patch
new file mode 100644
index 000000000..527715303
--- /dev/null
+++ b/source/a/grub/grub.f2fs.patch
@@ -0,0 +1,1514 @@
+From 71f9e4ac44142af52c3fc1860436cf9e432bf764 Mon Sep 17 00:00:00 2001
+From: Jaegeuk Kim <jaegeuk@kernel.org>
+Date: Thu, 29 Mar 2018 16:37:39 +0100
+Subject: fs: Add F2FS support
+
+"F2FS (Flash-Friendly File System) is flash-friendly file system which was merged
+into Linux kernel v3.8 in 2013.
+
+The motive for F2FS was to build a file system that from the start, takes into
+account the characteristics of NAND flash memory-based storage devices (such as
+solid-state disks, eMMC, and SD cards).
+
+F2FS was designed on a basis of a log-structured file system approach, which
+remedies some known issues of the older log structured file systems, such as
+the snowball effect of wandering trees and high cleaning overhead. In addition,
+since a NAND-based storage device shows different characteristics according to
+its internal geometry or flash memory management scheme (such as the Flash
+Translation Layer or FTL), it supports various parameters not only for
+configuring on-disk layout, but also for selecting allocation and cleaning
+algorithm.", quote by https://en.wikipedia.org/wiki/F2FS.
+
+The source codes for F2FS are available from:
+
+http://git.kernel.org/cgit/linux/kernel/git/jaegeuk/f2fs.git
+http://git.kernel.org/cgit/linux/kernel/git/jaegeuk/f2fs-tools.git
+
+This patch has been integrated in OpenMandriva Lx 3.
+  https://www.openmandriva.org/
+
+Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
+Signed-off-by: Pete Batard <pete@akeo.ie>
+Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
+Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
+---
+ Makefile.util.def            |    7 +
+ docs/grub.texi               |    7 +-
+ grub-core/Makefile.core.def  |    5 +
+ grub-core/fs/f2fs.c          | 1314 ++++++++++++++++++++++++++++++++++++++++++
+ po/exclude.pot               |    1 +
+ tests/f2fs_test.in           |   19 +
+ tests/util/grub-fs-tester.in |   10 +-
+ 7 files changed, 1358 insertions(+), 5 deletions(-)
+ create mode 100644 grub-core/fs/f2fs.c
+ create mode 100644 tests/f2fs_test.in
+
+diff --git a/Makefile.util.def b/Makefile.util.def
+index f9caccb..3180ac8 100644
+--- a/Makefile.util.def
++++ b/Makefile.util.def
+@@ -99,6 +99,7 @@ library = {
+   common = grub-core/fs/ext2.c;
+   common = grub-core/fs/fat.c;
+   common = grub-core/fs/exfat.c;
++  common = grub-core/fs/f2fs.c;
+   common = grub-core/fs/fshelp.c;
+   common = grub-core/fs/hfs.c;
+   common = grub-core/fs/hfsplus.c;
+@@ -776,6 +777,12 @@ script = {
+ 
+ script = {
+   testcase;
++  name = f2fs_test;
++  common = tests/f2fs_test.in;
++};
++
++script = {
++  testcase;
+   name = nilfs2_test;
+   common = tests/nilfs2_test.in;
+ };
+diff --git a/docs/grub.texi b/docs/grub.texi
+index 65b4bbe..0f2ab91 100644
+--- a/docs/grub.texi
++++ b/docs/grub.texi
+@@ -360,8 +360,9 @@ blocklist notation. The currently supported filesystem types are @dfn{Amiga
+ Fast FileSystem (AFFS)}, @dfn{AtheOS fs}, @dfn{BeFS},
+ @dfn{BtrFS} (including raid0, raid1, raid10, gzip and lzo),
+ @dfn{cpio} (little- and big-endian bin, odc and newc variants),
+-@dfn{Linux ext2/ext3/ext4}, @dfn{DOS FAT12/FAT16/FAT32}, @dfn{exFAT}, @dfn{HFS},
+-@dfn{HFS+}, @dfn{ISO9660} (including Joliet, Rock-ridge and multi-chunk files),
++@dfn{Linux ext2/ext3/ext4}, @dfn{DOS FAT12/FAT16/FAT32},
++@dfn{exFAT}, @dfn{F2FS}, @dfn{HFS}, @dfn{HFS+},
++@dfn{ISO9660} (including Joliet, Rock-ridge and multi-chunk files),
+ @dfn{JFS}, @dfn{Minix fs} (versions 1, 2 and 3), @dfn{nilfs2},
+ @dfn{NTFS} (including compression), @dfn{ReiserFS}, @dfn{ROMFS},
+ @dfn{Amiga Smart FileSystem (SFS)}, @dfn{Squash4}, @dfn{tar}, @dfn{UDF},
+@@ -5375,7 +5376,7 @@ NTFS, JFS, UDF, HFS+, exFAT, long filenames in FAT, Joliet part of
+ ISO9660 are treated as UTF-16 as per specification. AFS and BFS are read
+ as UTF-8, again according to specification. BtrFS, cpio, tar, squash4, minix,
+ minix2, minix3, ROMFS, ReiserFS, XFS, ext2, ext3, ext4, FAT (short names),
+-RockRidge part of ISO9660, nilfs2, UFS1, UFS2 and ZFS are assumed
++F2FS, RockRidge part of ISO9660, nilfs2, UFS1, UFS2 and ZFS are assumed
+ to be UTF-8. This might be false on systems configured with legacy charset
+ but as long as the charset used is superset of ASCII you should be able to
+ access ASCII-named files. And it's recommended to configure your system to use
+diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
+index 2c1d62c..fc4767f 100644
+--- a/grub-core/Makefile.core.def
++++ b/grub-core/Makefile.core.def
+@@ -1315,6 +1315,11 @@ module = {
+ };
+ 
+ module = {
++  name = f2fs;
++  common = fs/f2fs.c;
++};
++
++module = {
+   name = fshelp;
+   common = fs/fshelp.c;
+ };
+diff --git a/grub-core/fs/f2fs.c b/grub-core/fs/f2fs.c
+new file mode 100644
+index 0000000..1cad261
+--- /dev/null
++++ b/grub-core/fs/f2fs.c
+@@ -0,0 +1,1314 @@
++/*
++ *  f2fs.c - Flash-Friendly File System
++ *
++ *  Written by Jaegeuk Kim <jaegeuk@kernel.org>
++ *
++ *  Copyright (C) 2015  Free Software Foundation, Inc.
++ *
++ *  GRUB 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 3 of the License, or
++ *  (at your option) any later version.
++ *
++ *  GRUB 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 GRUB.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include <grub/err.h>
++#include <grub/file.h>
++#include <grub/mm.h>
++#include <grub/misc.h>
++#include <grub/disk.h>
++#include <grub/dl.h>
++#include <grub/types.h>
++#include <grub/charset.h>
++#include <grub/fshelp.h>
++
++GRUB_MOD_LICENSE ("GPLv3+");
++
++/* F2FS Magic Number. */
++#define F2FS_SUPER_MAGIC          0xf2f52010
++
++#define CHECKSUM_OFFSET           4092  /* Must be aligned 4 bytes. */
++#define U32_CHECKSUM_OFFSET       (CHECKSUM_OFFSET >> 2)
++#define CRCPOLY_LE                0xedb88320
++
++/* Byte-size offset. */
++#define F2FS_SUPER_OFFSET         ((grub_disk_addr_t)1024)
++#define F2FS_SUPER_OFFSET0        (F2FS_SUPER_OFFSET >> GRUB_DISK_SECTOR_BITS)
++#define F2FS_SUPER_OFFSET1        ((F2FS_SUPER_OFFSET + F2FS_BLKSIZE) >> \
++                                        GRUB_DISK_SECTOR_BITS)
++
++/* 9 bits for 512 bytes. */
++#define F2FS_MIN_LOG_SECTOR_SIZE  9
++
++/* Support only 4KB block. */
++#define F2FS_BLK_BITS             12
++#define F2FS_BLKSIZE              (1 << F2FS_BLK_BITS)
++#define F2FS_BLK_SEC_BITS         (F2FS_BLK_BITS - GRUB_DISK_SECTOR_BITS)
++
++#define VERSION_LEN               256
++#define F2FS_MAX_EXTENSION        64
++
++#define CP_COMPACT_SUM_FLAG       0x00000004
++#define CP_UMOUNT_FLAG            0x00000001
++
++#define MAX_ACTIVE_LOGS           16
++#define MAX_ACTIVE_NODE_LOGS      8
++#define MAX_ACTIVE_DATA_LOGS      8
++#define NR_CURSEG_DATA_TYPE       3
++#define NR_CURSEG_NODE_TYPE       3
++#define NR_CURSEG_TYPE            (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)
++
++#define ENTRIES_IN_SUM            512
++#define SUMMARY_SIZE              7
++#define SUM_FOOTER_SIZE           5
++#define JENTRY_SIZE               (sizeof(struct grub_f2fs_nat_jent))
++#define SUM_ENTRIES_SIZE          (SUMMARY_SIZE * ENTRIES_IN_SUM)
++#define SUM_JOURNAL_SIZE          (F2FS_BLKSIZE - SUM_FOOTER_SIZE - SUM_ENTRIES_SIZE)
++#define NAT_JOURNAL_ENTRIES       ((SUM_JOURNAL_SIZE - 2) / JENTRY_SIZE)
++#define NAT_JOURNAL_RESERVED      ((SUM_JOURNAL_SIZE - 2) % JENTRY_SIZE)
++
++#define NAT_ENTRY_SIZE            (sizeof(struct grub_f2fs_nat_entry))
++#define NAT_ENTRY_PER_BLOCK       (F2FS_BLKSIZE / NAT_ENTRY_SIZE)
++
++#define F2FS_NAME_LEN             255
++#define F2FS_SLOT_LEN             8
++#define NR_DENTRY_IN_BLOCK        214
++#define SIZE_OF_DIR_ENTRY         11    /* By byte. */
++#define BITS_PER_BYTE             8
++#define SIZE_OF_DENTRY_BITMAP     ((NR_DENTRY_IN_BLOCK + BITS_PER_BYTE - 1) / \
++                                        BITS_PER_BYTE)
++#define SIZE_OF_RESERVED          (F2FS_BLKSIZE - \
++                                        ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
++                                        NR_DENTRY_IN_BLOCK + SIZE_OF_DENTRY_BITMAP))
++
++#define F2FS_INLINE_XATTR_ADDRS   50    /* 200 bytes for inline xattrs. */
++#define DEF_ADDRS_PER_INODE       923   /* Address Pointers in an Inode. */
++
++#define ADDRS_PER_BLOCK           1018  /* Address Pointers in a Direct Block. */
++#define NIDS_PER_BLOCK            1018  /* Node IDs in an Indirect Block. */
++#define NODE_DIR1_BLOCK           (DEF_ADDRS_PER_INODE + 1)
++#define NODE_DIR2_BLOCK           (DEF_ADDRS_PER_INODE + 2)
++#define NODE_IND1_BLOCK           (DEF_ADDRS_PER_INODE + 3)
++#define NODE_IND2_BLOCK           (DEF_ADDRS_PER_INODE + 4)
++#define NODE_DIND_BLOCK           (DEF_ADDRS_PER_INODE + 5)
++
++#define MAX_INLINE_DATA           (4 * (DEF_ADDRS_PER_INODE - \
++                                        F2FS_INLINE_XATTR_ADDRS - 1))
++#define NR_INLINE_DENTRY          (MAX_INLINE_DATA * BITS_PER_BYTE / \
++                                        ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
++                                        BITS_PER_BYTE + 1))
++#define INLINE_DENTRY_BITMAP_SIZE ((NR_INLINE_DENTRY + BITS_PER_BYTE - 1) / \
++                                        BITS_PER_BYTE)
++#define INLINE_RESERVED_SIZE      (MAX_INLINE_DATA - \
++                                        ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
++                                        NR_INLINE_DENTRY + \
++                                        INLINE_DENTRY_BITMAP_SIZE))
++#define CURSEG_HOT_DATA           0
++
++#define CKPT_FLAG_SET(ckpt, f)    (ckpt)->ckpt_flags & \
++                                        grub_cpu_to_le32_compile_time (f)
++
++#define F2FS_INLINE_XATTR         0x01  /* File inline xattr flag. */
++#define F2FS_INLINE_DATA          0x02  /* File inline data flag. */
++#define F2FS_INLINE_DENTRY        0x04  /* File inline dentry flag. */
++#define F2FS_DATA_EXIST           0x08  /* File inline data exist flag. */
++#define F2FS_INLINE_DOTS          0x10  /* File having implicit dot dentries. */
++
++#define MAX_VOLUME_NAME           512
++
++enum FILE_TYPE
++{
++  F2FS_FT_UNKNOWN,
++  F2FS_FT_REG_FILE                = 1,
++  F2FS_FT_DIR                     = 2,
++  F2FS_FT_SYMLINK                 = 7
++};
++
++struct grub_f2fs_superblock
++{
++  grub_uint32_t                   magic;
++  grub_uint16_t                   dummy1[2];
++  grub_uint32_t                   log_sectorsize;
++  grub_uint32_t                   log_sectors_per_block;
++  grub_uint32_t                   log_blocksize;
++  grub_uint32_t                   log_blocks_per_seg;
++  grub_uint32_t                   segs_per_sec;
++  grub_uint32_t                   secs_per_zone;
++  grub_uint32_t                   checksum_offset;
++  grub_uint8_t                    dummy2[40];
++  grub_uint32_t                   cp_blkaddr;
++  grub_uint32_t                   sit_blkaddr;
++  grub_uint32_t                   nat_blkaddr;
++  grub_uint32_t                   ssa_blkaddr;
++  grub_uint32_t                   main_blkaddr;
++  grub_uint32_t                   root_ino;
++  grub_uint32_t                   node_ino;
++  grub_uint32_t                   meta_ino;
++  grub_uint8_t                    uuid[16];
++  grub_uint16_t                   volume_name[MAX_VOLUME_NAME];
++  grub_uint32_t                   extension_count;
++  grub_uint8_t                    extension_list[F2FS_MAX_EXTENSION][8];
++  grub_uint32_t                   cp_payload;
++  grub_uint8_t                    version[VERSION_LEN];
++  grub_uint8_t                    init_version[VERSION_LEN];
++} GRUB_PACKED;
++
++struct grub_f2fs_checkpoint
++{
++  grub_uint64_t                   checkpoint_ver;
++  grub_uint64_t                   user_block_count;
++  grub_uint64_t                   valid_block_count;
++  grub_uint32_t                   rsvd_segment_count;
++  grub_uint32_t                   overprov_segment_count;
++  grub_uint32_t                   free_segment_count;
++  grub_uint32_t                   cur_node_segno[MAX_ACTIVE_NODE_LOGS];
++  grub_uint16_t                   cur_node_blkoff[MAX_ACTIVE_NODE_LOGS];
++  grub_uint32_t                   cur_data_segno[MAX_ACTIVE_DATA_LOGS];
++  grub_uint16_t                   cur_data_blkoff[MAX_ACTIVE_DATA_LOGS];
++  grub_uint32_t                   ckpt_flags;
++  grub_uint32_t                   cp_pack_total_block_count;
++  grub_uint32_t                   cp_pack_start_sum;
++  grub_uint32_t                   valid_node_count;
++  grub_uint32_t                   valid_inode_count;
++  grub_uint32_t                   next_free_nid;
++  grub_uint32_t                   sit_ver_bitmap_bytesize;
++  grub_uint32_t                   nat_ver_bitmap_bytesize;
++  grub_uint32_t                   checksum_offset;
++  grub_uint64_t                   elapsed_time;
++  grub_uint8_t                    alloc_type[MAX_ACTIVE_LOGS];
++  grub_uint8_t                    sit_nat_version_bitmap[3900];
++  grub_uint32_t                   checksum;
++} GRUB_PACKED;
++
++struct grub_f2fs_nat_entry {
++  grub_uint8_t                    version;
++  grub_uint32_t                   ino;
++  grub_uint32_t                   block_addr;
++} GRUB_PACKED;
++
++struct grub_f2fs_nat_jent
++{
++  grub_uint32_t                   nid;
++  struct grub_f2fs_nat_entry      ne;
++} GRUB_PACKED;
++
++struct grub_f2fs_nat_journal {
++  grub_uint16_t                   n_nats;
++  struct grub_f2fs_nat_jent       entries[NAT_JOURNAL_ENTRIES];
++  grub_uint8_t                    reserved[NAT_JOURNAL_RESERVED];
++} GRUB_PACKED;
++
++struct grub_f2fs_nat_block {
++  struct grub_f2fs_nat_entry      ne[NAT_ENTRY_PER_BLOCK];
++} GRUB_PACKED;
++
++struct grub_f2fs_dir_entry
++{
++  grub_uint32_t                   hash_code;
++  grub_uint32_t                   ino;
++  grub_uint16_t                   name_len;
++  grub_uint8_t                    file_type;
++} GRUB_PACKED;
++
++struct grub_f2fs_inline_dentry
++{
++  grub_uint8_t                    dentry_bitmap[INLINE_DENTRY_BITMAP_SIZE];
++  grub_uint8_t                    reserved[INLINE_RESERVED_SIZE];
++  struct grub_f2fs_dir_entry      dentry[NR_INLINE_DENTRY];
++  grub_uint8_t                    filename[NR_INLINE_DENTRY][F2FS_SLOT_LEN];
++} GRUB_PACKED;
++
++struct grub_f2fs_dentry_block {
++  grub_uint8_t                    dentry_bitmap[SIZE_OF_DENTRY_BITMAP];
++  grub_uint8_t                    reserved[SIZE_OF_RESERVED];
++  struct grub_f2fs_dir_entry      dentry[NR_DENTRY_IN_BLOCK];
++  grub_uint8_t                    filename[NR_DENTRY_IN_BLOCK][F2FS_SLOT_LEN];
++} GRUB_PACKED;
++
++struct grub_f2fs_inode
++{
++  grub_uint16_t                   i_mode;
++  grub_uint8_t                    i_advise;
++  grub_uint8_t                    i_inline;
++  grub_uint32_t                   i_uid;
++  grub_uint32_t                   i_gid;
++  grub_uint32_t                   i_links;
++  grub_uint64_t                   i_size;
++  grub_uint64_t                   i_blocks;
++  grub_uint64_t                   i_atime;
++  grub_uint64_t                   i_ctime;
++  grub_uint64_t                   i_mtime;
++  grub_uint32_t                   i_atime_nsec;
++  grub_uint32_t                   i_ctime_nsec;
++  grub_uint32_t                   i_mtime_nsec;
++  grub_uint32_t                   i_generation;
++  grub_uint32_t                   i_current_depth;
++  grub_uint32_t                   i_xattr_nid;
++  grub_uint32_t                   i_flags;
++  grub_uint32_t                   i_pino;
++  grub_uint32_t                   i_namelen;
++  grub_uint8_t                    i_name[F2FS_NAME_LEN];
++  grub_uint8_t                    i_dir_level;
++  grub_uint8_t                    i_ext[12];
++  grub_uint32_t                   i_addr[DEF_ADDRS_PER_INODE];
++  grub_uint32_t                   i_nid[5];
++} GRUB_PACKED;
++
++struct grub_direct_node {
++  grub_uint32_t                   addr[ADDRS_PER_BLOCK];
++} GRUB_PACKED;
++
++struct grub_indirect_node {
++  grub_uint32_t                   nid[NIDS_PER_BLOCK];
++} GRUB_PACKED;
++
++struct grub_f2fs_node
++{
++  union
++  {
++    struct grub_f2fs_inode        i;
++    struct grub_direct_node       dn;
++    struct grub_indirect_node     in;
++    /* Should occupy F2FS_BLKSIZE totally. */
++    char                          buf[F2FS_BLKSIZE - 40];
++  };
++  grub_uint8_t                    dummy[40];
++} GRUB_PACKED;
++
++struct grub_fshelp_node
++{
++  struct grub_f2fs_data           *data;
++  struct grub_f2fs_node           inode;
++  grub_uint32_t                   ino;
++  int inode_read;
++};
++
++struct grub_f2fs_data
++{
++  struct grub_f2fs_superblock     sblock;
++  struct grub_f2fs_checkpoint     ckpt;
++
++  grub_uint32_t                   root_ino;
++  grub_uint32_t                   blocks_per_seg;
++  grub_uint32_t                   cp_blkaddr;
++  grub_uint32_t                   nat_blkaddr;
++
++  struct grub_f2fs_nat_journal    nat_j;
++  char                            *nat_bitmap;
++
++  grub_disk_t                     disk;
++  struct grub_f2fs_node           *inode;
++  struct grub_fshelp_node         diropen;
++};
++
++struct grub_f2fs_dir_iter_ctx
++{
++  struct grub_f2fs_data           *data;
++  grub_fshelp_iterate_dir_hook_t  hook;
++  void                            *hook_data;
++  grub_uint8_t                    *bitmap;
++  grub_uint8_t                    (*filename)[F2FS_SLOT_LEN];
++  struct grub_f2fs_dir_entry      *dentry;
++  int                             max;
++};
++
++struct grub_f2fs_dir_ctx
++{
++  grub_fs_dir_hook_t              hook;
++  void                            *hook_data;
++  struct grub_f2fs_data           *data;
++};
++
++static grub_dl_t my_mod;
++
++static int
++grub_f2fs_test_bit_le (int nr, const grub_uint8_t *addr)
++{
++  return addr[nr >> 3] & (1 << (nr & 7));
++}
++
++static char *
++get_inline_addr (struct grub_f2fs_inode *inode)
++{
++  return (char *) &inode->i_addr[1];
++}
++
++static grub_uint64_t
++grub_f2fs_file_size (struct grub_f2fs_inode *inode)
++{
++  return grub_le_to_cpu64 (inode->i_size);
++}
++
++static grub_uint32_t
++start_cp_addr (struct grub_f2fs_data *data)
++{
++  struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
++  grub_uint32_t start_addr = data->cp_blkaddr;
++
++  if (!(ckpt->checkpoint_ver & grub_cpu_to_le64_compile_time(1)))
++    return start_addr + data->blocks_per_seg;
++
++  return start_addr;
++}
++
++static grub_uint32_t
++start_sum_block (struct grub_f2fs_data *data)
++{
++  struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
++
++  return start_cp_addr (data) + grub_le_to_cpu32 (ckpt->cp_pack_start_sum);
++}
++
++static grub_uint32_t
++sum_blk_addr (struct grub_f2fs_data *data, int base, int type)
++{
++  struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
++
++  return start_cp_addr (data) +
++           grub_le_to_cpu32 (ckpt->cp_pack_total_block_count) -
++           (base + 1) + type;
++}
++
++static void *
++nat_bitmap_ptr (struct grub_f2fs_data *data)
++{
++  struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
++  grub_uint32_t offset;
++
++  if (grub_le_to_cpu32 (data->sblock.cp_payload) > 0)
++    return ckpt->sit_nat_version_bitmap;
++
++  offset = grub_le_to_cpu32 (ckpt->sit_ver_bitmap_bytesize);
++
++  return ckpt->sit_nat_version_bitmap + offset;
++}
++
++static grub_uint32_t
++get_node_id (struct grub_f2fs_node *rn, int off, int inode_block)
++{
++  if (inode_block)
++    return grub_le_to_cpu32 (rn->i.i_nid[off - NODE_DIR1_BLOCK]);
++
++  return grub_le_to_cpu32 (rn->in.nid[off]);
++}
++
++static grub_err_t
++grub_f2fs_block_read (struct grub_f2fs_data *data, grub_uint32_t blkaddr,
++                      void *buf)
++{
++  return grub_disk_read (data->disk,
++                         ((grub_disk_addr_t)blkaddr) << F2FS_BLK_SEC_BITS,
++                         0, F2FS_BLKSIZE, buf);
++}
++
++/* CRC32 */
++static grub_uint32_t
++grub_f2fs_cal_crc32 (const void *buf, const grub_uint32_t len)
++{
++  grub_uint32_t crc = F2FS_SUPER_MAGIC;
++  unsigned char *p = (unsigned char *)buf;
++  grub_uint32_t tmp = len;
++  int i;
++
++  while (tmp--)
++    {
++      crc ^= *p++;
++      for (i = 0; i < 8; i++)
++        crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
++    }
++
++  return crc;
++}
++
++static int
++grub_f2fs_crc_valid (grub_uint32_t blk_crc, void *buf, const grub_uint32_t len)
++{
++  grub_uint32_t cal_crc = 0;
++
++  cal_crc = grub_f2fs_cal_crc32 (buf, len);
++
++  return (cal_crc == blk_crc) ? 1 : 0;
++}
++
++static int
++grub_f2fs_test_bit (grub_uint32_t nr, const char *p)
++{
++  int mask;
++
++  p += (nr >> 3);
++  mask = 1 << (7 - (nr & 0x07));
++
++  return mask & *p;
++}
++
++static int
++grub_f2fs_sanity_check_sb (struct grub_f2fs_superblock *sb)
++{
++  grub_uint32_t log_sectorsize, log_sectors_per_block;
++
++  if (sb->magic != grub_cpu_to_le32_compile_time (F2FS_SUPER_MAGIC))
++    return -1;
++
++  if (sb->log_blocksize != grub_cpu_to_le32_compile_time (F2FS_BLK_BITS))
++    return -1;
++
++  log_sectorsize = grub_le_to_cpu32 (sb->log_sectorsize);
++  log_sectors_per_block = grub_le_to_cpu32 (sb->log_sectors_per_block);
++
++  if (log_sectorsize > F2FS_BLK_BITS)
++    return -1;
++
++  if (log_sectorsize < F2FS_MIN_LOG_SECTOR_SIZE)
++    return -1;
++
++  if (log_sectors_per_block + log_sectorsize != F2FS_BLK_BITS)
++    return -1;
++
++  return 0;
++}
++
++static int
++grub_f2fs_read_sb (struct grub_f2fs_data *data, grub_disk_addr_t offset)
++{
++  grub_disk_t disk = data->disk;
++  grub_err_t err;
++
++  /* Read first super block. */
++  err = grub_disk_read (disk, offset, 0, sizeof (data->sblock), &data->sblock);
++  if (err)
++    return -1;
++
++  return grub_f2fs_sanity_check_sb (&data->sblock);
++}
++
++static void *
++validate_checkpoint (struct grub_f2fs_data *data, grub_uint32_t cp_addr,
++                     grub_uint64_t *version)
++{
++  grub_uint32_t *cp_page_1, *cp_page_2;
++  struct grub_f2fs_checkpoint *cp_block;
++  grub_uint64_t cur_version = 0, pre_version = 0;
++  grub_uint32_t crc = 0;
++  grub_uint32_t crc_offset;
++  grub_err_t err;
++
++  /* Read the 1st cp block in this CP pack. */
++  cp_page_1 = grub_malloc (F2FS_BLKSIZE);
++  if (!cp_page_1)
++    return NULL;
++
++  err = grub_f2fs_block_read (data, cp_addr, cp_page_1);
++  if (err)
++    goto invalid_cp1;
++
++  cp_block = (struct grub_f2fs_checkpoint *)cp_page_1;
++  crc_offset = grub_le_to_cpu32 (cp_block->checksum_offset);
++  if (crc_offset != CHECKSUM_OFFSET)
++    goto invalid_cp1;
++
++  crc = grub_le_to_cpu32 (*(cp_page_1 + U32_CHECKSUM_OFFSET));
++  if (!grub_f2fs_crc_valid (crc, cp_block, crc_offset))
++    goto invalid_cp1;
++
++  pre_version = grub_le_to_cpu64 (cp_block->checkpoint_ver);
++
++  /* Read the 2nd cp block in this CP pack. */
++  cp_page_2 = grub_malloc (F2FS_BLKSIZE);
++  if (!cp_page_2)
++    goto invalid_cp1;
++
++  cp_addr += grub_le_to_cpu32 (cp_block->cp_pack_total_block_count) - 1;
++
++  err = grub_f2fs_block_read (data, cp_addr, cp_page_2);
++  if (err)
++    goto invalid_cp2;
++
++  cp_block = (struct grub_f2fs_checkpoint *)cp_page_2;
++  crc_offset = grub_le_to_cpu32 (cp_block->checksum_offset);
++  if (crc_offset != CHECKSUM_OFFSET)
++    goto invalid_cp2;
++
++  crc = grub_le_to_cpu32 (*(cp_page_2 + U32_CHECKSUM_OFFSET));
++  if (!grub_f2fs_crc_valid (crc, cp_block, crc_offset))
++    goto invalid_cp2;
++
++  cur_version = grub_le_to_cpu64 (cp_block->checkpoint_ver);
++  if (cur_version == pre_version)
++    {
++      *version = cur_version;
++      grub_free (cp_page_2);
++
++      return cp_page_1;
++    }
++
++ invalid_cp2:
++  grub_free (cp_page_2);
++
++ invalid_cp1:
++  grub_free (cp_page_1);
++
++  return NULL;
++}
++
++static grub_err_t
++grub_f2fs_read_cp (struct grub_f2fs_data *data)
++{
++  void *cp1, *cp2, *cur_page;
++  grub_uint64_t cp1_version = 0, cp2_version = 0;
++  grub_uint64_t cp_start_blk_no;
++
++  /*
++   * Finding out valid cp block involves read both
++   * sets (cp pack1 and cp pack 2).
++   */
++  cp_start_blk_no = data->cp_blkaddr;
++  cp1 = validate_checkpoint (data, cp_start_blk_no, &cp1_version);
++  if (!cp1 && grub_errno)
++    return grub_errno;
++
++  /* The second checkpoint pack should start at the next segment. */
++  cp_start_blk_no += data->blocks_per_seg;
++  cp2 = validate_checkpoint (data, cp_start_blk_no, &cp2_version);
++  if (!cp2 && grub_errno)
++    {
++      grub_free (cp1);
++      return grub_errno;
++    }
++
++  if (cp1 && cp2)
++    cur_page = (cp2_version > cp1_version) ? cp2 : cp1;
++  else if (cp1)
++    cur_page = cp1;
++  else if (cp2)
++    cur_page = cp2;
++  else
++    return grub_error (GRUB_ERR_BAD_FS, "no checkpoints");
++
++  grub_memcpy (&data->ckpt, cur_page, F2FS_BLKSIZE);
++
++  grub_free (cp1);
++  grub_free (cp2);
++
++  return 0;
++}
++
++static grub_err_t
++get_nat_journal (struct grub_f2fs_data *data)
++{
++  grub_uint32_t block;
++  char *buf;
++  grub_err_t err;
++
++  buf = grub_malloc (F2FS_BLKSIZE);
++  if (!buf)
++    return grub_errno;
++
++  if (CKPT_FLAG_SET(&data->ckpt, CP_COMPACT_SUM_FLAG))
++    block = start_sum_block (data);
++  else if (CKPT_FLAG_SET (&data->ckpt, CP_UMOUNT_FLAG))
++    block = sum_blk_addr (data, NR_CURSEG_TYPE, CURSEG_HOT_DATA);
++  else
++    block = sum_blk_addr (data, NR_CURSEG_DATA_TYPE, CURSEG_HOT_DATA);
++
++  err = grub_f2fs_block_read (data, block, buf);
++  if (err)
++    goto fail;
++
++  if (CKPT_FLAG_SET (&data->ckpt, CP_COMPACT_SUM_FLAG))
++    grub_memcpy (&data->nat_j, buf, SUM_JOURNAL_SIZE);
++  else
++    grub_memcpy (&data->nat_j, buf + SUM_ENTRIES_SIZE, SUM_JOURNAL_SIZE);
++
++ fail:
++  grub_free (buf);
++
++  return err;
++}
++
++static grub_uint32_t
++get_blkaddr_from_nat_journal (struct grub_f2fs_data *data, grub_uint32_t nid)
++{
++  grub_uint16_t n = grub_le_to_cpu16 (data->nat_j.n_nats);
++  grub_uint32_t blkaddr = 0;
++  grub_uint16_t i;
++
++  for (i = 0; i < n; i++)
++    {
++      if (grub_le_to_cpu32 (data->nat_j.entries[i].nid) == nid)
++        {
++          blkaddr = grub_le_to_cpu32 (data->nat_j.entries[i].ne.block_addr);
++          break;
++        }
++    }
++
++  return blkaddr;
++}
++
++static grub_uint32_t
++get_node_blkaddr (struct grub_f2fs_data *data, grub_uint32_t nid)
++{
++  struct grub_f2fs_nat_block *nat_block;
++  grub_uint32_t seg_off, block_off, entry_off, block_addr;
++  grub_uint32_t blkaddr;
++  grub_err_t err;
++
++  blkaddr = get_blkaddr_from_nat_journal (data, nid);
++  if (blkaddr)
++    return blkaddr;
++
++  nat_block = grub_malloc (F2FS_BLKSIZE);
++  if (!nat_block)
++    return 0;
++
++  block_off = nid / NAT_ENTRY_PER_BLOCK;
++  entry_off = nid % NAT_ENTRY_PER_BLOCK;
++
++  seg_off = block_off / data->blocks_per_seg;
++  block_addr = data->nat_blkaddr +
++        ((seg_off * data->blocks_per_seg) << 1) +
++        (block_off & (data->blocks_per_seg - 1));
++
++  if (grub_f2fs_test_bit (block_off, data->nat_bitmap))
++    block_addr += data->blocks_per_seg;
++
++  err = grub_f2fs_block_read (data, block_addr, nat_block);
++  if (err)
++    {
++      grub_free (nat_block);
++      return 0;
++    }
++
++  blkaddr = grub_le_to_cpu32 (nat_block->ne[entry_off].block_addr);
++
++  grub_free (nat_block);
++
++  return blkaddr;
++}
++
++static int
++grub_get_node_path (struct grub_f2fs_inode *inode, grub_uint32_t block,
++                    grub_uint32_t offset[4], grub_uint32_t noffset[4])
++{
++  grub_uint32_t direct_blks = ADDRS_PER_BLOCK;
++  grub_uint32_t dptrs_per_blk = NIDS_PER_BLOCK;
++  grub_uint32_t indirect_blks = ADDRS_PER_BLOCK * NIDS_PER_BLOCK;
++  grub_uint32_t dindirect_blks = indirect_blks * NIDS_PER_BLOCK;
++  grub_uint32_t direct_index = DEF_ADDRS_PER_INODE;
++  int n = 0;
++  int level = 0;
++
++  if (inode->i_inline & F2FS_INLINE_XATTR)
++    direct_index -= F2FS_INLINE_XATTR_ADDRS;
++
++  noffset[0] = 0;
++
++  if (block < direct_index)
++    {
++      offset[n] = block;
++      goto got;
++    }
++
++  block -= direct_index;
++  if (block < direct_blks)
++    {
++      offset[n++] = NODE_DIR1_BLOCK;
++      noffset[n] = 1;
++      offset[n] = block;
++      level = 1;
++      goto got;
++    }
++
++  block -= direct_blks;
++  if (block < direct_blks)
++    {
++      offset[n++] = NODE_DIR2_BLOCK;
++      noffset[n] = 2;
++      offset[n] = block;
++      level = 1;
++      goto got;
++    }
++
++  block -= direct_blks;
++  if (block < indirect_blks)
++    {
++      offset[n++] = NODE_IND1_BLOCK;
++      noffset[n] = 3;
++      offset[n++] = block / direct_blks;
++      noffset[n] = 4 + offset[n - 1];
++      offset[n] = block % direct_blks;
++      level = 2;
++      goto got;
++    }
++
++  block -= indirect_blks;
++  if (block < indirect_blks)
++    {
++      offset[n++] = NODE_IND2_BLOCK;
++      noffset[n] = 4 + dptrs_per_blk;
++      offset[n++] = block / direct_blks;
++      noffset[n] = 5 + dptrs_per_blk + offset[n - 1];
++      offset[n] = block % direct_blks;
++      level = 2;
++      goto got;
++    }
++
++  block -= indirect_blks;
++  if (block < dindirect_blks)
++    {
++      offset[n++] = NODE_DIND_BLOCK;
++      noffset[n] = 5 + (dptrs_per_blk * 2);
++      offset[n++] = block / indirect_blks;
++      noffset[n] = 6 + (dptrs_per_blk * 2) +
++      offset[n - 1] * (dptrs_per_blk + 1);
++      offset[n++] = (block / direct_blks) % dptrs_per_blk;
++      noffset[n] = 7 + (dptrs_per_blk * 2) +
++      offset[n - 2] * (dptrs_per_blk + 1) + offset[n - 1];
++      offset[n] = block % direct_blks;
++      level = 3;
++      goto got;
++    }
++
++ got:
++  return level;
++}
++
++static grub_err_t
++grub_f2fs_read_node (struct grub_f2fs_data *data,
++                     grub_uint32_t nid, struct grub_f2fs_node *np)
++{
++  grub_uint32_t blkaddr;
++
++  blkaddr = get_node_blkaddr (data, nid);
++  if (!blkaddr)
++    return grub_errno;
++
++  return grub_f2fs_block_read (data, blkaddr, np);
++}
++
++static struct grub_f2fs_data *
++grub_f2fs_mount (grub_disk_t disk)
++{
++  struct grub_f2fs_data *data;
++  grub_err_t err;
++
++  data = grub_malloc (sizeof (*data));
++  if (!data)
++    return NULL;
++
++  data->disk = disk;
++
++  if (grub_f2fs_read_sb (data, F2FS_SUPER_OFFSET0))
++    {
++      if (grub_f2fs_read_sb (data, F2FS_SUPER_OFFSET1))
++        {
++          if (grub_errno == GRUB_ERR_NONE)
++            grub_error (GRUB_ERR_BAD_FS,
++                        "not a F2FS filesystem (no superblock)");
++          goto fail;
++        }
++    }
++
++  data->root_ino = grub_le_to_cpu32 (data->sblock.root_ino);
++  data->cp_blkaddr = grub_le_to_cpu32 (data->sblock.cp_blkaddr);
++  data->nat_blkaddr = grub_le_to_cpu32 (data->sblock.nat_blkaddr);
++  data->blocks_per_seg = 1 <<
++    grub_le_to_cpu32 (data->sblock.log_blocks_per_seg);
++
++  err = grub_f2fs_read_cp (data);
++  if (err)
++    goto fail;
++
++  data->nat_bitmap = nat_bitmap_ptr (data);
++
++  err = get_nat_journal (data);
++  if (err)
++    goto fail;
++
++  data->diropen.data = data;
++  data->diropen.ino = data->root_ino;
++  data->diropen.inode_read = 1;
++  data->inode = &data->diropen.inode;
++
++  err = grub_f2fs_read_node (data, data->root_ino, data->inode);
++  if (err)
++    goto fail;
++
++  return data;
++
++ fail:
++  grub_free (data);
++
++  return NULL;
++}
++
++/* Guarantee inline_data was handled by caller. */
++static grub_disk_addr_t
++grub_f2fs_get_block (grub_fshelp_node_t node, grub_disk_addr_t block_ofs)
++{
++  struct grub_f2fs_data *data = node->data;
++  struct grub_f2fs_inode *inode = &node->inode.i;
++  grub_uint32_t offset[4], noffset[4], nids[4];
++  struct grub_f2fs_node *node_block;
++  grub_uint32_t block_addr = -1;
++  int level, i;
++
++  level = grub_get_node_path (inode, block_ofs, offset, noffset);
++  if (level == 0)
++    return grub_le_to_cpu32 (inode->i_addr[offset[0]]);
++
++  node_block = grub_malloc (F2FS_BLKSIZE);
++  if (!node_block)
++    return -1;
++
++  nids[1] = get_node_id (&node->inode, offset[0], 1);
++
++  /* Get indirect or direct nodes. */
++  for (i = 1; i <= level; i++)
++    {
++      grub_f2fs_read_node (data, nids[i], node_block);
++      if (grub_errno)
++        goto fail;
++
++      if (i < level)
++        nids[i + 1] = get_node_id (node_block, offset[i], 0);
++    }
++
++  block_addr = grub_le_to_cpu32 (node_block->dn.addr[offset[level]]);
++
++ fail:
++  grub_free (node_block);
++
++  return block_addr;
++}
++
++static grub_ssize_t
++grub_f2fs_read_file (grub_fshelp_node_t node,
++                     grub_disk_read_hook_t read_hook, void *read_hook_data,
++                     grub_off_t pos, grub_size_t len, char *buf)
++{
++  struct grub_f2fs_inode *inode = &node->inode.i;
++  grub_off_t filesize = grub_f2fs_file_size (inode);
++  char *inline_addr = get_inline_addr (inode);
++
++  if (inode->i_inline & F2FS_INLINE_DATA)
++    {
++      if (filesize > MAX_INLINE_DATA)
++        return -1;
++
++      if (len > filesize - pos)
++        len = filesize - pos;
++
++      grub_memcpy (buf, inline_addr + pos, len);
++      return len;
++    }
++
++  return grub_fshelp_read_file (node->data->disk, node,
++                                read_hook, read_hook_data,
++                                pos, len, buf, grub_f2fs_get_block,
++                                filesize,
++                                F2FS_BLK_SEC_BITS, 0);
++}
++
++static char *
++grub_f2fs_read_symlink (grub_fshelp_node_t node)
++{
++  char *symlink;
++  struct grub_fshelp_node *diro = node;
++  grub_uint64_t filesize;
++
++  if (!diro->inode_read)
++    {
++      grub_f2fs_read_node (diro->data, diro->ino, &diro->inode);
++      if (grub_errno)
++        return 0;
++    }
++
++  filesize = grub_f2fs_file_size(&diro->inode.i);
++
++  symlink = grub_malloc (filesize + 1);
++  if (!symlink)
++    return 0;
++
++  grub_f2fs_read_file (diro, 0, 0, 0, filesize, symlink);
++  if (grub_errno)
++    {
++      grub_free (symlink);
++      return 0;
++    }
++
++  symlink[filesize] = '\0';
++
++  return symlink;
++}
++
++static int
++grub_f2fs_check_dentries (struct grub_f2fs_dir_iter_ctx *ctx)
++{
++  struct grub_fshelp_node *fdiro;
++  int i;
++
++  for (i = 0; i < ctx->max;)
++    {
++      char *filename;
++      enum grub_fshelp_filetype type = GRUB_FSHELP_UNKNOWN;
++      enum FILE_TYPE ftype;
++      int name_len;
++      int ret;
++
++      if (grub_f2fs_test_bit_le (i, ctx->bitmap) == 0)
++        {
++          i++;
++          continue;
++        }
++
++      ftype = ctx->dentry[i].file_type;
++      name_len = grub_le_to_cpu16 (ctx->dentry[i].name_len);
++      filename = grub_malloc (name_len + 1);
++      if (!filename)
++        return 0;
++
++      grub_memcpy (filename, ctx->filename[i], name_len);
++      filename[name_len] = 0;
++
++      fdiro = grub_malloc (sizeof (struct grub_fshelp_node));
++      if (!fdiro)
++        {
++          grub_free(filename);
++          return 0;
++        }
++
++      if (ftype == F2FS_FT_DIR)
++        type = GRUB_FSHELP_DIR;
++      else if (ftype == F2FS_FT_SYMLINK)
++        type = GRUB_FSHELP_SYMLINK;
++      else if (ftype == F2FS_FT_REG_FILE)
++        type = GRUB_FSHELP_REG;
++
++      fdiro->data = ctx->data;
++      fdiro->ino = grub_le_to_cpu32 (ctx->dentry[i].ino);
++      fdiro->inode_read = 0;
++
++      ret = ctx->hook (filename, type, fdiro, ctx->hook_data);
++      grub_free(filename);
++      if (ret)
++        return 1;
++
++      i += (name_len + F2FS_SLOT_LEN - 1) / F2FS_SLOT_LEN;
++    }
++
++    return 0;
++}
++
++static int
++grub_f2fs_iterate_inline_dir (struct grub_f2fs_inode *dir,
++                              struct grub_f2fs_dir_iter_ctx *ctx)
++{
++  struct grub_f2fs_inline_dentry *de_blk;
++
++  de_blk = (struct grub_f2fs_inline_dentry *) get_inline_addr (dir);
++
++  ctx->bitmap = de_blk->dentry_bitmap;
++  ctx->dentry = de_blk->dentry;
++  ctx->filename = de_blk->filename;
++  ctx->max = NR_INLINE_DENTRY;
++
++  return grub_f2fs_check_dentries (ctx);
++}
++
++static int
++grub_f2fs_iterate_dir (grub_fshelp_node_t dir,
++                       grub_fshelp_iterate_dir_hook_t hook, void *hook_data)
++{
++  struct grub_fshelp_node *diro = (struct grub_fshelp_node *) dir;
++  struct grub_f2fs_inode *inode;
++  struct grub_f2fs_dir_iter_ctx ctx = {
++    .data = diro->data,
++    .hook = hook,
++    .hook_data = hook_data
++  };
++  grub_off_t fpos = 0;
++
++  if (!diro->inode_read)
++    {
++      grub_f2fs_read_node (diro->data, diro->ino, &diro->inode);
++      if (grub_errno)
++        return 0;
++    }
++
++  inode = &diro->inode.i;
++
++  if (inode->i_inline & F2FS_INLINE_DENTRY)
++    return grub_f2fs_iterate_inline_dir (inode, &ctx);
++
++  while (fpos < grub_f2fs_file_size (inode))
++    {
++      struct grub_f2fs_dentry_block *de_blk;
++      char *buf;
++      int ret;
++
++      buf = grub_zalloc (F2FS_BLKSIZE);
++      if (!buf)
++        return 0;
++
++      grub_f2fs_read_file (diro, 0, 0, fpos, F2FS_BLKSIZE, buf);
++      if (grub_errno)
++        {
++          grub_free (buf);
++          return 0;
++        }
++
++      de_blk = (struct grub_f2fs_dentry_block *) buf;
++
++      ctx.bitmap = de_blk->dentry_bitmap;
++      ctx.dentry = de_blk->dentry;
++      ctx.filename = de_blk->filename;
++      ctx.max = NR_DENTRY_IN_BLOCK;
++
++      ret = grub_f2fs_check_dentries (&ctx);
++      grub_free (buf);
++      if (ret)
++        return 1;
++
++      fpos += F2FS_BLKSIZE;
++    }
++
++  return 0;
++}
++
++static int
++grub_f2fs_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
++                    grub_fshelp_node_t node, void *data)
++{
++  struct grub_f2fs_dir_ctx *ctx = data;
++  struct grub_dirhook_info info;
++
++  grub_memset (&info, 0, sizeof (info));
++  if (!node->inode_read)
++    {
++      grub_f2fs_read_node (ctx->data, node->ino, &node->inode);
++      if (!grub_errno)
++        node->inode_read = 1;
++      grub_errno = GRUB_ERR_NONE;
++    }
++  if (node->inode_read)
++    {
++      info.mtimeset = 1;
++      info.mtime = grub_le_to_cpu64 (node->inode.i.i_mtime);
++    }
++
++  info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
++  grub_free (node);
++
++  return ctx->hook (filename, &info, ctx->hook_data);
++}
++
++static grub_err_t
++grub_f2fs_dir (grub_device_t device, const char *path,
++               grub_fs_dir_hook_t hook, void *hook_data)
++{
++  struct grub_f2fs_dir_ctx ctx = {
++    .hook = hook,
++    .hook_data = hook_data
++  };
++  struct grub_fshelp_node *fdiro = 0;
++
++  grub_dl_ref (my_mod);
++
++  ctx.data = grub_f2fs_mount (device->disk);
++  if (!ctx.data)
++    goto fail;
++
++  grub_fshelp_find_file (path, &ctx.data->diropen, &fdiro,
++                         grub_f2fs_iterate_dir, grub_f2fs_read_symlink,
++                         GRUB_FSHELP_DIR);
++  if (grub_errno)
++    goto fail;
++
++  grub_f2fs_iterate_dir (fdiro, grub_f2fs_dir_iter, &ctx);
++
++ fail:
++  if (fdiro != &ctx.data->diropen)
++    grub_free (fdiro);
++  grub_free (ctx.data);
++  grub_dl_unref (my_mod);
++
++  return grub_errno;
++}
++
++/* Open a file named NAME and initialize FILE. */
++static grub_err_t
++grub_f2fs_open (struct grub_file *file, const char *name)
++{
++  struct grub_f2fs_data *data = NULL;
++  struct grub_fshelp_node *fdiro = 0;
++  struct grub_f2fs_inode *inode;
++
++  grub_dl_ref (my_mod);
++
++  data = grub_f2fs_mount (file->device->disk);
++  if (!data)
++    goto fail;
++
++  grub_fshelp_find_file (name, &data->diropen, &fdiro,
++                         grub_f2fs_iterate_dir, grub_f2fs_read_symlink,
++                         GRUB_FSHELP_REG);
++  if (grub_errno)
++    goto fail;
++
++  if (!fdiro->inode_read)
++    {
++      grub_f2fs_read_node (data, fdiro->ino, &fdiro->inode);
++      if (grub_errno)
++        goto fail;
++    }
++
++  grub_memcpy (data->inode, &fdiro->inode, sizeof (*data->inode));
++  grub_free (fdiro);
++
++  inode = &(data->inode->i);
++  file->size = grub_f2fs_file_size (inode);
++  file->data = data;
++  file->offset = 0;
++
++  if (inode->i_inline & F2FS_INLINE_DATA && file->size > MAX_INLINE_DATA)
++    grub_error (GRUB_ERR_BAD_FS, "corrupted inline_data: need fsck");
++
++  return 0;
++
++ fail:
++  if (fdiro != &data->diropen)
++    grub_free (fdiro);
++  grub_free (data);
++
++  grub_dl_unref (my_mod);
++
++  return grub_errno;
++}
++
++static grub_ssize_t
++grub_f2fs_read (grub_file_t file, char *buf, grub_size_t len)
++{
++  struct grub_f2fs_data *data = (struct grub_f2fs_data *) file->data;
++
++  return grub_f2fs_read_file (&data->diropen,
++                              file->read_hook, file->read_hook_data,
++                              file->offset, len, buf);
++}
++
++static grub_err_t
++grub_f2fs_close (grub_file_t file)
++{
++  struct grub_f2fs_data *data = (struct grub_f2fs_data *) file->data;
++
++  grub_free (data);
++
++  grub_dl_unref (my_mod);
++
++  return GRUB_ERR_NONE;
++}
++
++static grub_uint8_t *
++grub_f2fs_utf16_to_utf8 (grub_uint16_t *in_buf_le)
++{
++  grub_uint16_t in_buf[MAX_VOLUME_NAME];
++  grub_uint8_t *out_buf;
++  int len = 0;
++
++  out_buf = grub_malloc (MAX_VOLUME_NAME * GRUB_MAX_UTF8_PER_UTF16 + 1);
++  if (!out_buf)
++    return NULL;
++
++  while (*in_buf_le != 0 && len < MAX_VOLUME_NAME) {
++    in_buf[len] = grub_le_to_cpu16 (in_buf_le[len]);
++    len++;
++  }
++
++  *grub_utf16_to_utf8 (out_buf, in_buf, len) = '\0';
++
++  return out_buf;
++}
++
++static grub_err_t
++grub_f2fs_label (grub_device_t device, char **label)
++{
++  struct grub_f2fs_data *data;
++  grub_disk_t disk = device->disk;
++
++  grub_dl_ref (my_mod);
++
++  data = grub_f2fs_mount (disk);
++  if (data)
++    *label = (char *) grub_f2fs_utf16_to_utf8 (data->sblock.volume_name);
++  else
++    *label = NULL;
++
++  grub_free (data);
++  grub_dl_unref (my_mod);
++
++  return grub_errno;
++}
++
++static grub_err_t
++grub_f2fs_uuid (grub_device_t device, char **uuid)
++{
++  struct grub_f2fs_data *data;
++  grub_disk_t disk = device->disk;
++
++  grub_dl_ref (my_mod);
++
++  data = grub_f2fs_mount (disk);
++  if (data)
++    {
++      *uuid =
++        grub_xasprintf
++        ("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
++         data->sblock.uuid[0], data->sblock.uuid[1],
++         data->sblock.uuid[2], data->sblock.uuid[3],
++         data->sblock.uuid[4], data->sblock.uuid[5],
++         data->sblock.uuid[6], data->sblock.uuid[7],
++         data->sblock.uuid[8], data->sblock.uuid[9],
++         data->sblock.uuid[10], data->sblock.uuid[11],
++         data->sblock.uuid[12], data->sblock.uuid[13],
++         data->sblock.uuid[14], data->sblock.uuid[15]);
++    }
++  else
++    *uuid = NULL;
++
++  grub_free (data);
++  grub_dl_unref (my_mod);
++
++  return grub_errno;
++}
++
++static struct grub_fs grub_f2fs_fs = {
++  .name                  = "f2fs",
++  .dir                   = grub_f2fs_dir,
++  .open                  = grub_f2fs_open,
++  .read                  = grub_f2fs_read,
++  .close                 = grub_f2fs_close,
++  .label                 = grub_f2fs_label,
++  .uuid                  = grub_f2fs_uuid,
++#ifdef GRUB_UTIL
++  .reserved_first_sector = 1,
++  .blocklist_install     = 0,
++#endif
++  .next                  = 0
++};
++
++GRUB_MOD_INIT (f2fs)
++{
++  grub_fs_register (&grub_f2fs_fs);
++  my_mod = mod;
++}
++
++GRUB_MOD_FINI (f2fs)
++{
++  grub_fs_unregister (&grub_f2fs_fs);
++}
+diff --git a/po/exclude.pot b/po/exclude.pot
+index 0a9b215..816089c 100644
+--- a/po/exclude.pot
++++ b/po/exclude.pot
+@@ -1214,6 +1214,7 @@ msgstr ""
+ 
+ #: grub-core/commands/xnu_uuid.c:75 grub-core/fs/jfs.c:924
+ #: grub-core/fs/nilfs2.c:1135
++#: grub-core/fs/f2fs.c:1259
+ #, c-format
+ msgid "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"
+ msgstr ""
+diff --git a/tests/f2fs_test.in b/tests/f2fs_test.in
+new file mode 100644
+index 0000000..1ea77c8
+--- /dev/null
++++ b/tests/f2fs_test.in
+@@ -0,0 +1,19 @@
++#!/bin/sh
++
++set -e
++
++if [ "x$EUID" = "x" ] ; then
++ EUID=`id -u`
++fi
++
++if [ "$EUID" != 0 ] ; then
++ exit 77
++fi
++
++if ! which mkfs.f2fs >/dev/null 2>&1; then
++ echo "mkfs.f2fs not installed; cannot test f2fs."
++ exit 77
++fi
++
++
++"@builddir@/grub-fs-tester" f2fs
+diff --git a/tests/util/grub-fs-tester.in b/tests/util/grub-fs-tester.in
+index 15969d7..26bd57a 100644
+--- a/tests/util/grub-fs-tester.in
++++ b/tests/util/grub-fs-tester.in
+@@ -172,7 +172,7 @@ for LOGSECSIZE in $(range "$MINLOGSECSIZE" "$MAXLOGSECSIZE" 1); do
+ 	xsquash*)
+ 	    MINBLKSIZE=4096
+ 	    MAXBLKSIZE=1048576;;
+-	xxfs)
++	xxfs|xf2fs)
+ 	    MINBLKSIZE=$SECSIZE
+ 		# OS Limitation: GNU/Linux doesn't accept > 4096
+ 	    MAXBLKSIZE=4096;;
+@@ -299,6 +299,10 @@ for LOGSECSIZE in $(range "$MINLOGSECSIZE" "$MAXLOGSECSIZE" 1); do
+ 		x"btrfs"*)
+ 		    FSLABEL="grub_;/testé莭莽😁киритi urewfceniuewruevrewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoi";;
+ 
++	    # FS LIMITATION: f2fs label is at most 512 UTF-16 chars
++		x"f2fs")
++		    FSLABEL="grub_;/testé䏌䐓䏕киритiurewfceniuewruewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoirvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoircreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoifoiq";;
++
+ 	    # FS LIMITATION: exfat is at most 15 UTF-16 chars
+ 		x"exfat")
+ 		    FSLABEL="géт ;/莭莽😁кир";;
+@@ -508,7 +512,7 @@ for LOGSECSIZE in $(range "$MINLOGSECSIZE" "$MAXLOGSECSIZE" 1); do
+ 	    # FIXME: Not sure about BtrFS, NTFS, JFS, AFS, UDF and SFS. Check it.
+ 	# FS LIMITATION: as far as I know those FS don't store their last modification date.
+ 		x"jfs_caseins" | x"jfs" | x"xfs" | x"xfs_crc" | x"btrfs"* | x"reiserfs_old" | x"reiserfs" \
+-		    | x"bfs" | x"afs" \
++		    | x"bfs" | x"afs" | x"f2fs" \
+ 		    | x"tarfs" | x"cpio_"* | x"minix" | x"minix2" \
+ 		    | x"minix3" | x"ntfs"* | x"udf" | x"sfs"*)
+ 		    NOFSTIME=y;;
+@@ -792,6 +796,8 @@ for LOGSECSIZE in $(range "$MINLOGSECSIZE" "$MAXLOGSECSIZE" 1); do
+ 		    MOUNTDEVICE="/dev/mapper/grub_test-testvol"
+ 		    MOUNTFS=ext2
+ 		    "mkfs.ext2" -L "$FSLABEL" -q "${MOUNTDEVICE}"  ;;
++		xf2fs)
++		    "mkfs.f2fs" -l "$FSLABEL" -q "${LODEVICES[0]}" ;;
+ 		xnilfs2)
+ 		    "mkfs.nilfs2" -L "$FSLABEL" -b $BLKSIZE  -q "${MOUNTDEVICE}" ;;
+ 		xext2_old)
+-- 
+cgit v1.0-41-gc330
+
+
diff --git a/source/l/libcroco/898e3a8c8c03.patch b/source/l/libcroco/898e3a8c8c03.patch
deleted file mode 100644
index b669339ce..000000000
--- a/source/l/libcroco/898e3a8c8c03.patch
+++ /dev/null
@@ -1,58 +0,0 @@
-From 898e3a8c8c0314d2e6b106809a8e3e93cf9d4394 Mon Sep 17 00:00:00 2001
-From: Ignacio Casal Quinteiro <qignacio@amazon.com>
-Date: Sun, 16 Apr 2017 13:13:43 +0200
-Subject: input: check end of input before reading a byte
-
-When reading bytes we weren't check that the index wasn't
-out of bound and this could produce an invalid read which
-could deal to a security bug.
----
- src/cr-input.c | 11 +++++++++--
- 1 file changed, 9 insertions(+), 2 deletions(-)
-
-diff --git a/src/cr-input.c b/src/cr-input.c
-index 49000b1..3b63a88 100644
---- a/src/cr-input.c
-+++ b/src/cr-input.c
-@@ -256,7 +256,7 @@ cr_input_new_from_uri (const gchar * a_file_uri, enum CREncoding a_enc)
-                  *we should  free buf here because it's own by CRInput.
-                  *(see the last parameter of cr_input_new_from_buf().
-                  */
--                buf = NULL ;
-+                buf = NULL;
-         }
- 
-  cleanup:
-@@ -404,6 +404,8 @@ cr_input_get_nb_bytes_left (CRInput const * a_this)
- enum CRStatus
- cr_input_read_byte (CRInput * a_this, guchar * a_byte)
- {
-+        gulong nb_bytes_left = 0;
-+
-         g_return_val_if_fail (a_this && PRIVATE (a_this)
-                               && a_byte, CR_BAD_PARAM_ERROR);
- 
-@@ -413,6 +415,12 @@ cr_input_read_byte (CRInput * a_this, guchar * a_byte)
-         if (PRIVATE (a_this)->end_of_input == TRUE)
-                 return CR_END_OF_INPUT_ERROR;
- 
-+        nb_bytes_left = cr_input_get_nb_bytes_left (a_this);
-+
-+        if (nb_bytes_left < 1) {
-+                return CR_END_OF_INPUT_ERROR;
-+        }
-+
-         *a_byte = PRIVATE (a_this)->in_buf[PRIVATE (a_this)->next_byte_index];
- 
-         if (PRIVATE (a_this)->nb_bytes -
-@@ -477,7 +485,6 @@ cr_input_read_char (CRInput * a_this, guint32 * a_char)
-                 if (*a_char == '\n') {
-                         PRIVATE (a_this)->end_of_line = TRUE;
-                 }
--
-         }
- 
-         return status;
--- 
-cgit v0.12
-
diff --git a/source/l/libcroco/libcroco.SlackBuild b/source/l/libcroco/libcroco.SlackBuild
index 25a7652b3..eda23051b 100755
--- a/source/l/libcroco/libcroco.SlackBuild
+++ b/source/l/libcroco/libcroco.SlackBuild
@@ -26,7 +26,7 @@ cd $(dirname $0) ; CWD=$(pwd)
 
 PKGNAM=libcroco
 VERSION=${VERSION:-$(echo $PKGNAM-*.tar.?z* | rev | cut -f 3- -d . | cut -f 1 -d - | rev)}
-BUILD=${BUILD:-2}
+BUILD=${BUILD:-1}
 
 if [ -z "$ARCH" ]; then
   case "$( uname -m )" in
@@ -78,9 +78,6 @@ find . \
  \( -perm 666 -o -perm 664 -o -perm 600 -o -perm 444 -o -perm 440 -o -perm 400 \) \
  -exec chmod 644 {} \;
 
-# https://blogs.gentoo.org/ago/2017/04/17/libcroco-heap-overflow-and-undefined-behavior/
-patch -p1 --verbose < $CWD/898e3a8c8c03.patch || exit 1
-
 CFLAGS="$SLKCFLAGS" \
 CXXFLAGS="$SLKCFLAGS" \
 ./configure \
diff --git a/source/l/libnotify/libnotify.SlackBuild b/source/l/libnotify/libnotify.SlackBuild
index 98c4d3f64..53a69c039 100755
--- a/source/l/libnotify/libnotify.SlackBuild
+++ b/source/l/libnotify/libnotify.SlackBuild
@@ -3,7 +3,7 @@
 # Slackware build script for libnotify
 #
 # Copyright 2009  Erik W. Hanson, Minneapolis, MN, USA
-# Copyright 2010, 2018  Patrick J. Volkerding, Sebeka, MN, USA
+# Copyright 2010, 2018, 2019  Patrick J. Volkerding, Sebeka, MN, USA
 # All rights reserved.
 #
 # Redistribution and use of this script, with or without modification, is
@@ -27,7 +27,7 @@ cd $(dirname $0) ; CWD=$(pwd)
 
 PKGNAM=libnotify
 VERSION=${VERSION:-$(echo $PKGNAM-*.tar.xz | rev | cut -f 3- -d . | cut -f 1 -d - | rev)}
-BUILD=${BUILD:-2}
+BUILD=${BUILD:-1}
 
 NUMJOBS=${NUMJOBS:-" -j$(expr $(nproc) + 1) "}
 
@@ -73,18 +73,29 @@ cd $PKGNAM-$VERSION || exit 1
 chown -R root:root .
 chmod -R u+w,go+r-w,a-s .
 
-CFLAGS="$SLKCFLAGS" \
-./configure \
+# Configure, build, and install:
+export CFLAGS="$SLKCFLAGS"
+export CXXFLAGS="$SLKCFLAGS"
+mkdir meson-build
+cd meson-build
+meson setup \
   --prefix=/usr \
-  --libdir=/usr/lib${LIBDIRSUFFIX} \
+  --libdir=lib${LIBDIRSUFFIX} \
+  --libexecdir=/usr/libexec \
+  --bindir=/usr/bin \
+  --sbindir=/usr/sbin \
+  --includedir=/usr/include \
+  --datadir=/usr/share \
+  --mandir=/usr/man \
   --sysconfdir=/etc \
   --localstatedir=/var \
-  --enable-static=no \
-  --enable-shared=yes \
-  --build=$ARCH-slackware-linux || exit 1
-
-make $NUMJOBS || make || exit 1
-make install DESTDIR=$PKG || exit 1
+  --buildtype=release \
+  -Ddocbook_docs=disabled \
+  -Dtests=false \
+  .. || exit 1
+  ninja || exit 1
+  DESTDIR=$PKG ninja install || exit 1
+cd ..
 
 # Don't ship .la files:
 rm -f $PKG/{,usr/}lib${LIBDIRSUFFIX}/*.la
diff --git a/source/n/nfs-utils/nfs-utils.SlackBuild b/source/n/nfs-utils/nfs-utils.SlackBuild
index 217ed6f2f..336ffb296 100755
--- a/source/n/nfs-utils/nfs-utils.SlackBuild
+++ b/source/n/nfs-utils/nfs-utils.SlackBuild
@@ -24,7 +24,7 @@ cd $(dirname $0) ; CWD=$(pwd)
 
 PKGNAM=nfs-utils
 VERSION=${VERSION:-$(echo $PKGNAM-*.tar.?z | rev | cut -f 3- -d . | cut -f 1 -d - | rev)}
-BUILD=${BUILD:-1}
+BUILD=${BUILD:-2}
 
 # Automatically determine the architecture we're building on:
 if [ -z "$ARCH" ]; then
@@ -132,6 +132,9 @@ mkdir -p $PKG/sbin
 mv $PKG/usr/sbin/rpc.statd $PKG/sbin
 ( cd $PKG/usr/sbin ; ln -sf ../../sbin/rpc.statd . )
 
+# Make recovery directory:
+mkdir -p $PKG/var/lib/nfs/v4recovery
+
 # Chown /var/lib/nfs so that rpc.statd runs as rpc:rpc:
 chown -R rpc:rpc $PKG/var/lib/nfs
 
diff --git a/source/n/nfs-utils/rc.nfsd b/source/n/nfs-utils/rc.nfsd
index 965db6b4c..06c34b018 100644
--- a/source/n/nfs-utils/rc.nfsd
+++ b/source/n/nfs-utils/rc.nfsd
@@ -24,6 +24,14 @@ nfsd_start() {
     exit # no uncommented shares in /etc/exports
   fi
 
+  # Without this directory the logs will complain with
+  # 'NFSD: Unable to end grace period'.
+  NFSV4RECOVERYDIR=$(cat /proc/fs/nfsd/nfsv4recoverydir)
+  if [ -r /proc/fs/nfsd/nfsv4recoverydir -a ! -d "$NFSV4RECOVERYDIR" ]; then
+    mkdir "$NFSV4RECOVERYDIR"
+    chown -R rpc:rpc "$NFSV4RECOVERYDIR"
+  fi
+
   # If we do not detect nfsd support built into the kernel (or previously
   # loaded as a module), we will try to load the nfsd.ko kernel module:
   if [ ! -r /proc/1/net/rpc/nfsd ]; then
diff --git a/source/n/samba/samba.url b/source/n/samba/samba.url
index 4eba19fa7..221981517 100644
--- a/source/n/samba/samba.url
+++ b/source/n/samba/samba.url
@@ -1,2 +1,2 @@
-https://download.samba.org/pub/samba/stable/samba-4.10.1.tar.gz
-https://download.samba.org/pub/samba/stable/samba-4.10.1.tar.asc
+https://download.samba.org/pub/samba/stable/samba-4.10.2.tar.gz
+https://download.samba.org/pub/samba/stable/samba-4.10.2.tar.asc
diff --git a/source/x/x11/patch/pixman/pixman.remove.tests.that.fail.to.compile.diff b/source/x/x11/patch/pixman/pixman.remove.tests.that.fail.to.compile.diff
index 113f8ca6c..86d01e898 100644
--- a/source/x/x11/patch/pixman/pixman.remove.tests.that.fail.to.compile.diff
+++ b/source/x/x11/patch/pixman/pixman.remove.tests.that.fail.to.compile.diff
@@ -1,16 +1,16 @@
---- ./test/Makefile.in.orig	2019-02-11 06:24:53.000000000 -0600
-+++ ./test/Makefile.in	2019-02-12 13:54:42.157995706 -0600
-@@ -106,19 +106,18 @@
+--- ./test/Makefile.in.orig	2019-04-07 15:31:45.000000000 -0500
++++ ./test/Makefile.in	2019-04-08 15:06:58.331894784 -0500
+@@ -106,19 +106,17 @@
  	region-translate-test$(EXEEXT) fetch-test$(EXEEXT) \
  	a1-trap-test$(EXEEXT) prng-test$(EXEEXT) \
  	radial-invalid$(EXEEXT) pdf-op-test$(EXEEXT) \
 -	region-test$(EXEEXT) combiner-test$(EXEEXT) \
-+	combiner-test$(EXEEXT) \
- 	scaling-crash-test$(EXEEXT) alpha-loop$(EXEEXT) \
+-	scaling-crash-test$(EXEEXT) alpha-loop$(EXEEXT) \
 -	scaling-helpers-test$(EXEEXT) thread-test$(EXEEXT) \
 -	rotate-test$(EXEEXT) alphamap$(EXEEXT) \
++	combiner-test$(EXEEXT) \
++	scaling-crash-test$(EXEEXT) \
 +	thread-test$(EXEEXT) \
-+	alphamap$(EXEEXT) \
  	gradient-crash-test$(EXEEXT) pixel-test$(EXEEXT) \
 -	matrix-test$(EXEEXT) filter-reduction-test$(EXEEXT) \
 -	composite-traps-test$(EXEEXT) region-contains-test$(EXEEXT) \
@@ -21,14 +21,14 @@
 -	affine-test$(EXEEXT) scaling-test$(EXEEXT) composite$(EXEEXT) \
 -	tolerance-test$(EXEEXT)
 +	cover-test$(EXEEXT) \
-+	scaling-test$(EXEEXT) composite$(EXEEXT)
++	scaling-test$(EXEEXT)
  am__EXEEXT_2 = lowlevel-blt-bench$(EXEEXT) radial-perf-test$(EXEEXT) \
 -	check-formats$(EXEEXT) scaling-bench$(EXEEXT) \
 +	check-formats$(EXEEXT) \
  	affine-bench$(EXEEXT)
  PROGRAMS = $(noinst_PROGRAMS)
  LTLIBRARIES = $(noinst_LTLIBRARIES)
-@@ -144,12 +143,6 @@
+@@ -144,30 +142,6 @@
  affine_bench_DEPENDENCIES = libutils.la \
  	$(top_builddir)/pixman/libpixman-1.la $(am__DEPENDENCIES_1) \
  	$(am__DEPENDENCIES_1)
@@ -38,13 +38,18 @@
 -affine_test_DEPENDENCIES = libutils.la \
 -	$(top_builddir)/pixman/libpixman-1.la $(am__DEPENDENCIES_1) \
 -	$(am__DEPENDENCIES_1)
- alpha_loop_SOURCES = alpha-loop.c
- alpha_loop_OBJECTS = alpha-loop.$(OBJEXT)
- alpha_loop_LDADD = $(LDADD)
-@@ -162,12 +155,6 @@
- alphamap_DEPENDENCIES = libutils.la \
- 	$(top_builddir)/pixman/libpixman-1.la $(am__DEPENDENCIES_1) \
- 	$(am__DEPENDENCIES_1)
+-alpha_loop_SOURCES = alpha-loop.c
+-alpha_loop_OBJECTS = alpha-loop.$(OBJEXT)
+-alpha_loop_LDADD = $(LDADD)
+-alpha_loop_DEPENDENCIES = libutils.la \
+-	$(top_builddir)/pixman/libpixman-1.la $(am__DEPENDENCIES_1) \
+-	$(am__DEPENDENCIES_1)
+-alphamap_SOURCES = alphamap.c
+-alphamap_OBJECTS = alphamap.$(OBJEXT)
+-alphamap_LDADD = $(LDADD)
+-alphamap_DEPENDENCIES = libutils.la \
+-	$(top_builddir)/pixman/libpixman-1.la $(am__DEPENDENCIES_1) \
+-	$(am__DEPENDENCIES_1)
 -blitters_test_SOURCES = blitters-test.c
 -blitters_test_OBJECTS = blitters-test.$(OBJEXT)
 -blitters_test_LDADD = $(LDADD)
@@ -54,7 +59,20 @@
  check_formats_SOURCES = check-formats.c
  check_formats_OBJECTS = check-formats.$(OBJEXT)
  check_formats_LDADD = $(LDADD)
-@@ -240,12 +227,6 @@
+@@ -180,12 +154,6 @@
+ combiner_test_DEPENDENCIES = libutils.la \
+ 	$(top_builddir)/pixman/libpixman-1.la $(am__DEPENDENCIES_1) \
+ 	$(am__DEPENDENCIES_1)
+-composite_SOURCES = composite.c
+-composite_OBJECTS = composite.$(OBJEXT)
+-composite_LDADD = $(LDADD)
+-composite_DEPENDENCIES = libutils.la \
+-	$(top_builddir)/pixman/libpixman-1.la $(am__DEPENDENCIES_1) \
+-	$(am__DEPENDENCIES_1)
+ composite_traps_test_SOURCES = composite-traps-test.c
+ composite_traps_test_OBJECTS = composite-traps-test.$(OBJEXT)
+ composite_traps_test_LDADD = $(LDADD)
+@@ -240,12 +208,6 @@
  lowlevel_blt_bench_DEPENDENCIES = libutils.la \
  	$(top_builddir)/pixman/libpixman-1.la $(am__DEPENDENCIES_1) \
  	$(am__DEPENDENCIES_1)
@@ -67,7 +85,7 @@
  oob_test_SOURCES = oob-test.c
  oob_test_OBJECTS = oob-test.$(OBJEXT)
  oob_test_LDADD = $(LDADD)
-@@ -282,48 +263,18 @@
+@@ -282,48 +244,18 @@
  radial_perf_test_DEPENDENCIES = libutils.la \
  	$(top_builddir)/pixman/libpixman-1.la $(am__DEPENDENCIES_1) \
  	$(am__DEPENDENCIES_1)
@@ -116,7 +134,7 @@
  scaling_test_SOURCES = scaling-test.c
  scaling_test_OBJECTS = scaling-test.$(OBJEXT)
  scaling_test_LDADD = $(LDADD)
-@@ -348,12 +299,6 @@
+@@ -348,12 +280,6 @@
  thread_test_DEPENDENCIES = libutils.la \
  	$(top_builddir)/pixman/libpixman-1.la $(am__DEPENDENCIES_1) \
  	$(am__DEPENDENCIES_1)
@@ -129,17 +147,18 @@
  trap_crasher_SOURCES = trap-crasher.c
  trap_crasher_OBJECTS = trap-crasher.$(OBJEXT)
  trap_crasher_LDADD = $(LDADD)
-@@ -376,27 +321,24 @@
+@@ -376,27 +302,23 @@
  depcomp = $(SHELL) $(top_srcdir)/depcomp
  am__maybe_remake_depfiles = depfiles
  am__depfiles_remade = ./$(DEPDIR)/a1-trap-test.Po \
 -	./$(DEPDIR)/affine-bench.Po ./$(DEPDIR)/affine-test.Po \
-+	./$(DEPDIR)/affine-bench.Po \
- 	./$(DEPDIR)/alpha-loop.Po ./$(DEPDIR)/alphamap.Po \
+-	./$(DEPDIR)/alpha-loop.Po ./$(DEPDIR)/alphamap.Po \
 -	./$(DEPDIR)/blitters-test.Po ./$(DEPDIR)/check-formats.Po \
++	./$(DEPDIR)/affine-bench.Po \
 +	./$(DEPDIR)/check-formats.Po \
  	./$(DEPDIR)/combiner-test.Po \
- 	./$(DEPDIR)/composite-traps-test.Po ./$(DEPDIR)/composite.Po \
+-	./$(DEPDIR)/composite-traps-test.Po ./$(DEPDIR)/composite.Po \
++	./$(DEPDIR)/composite-traps-test.Po \
  	./$(DEPDIR)/cover-test.Po ./$(DEPDIR)/fence-image-self-test.Po \
  	./$(DEPDIR)/fetch-test.Po ./$(DEPDIR)/filter-reduction-test.Po \
  	./$(DEPDIR)/glyph-test.Po ./$(DEPDIR)/gradient-crash-test.Po \
@@ -161,13 +180,13 @@
  	./$(DEPDIR)/utils-prng.Plo ./$(DEPDIR)/utils.Plo
  am__mv = mv -f
  COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
-@@ -418,29 +360,29 @@
+@@ -418,29 +340,27 @@
  am__v_CCLD_0 = @echo "  CCLD    " $@;
  am__v_CCLD_1 = 
  SOURCES = $(libutils_la_SOURCES) a1-trap-test.c affine-bench.c \
 -	affine-test.c alpha-loop.c alphamap.c blitters-test.c \
-+	alpha-loop.c alphamap.c \
- 	check-formats.c combiner-test.c composite.c \
+-	check-formats.c combiner-test.c composite.c \
++	check-formats.c combiner-test.c \
  	composite-traps-test.c cover-test.c fence-image-self-test.c \
  	fetch-test.c filter-reduction-test.c glyph-test.c \
  	gradient-crash-test.c infinite-loop.c lowlevel-blt-bench.c \
@@ -184,8 +203,8 @@
 +	stress-test.c thread-test.c trap-crasher.c
  DIST_SOURCES = $(libutils_la_SOURCES) a1-trap-test.c affine-bench.c \
 -	affine-test.c alpha-loop.c alphamap.c blitters-test.c \
-+	alpha-loop.c alphamap.c \
- 	check-formats.c combiner-test.c composite.c \
+-	check-formats.c combiner-test.c composite.c \
++	check-formats.c combiner-test.c \
  	composite-traps-test.c cover-test.c fence-image-self-test.c \
  	fetch-test.c filter-reduction-test.c glyph-test.c \
  	gradient-crash-test.c infinite-loop.c lowlevel-blt-bench.c \
@@ -203,18 +222,18 @@
  am__can_run_installinfo = \
    case $$AM_UPDATE_INFO_DIR in \
      n|no|NO) false;; \
-@@ -834,29 +776,21 @@
+@@ -833,29 +753,18 @@
  	prng-test		      \
  	radial-invalid		      \
  	pdf-op-test		      \
 -	region-test		      \
  	combiner-test		      \
  	scaling-crash-test	      \
- 	alpha-loop		      \
+-	alpha-loop		      \
 -	scaling-helpers-test	      \
  	thread-test		      \
 -	rotate-test		      \
- 	alphamap		      \
+-	alphamap		      \
  	gradient-crash-test	      \
  	pixel-test		      \
 -	matrix-test		      \
@@ -228,12 +247,12 @@
 -	blitters-test		      \
 -	affine-test		      \
  	scaling-test		      \
- 	composite		      \
+-	composite		      \
 -	tolerance-test		      \
  	$(NULL)
  
  
-@@ -865,7 +799,6 @@
+@@ -864,7 +773,6 @@
  	lowlevel-blt-bench	\
  	radial-perf-test	\
          check-formats           \
@@ -241,7 +260,7 @@
  	affine-bench            \
  	$(NULL)
  
-@@ -957,10 +890,6 @@
+@@ -956,22 +864,6 @@
  	@rm -f affine-bench$(EXEEXT)
  	$(AM_V_CCLD)$(LINK) $(affine_bench_OBJECTS) $(affine_bench_LDADD) $(LIBS)
  
@@ -249,13 +268,14 @@
 -	@rm -f affine-test$(EXEEXT)
 -	$(AM_V_CCLD)$(LINK) $(affine_test_OBJECTS) $(affine_test_LDADD) $(LIBS)
 -
- alpha-loop$(EXEEXT): $(alpha_loop_OBJECTS) $(alpha_loop_DEPENDENCIES) $(EXTRA_alpha_loop_DEPENDENCIES) 
- 	@rm -f alpha-loop$(EXEEXT)
- 	$(AM_V_CCLD)$(LINK) $(alpha_loop_OBJECTS) $(alpha_loop_LDADD) $(LIBS)
-@@ -969,10 +898,6 @@
- 	@rm -f alphamap$(EXEEXT)
- 	$(AM_V_CCLD)$(LINK) $(alphamap_OBJECTS) $(alphamap_LDADD) $(LIBS)
- 
+-alpha-loop$(EXEEXT): $(alpha_loop_OBJECTS) $(alpha_loop_DEPENDENCIES) $(EXTRA_alpha_loop_DEPENDENCIES) 
+-	@rm -f alpha-loop$(EXEEXT)
+-	$(AM_V_CCLD)$(LINK) $(alpha_loop_OBJECTS) $(alpha_loop_LDADD) $(LIBS)
+-
+-alphamap$(EXEEXT): $(alphamap_OBJECTS) $(alphamap_DEPENDENCIES) $(EXTRA_alphamap_DEPENDENCIES) 
+-	@rm -f alphamap$(EXEEXT)
+-	$(AM_V_CCLD)$(LINK) $(alphamap_OBJECTS) $(alphamap_LDADD) $(LIBS)
+-
 -blitters-test$(EXEEXT): $(blitters_test_OBJECTS) $(blitters_test_DEPENDENCIES) $(EXTRA_blitters_test_DEPENDENCIES) 
 -	@rm -f blitters-test$(EXEEXT)
 -	$(AM_V_CCLD)$(LINK) $(blitters_test_OBJECTS) $(blitters_test_LDADD) $(LIBS)
@@ -263,7 +283,18 @@
  check-formats$(EXEEXT): $(check_formats_OBJECTS) $(check_formats_DEPENDENCIES) $(EXTRA_check_formats_DEPENDENCIES) 
  	@rm -f check-formats$(EXEEXT)
  	$(AM_V_CCLD)$(LINK) $(check_formats_OBJECTS) $(check_formats_LDADD) $(LIBS)
-@@ -1021,10 +946,6 @@
+@@ -980,10 +872,6 @@
+ 	@rm -f combiner-test$(EXEEXT)
+ 	$(AM_V_CCLD)$(LINK) $(combiner_test_OBJECTS) $(combiner_test_LDADD) $(LIBS)
+ 
+-composite$(EXEEXT): $(composite_OBJECTS) $(composite_DEPENDENCIES) $(EXTRA_composite_DEPENDENCIES) 
+-	@rm -f composite$(EXEEXT)
+-	$(AM_V_CCLD)$(LINK) $(composite_OBJECTS) $(composite_LDADD) $(LIBS)
+-
+ composite-traps-test$(EXEEXT): $(composite_traps_test_OBJECTS) $(composite_traps_test_DEPENDENCIES) $(EXTRA_composite_traps_test_DEPENDENCIES) 
+ 	@rm -f composite-traps-test$(EXEEXT)
+ 	$(AM_V_CCLD)$(LINK) $(composite_traps_test_OBJECTS) $(composite_traps_test_LDADD) $(LIBS)
+@@ -1020,10 +908,6 @@
  	@rm -f lowlevel-blt-bench$(EXEEXT)
  	$(AM_V_CCLD)$(LINK) $(lowlevel_blt_bench_OBJECTS) $(lowlevel_blt_bench_LDADD) $(LIBS)
  
@@ -274,7 +305,7 @@
  oob-test$(EXEEXT): $(oob_test_OBJECTS) $(oob_test_DEPENDENCIES) $(EXTRA_oob_test_DEPENDENCIES) 
  	@rm -f oob-test$(EXEEXT)
  	$(AM_V_CCLD)$(LINK) $(oob_test_OBJECTS) $(oob_test_LDADD) $(LIBS)
-@@ -1049,34 +970,14 @@
+@@ -1048,34 +932,14 @@
  	@rm -f radial-perf-test$(EXEEXT)
  	$(AM_V_CCLD)$(LINK) $(radial_perf_test_OBJECTS) $(radial_perf_test_LDADD) $(LIBS)
  
@@ -309,7 +340,7 @@
  scaling-test$(EXEEXT): $(scaling_test_OBJECTS) $(scaling_test_DEPENDENCIES) $(EXTRA_scaling_test_DEPENDENCIES) 
  	@rm -f scaling-test$(EXEEXT)
  	$(AM_V_CCLD)$(LINK) $(scaling_test_OBJECTS) $(scaling_test_LDADD) $(LIBS)
-@@ -1093,10 +994,6 @@
+@@ -1092,10 +956,6 @@
  	@rm -f thread-test$(EXEEXT)
  	$(AM_V_CCLD)$(LINK) $(thread_test_OBJECTS) $(thread_test_LDADD) $(LIBS)
  
@@ -320,18 +351,22 @@
  trap-crasher$(EXEEXT): $(trap_crasher_OBJECTS) $(trap_crasher_DEPENDENCIES) $(EXTRA_trap_crasher_DEPENDENCIES) 
  	@rm -f trap-crasher$(EXEEXT)
  	$(AM_V_CCLD)$(LINK) $(trap_crasher_OBJECTS) $(trap_crasher_LDADD) $(LIBS)
-@@ -1109,10 +1006,8 @@
+@@ -1108,14 +968,9 @@
  
  @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/a1-trap-test.Po@am__quote@ # am--include-marker
  @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/affine-bench.Po@am__quote@ # am--include-marker
 -@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/affine-test.Po@am__quote@ # am--include-marker
- @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/alpha-loop.Po@am__quote@ # am--include-marker
- @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/alphamap.Po@am__quote@ # am--include-marker
+-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/alpha-loop.Po@am__quote@ # am--include-marker
+-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/alphamap.Po@am__quote@ # am--include-marker
 -@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/blitters-test.Po@am__quote@ # am--include-marker
  @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/check-formats.Po@am__quote@ # am--include-marker
  @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/combiner-test.Po@am__quote@ # am--include-marker
  @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/composite-traps-test.Po@am__quote@ # am--include-marker
-@@ -1125,25 +1020,18 @@
+-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/composite.Po@am__quote@ # am--include-marker
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cover-test.Po@am__quote@ # am--include-marker
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fence-image-self-test.Po@am__quote@ # am--include-marker
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fetch-test.Po@am__quote@ # am--include-marker
+@@ -1124,25 +979,18 @@
  @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gradient-crash-test.Po@am__quote@ # am--include-marker
  @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/infinite-loop.Po@am__quote@ # am--include-marker
  @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/lowlevel-blt-bench.Po@am__quote@ # am--include-marker
@@ -357,7 +392,7 @@
  @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/trap-crasher.Po@am__quote@ # am--include-marker
  @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/utils-prng.Plo@am__quote@ # am--include-marker
  @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/utils.Plo@am__quote@ # am--include-marker
-@@ -1444,13 +1332,6 @@
+@@ -1443,13 +1291,6 @@
  	--log-file $$b.log --trs-file $$b.trs \
  	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
  	"$$tst" $(AM_TESTS_FD_REDIRECT)
@@ -371,10 +406,17 @@
  combiner-test.log: combiner-test$(EXEEXT)
  	@p='combiner-test$(EXEEXT)'; \
  	b='combiner-test'; \
-@@ -1472,13 +1353,6 @@
+@@ -1464,20 +1305,6 @@
  	--log-file $$b.log --trs-file $$b.trs \
  	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
  	"$$tst" $(AM_TESTS_FD_REDIRECT)
+-alpha-loop.log: alpha-loop$(EXEEXT)
+-	@p='alpha-loop$(EXEEXT)'; \
+-	b='alpha-loop'; \
+-	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+-	--log-file $$b.log --trs-file $$b.trs \
+-	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+-	"$$tst" $(AM_TESTS_FD_REDIRECT)
 -scaling-helpers-test.log: scaling-helpers-test$(EXEEXT)
 -	@p='scaling-helpers-test$(EXEEXT)'; \
 -	b='scaling-helpers-test'; \
@@ -385,7 +427,7 @@
  thread-test.log: thread-test$(EXEEXT)
  	@p='thread-test$(EXEEXT)'; \
  	b='thread-test'; \
-@@ -1486,13 +1360,6 @@
+@@ -1485,20 +1312,6 @@
  	--log-file $$b.log --trs-file $$b.trs \
  	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
  	"$$tst" $(AM_TESTS_FD_REDIRECT)
@@ -396,10 +438,17 @@
 -	--log-file $$b.log --trs-file $$b.trs \
 -	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
 -	"$$tst" $(AM_TESTS_FD_REDIRECT)
- alphamap.log: alphamap$(EXEEXT)
- 	@p='alphamap$(EXEEXT)'; \
- 	b='alphamap'; \
-@@ -1514,13 +1381,6 @@
+-alphamap.log: alphamap$(EXEEXT)
+-	@p='alphamap$(EXEEXT)'; \
+-	b='alphamap'; \
+-	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+-	--log-file $$b.log --trs-file $$b.trs \
+-	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+-	"$$tst" $(AM_TESTS_FD_REDIRECT)
+ gradient-crash-test.log: gradient-crash-test$(EXEEXT)
+ 	@p='gradient-crash-test$(EXEEXT)'; \
+ 	b='gradient-crash-test'; \
+@@ -1513,13 +1326,6 @@
  	--log-file $$b.log --trs-file $$b.trs \
  	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
  	"$$tst" $(AM_TESTS_FD_REDIRECT)
@@ -413,7 +462,7 @@
  filter-reduction-test.log: filter-reduction-test$(EXEEXT)
  	@p='filter-reduction-test$(EXEEXT)'; \
  	b='filter-reduction-test'; \
-@@ -1535,13 +1395,6 @@
+@@ -1534,13 +1340,6 @@
  	--log-file $$b.log --trs-file $$b.trs \
  	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
  	"$$tst" $(AM_TESTS_FD_REDIRECT)
@@ -427,7 +476,7 @@
  glyph-test.log: glyph-test$(EXEEXT)
  	@p='glyph-test$(EXEEXT)'; \
  	b='glyph-test'; \
-@@ -1570,20 +1423,6 @@
+@@ -1569,20 +1368,6 @@
  	--log-file $$b.log --trs-file $$b.trs \
  	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
  	"$$tst" $(AM_TESTS_FD_REDIRECT)
@@ -448,10 +497,17 @@
  scaling-test.log: scaling-test$(EXEEXT)
  	@p='scaling-test$(EXEEXT)'; \
  	b='scaling-test'; \
-@@ -1598,13 +1437,6 @@
+@@ -1590,20 +1375,6 @@
  	--log-file $$b.log --trs-file $$b.trs \
  	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
  	"$$tst" $(AM_TESTS_FD_REDIRECT)
+-composite.log: composite$(EXEEXT)
+-	@p='composite$(EXEEXT)'; \
+-	b='composite'; \
+-	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+-	--log-file $$b.log --trs-file $$b.trs \
+-	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+-	"$$tst" $(AM_TESTS_FD_REDIRECT)
 -tolerance-test.log: tolerance-test$(EXEEXT)
 -	@p='tolerance-test$(EXEEXT)'; \
 -	b='tolerance-test'; \
@@ -462,18 +518,22 @@
  .test.log:
  	@p='$<'; \
  	$(am__set_b); \
-@@ -1699,10 +1531,8 @@
+@@ -1698,14 +1469,9 @@
  distclean: distclean-am
  		-rm -f ./$(DEPDIR)/a1-trap-test.Po
  	-rm -f ./$(DEPDIR)/affine-bench.Po
 -	-rm -f ./$(DEPDIR)/affine-test.Po
- 	-rm -f ./$(DEPDIR)/alpha-loop.Po
- 	-rm -f ./$(DEPDIR)/alphamap.Po
+-	-rm -f ./$(DEPDIR)/alpha-loop.Po
+-	-rm -f ./$(DEPDIR)/alphamap.Po
 -	-rm -f ./$(DEPDIR)/blitters-test.Po
  	-rm -f ./$(DEPDIR)/check-formats.Po
  	-rm -f ./$(DEPDIR)/combiner-test.Po
  	-rm -f ./$(DEPDIR)/composite-traps-test.Po
-@@ -1715,25 +1545,18 @@
+-	-rm -f ./$(DEPDIR)/composite.Po
+ 	-rm -f ./$(DEPDIR)/cover-test.Po
+ 	-rm -f ./$(DEPDIR)/fence-image-self-test.Po
+ 	-rm -f ./$(DEPDIR)/fetch-test.Po
+@@ -1714,25 +1480,18 @@
  	-rm -f ./$(DEPDIR)/gradient-crash-test.Po
  	-rm -f ./$(DEPDIR)/infinite-loop.Po
  	-rm -f ./$(DEPDIR)/lowlevel-blt-bench.Po
@@ -499,18 +559,22 @@
  	-rm -f ./$(DEPDIR)/trap-crasher.Po
  	-rm -f ./$(DEPDIR)/utils-prng.Plo
  	-rm -f ./$(DEPDIR)/utils.Plo
-@@ -1784,10 +1607,8 @@
+@@ -1783,14 +1542,9 @@
  maintainer-clean: maintainer-clean-am
  		-rm -f ./$(DEPDIR)/a1-trap-test.Po
  	-rm -f ./$(DEPDIR)/affine-bench.Po
 -	-rm -f ./$(DEPDIR)/affine-test.Po
- 	-rm -f ./$(DEPDIR)/alpha-loop.Po
- 	-rm -f ./$(DEPDIR)/alphamap.Po
+-	-rm -f ./$(DEPDIR)/alpha-loop.Po
+-	-rm -f ./$(DEPDIR)/alphamap.Po
 -	-rm -f ./$(DEPDIR)/blitters-test.Po
  	-rm -f ./$(DEPDIR)/check-formats.Po
  	-rm -f ./$(DEPDIR)/combiner-test.Po
  	-rm -f ./$(DEPDIR)/composite-traps-test.Po
-@@ -1800,25 +1621,18 @@
+-	-rm -f ./$(DEPDIR)/composite.Po
+ 	-rm -f ./$(DEPDIR)/cover-test.Po
+ 	-rm -f ./$(DEPDIR)/fence-image-self-test.Po
+ 	-rm -f ./$(DEPDIR)/fetch-test.Po
+@@ -1799,25 +1553,18 @@
  	-rm -f ./$(DEPDIR)/gradient-crash-test.Po
  	-rm -f ./$(DEPDIR)/infinite-loop.Po
  	-rm -f ./$(DEPDIR)/lowlevel-blt-bench.Po