[PATCH 00/17] fs, btrfs refcount conversions

[PATCH 00/17] fs, btrfs refcount conversions

[Elena Reshetova]

Now when new refcount_t type and API are finally merged
(see include/linux/refcount.h), the following
patches convert various refcounters in the btrfs filesystem from atomic_t
to refcount_t. By doing this we prevent intentional or accidental
underflows or overflows that can led to use-after-free vulnerabilities.

The below patches are fully independent and can be cherry-picked separately.
Since we convert all kernel subsystems in the same fashion, resulting
in about 300 patches, we have to group them for sending at least in some
fashion to be manageable. Please excuse the long cc list.

These patches have been tested with xfstests by running btrfs-related tests.
btrfs debug was enabled, warns on refcount errors, too. No output related to
refcount errors produced. However, the following errors were during the run:
 * tests btrfs/078, btrfs/114, btrfs/115, no errors anywhere in dmesg, but
 process hangs. They all seem to be around qgroup, sometimes error visible
 such as qgroup scan failed -4 before it blocks, but not always.
 * test btrfs/104 dmesg has additional error output:
 BTRFS warning (device vdc): qgroup 258 reserved space underflow, have: 0,
 to free: 4096
 I tried looking at the code on what causes the failure, but could not figure
 it out. It doesn't seem to be related to any refcount changes at least IMO.

The above test failures are hard for me to understand and interpreted, but
they don't seem to relate to refcount conversions.

Elena Reshetova (17):
  fs, btrfs: convert btrfs_bio.refs from atomic_t to refcount_t
  fs, btrfs: convert btrfs_transaction.use_count from atomic_t to
    refcount_t
  fs, btrfs: convert extent_map.refs from atomic_t to refcount_t
  fs, btrfs: convert btrfs_ordered_extent.refs from atomic_t to
    refcount_t
  fs, btrfs: convert btrfs_caching_control.count from atomic_t to
    refcount_t
  fs, btrfs: convert btrfs_delayed_ref_node.refs from atomic_t to
    refcount_t
  fs, btrfs: convert btrfs_delayed_node.refs from atomic_t to refcount_t
  fs, btrfs: convert btrfs_delayed_item.refs from atomic_t to refcount_t
  fs, btrfs: convert btrfs_root.refs from atomic_t to refcount_t
  fs, btrfs: convert extent_state.refs from atomic_t to refcount_t
  fs, btrfs: convert compressed_bio.pending_bios from atomic_t to
    refcount_t
  fs, btrfs: convert scrub_recover.refs from atomic_t to refcount_t
  fs, btrfs: convert scrub_page.refs from atomic_t to refcount_t
  fs, btrfs: convert scrub_block.refs from atomic_t to refcount_t
  fs, btrfs: convert scrub_parity.refs from atomic_t to refcount_t
  fs, btrfs: convert scrub_ctx.refs from atomic_t to refcount_t
  fs, btrfs: convert btrfs_raid_bio.refs from atomic_t to refcount_t

 fs/btrfs/backref.c           |  2 +-
 fs/btrfs/compression.c       | 18 ++++++++---------
 fs/btrfs/ctree.h             |  5 +++--
 fs/btrfs/delayed-inode.c     | 46 ++++++++++++++++++++++----------------------
 fs/btrfs/delayed-inode.h     |  5 +++--
 fs/btrfs/delayed-ref.c       |  8 ++++----
 fs/btrfs/delayed-ref.h       |  8 +++++---
 fs/btrfs/disk-io.c           |  6 +++---
 fs/btrfs/disk-io.h           |  4 ++--
 fs/btrfs/extent-tree.c       | 20 +++++++++----------
 fs/btrfs/extent_io.c         | 18 ++++++++---------
 fs/btrfs/extent_io.h         |  3 ++-
 fs/btrfs/extent_map.c        | 10 +++++-----
 fs/btrfs/extent_map.h        |  3 ++-
 fs/btrfs/ordered-data.c      | 20 +++++++++----------
 fs/btrfs/ordered-data.h      |  2 +-
 fs/btrfs/raid56.c            | 19 +++++++++---------
 fs/btrfs/scrub.c             | 42 ++++++++++++++++++++--------------------
 fs/btrfs/transaction.c       | 20 +++++++++----------
 fs/btrfs/transaction.h       |  3 ++-
 fs/btrfs/tree-log.c          |  2 +-
 fs/btrfs/volumes.c           | 10 +++++-----
 fs/btrfs/volumes.h           |  2 +-
 include/trace/events/btrfs.h |  4 ++--
 24 files changed, 143 insertions(+), 137 deletions(-)

-- 
2.7.4

[PATCH 01/17] fs, btrfs: convert btrfs_bio.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/volumes.c | 8 ++++----
 fs/btrfs/volumes.h | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index b124462..a8fd2e9 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -5295,22 +5295,22 @@ static struct btrfs_bio *alloc_btrfs_bio(int total_stripes, int real_stripes)
 		GFP_NOFS|__GFP_NOFAIL);
 
 	atomic_set(&bbio->error, 0);
-	atomic_set(&bbio->refs, 1);
+	refcount_set(&bbio->refs, 1);
 
 	return bbio;
 }
 
 void btrfs_get_bbio(struct btrfs_bio *bbio)
 {
-	WARN_ON(!atomic_read(&bbio->refs));
-	atomic_inc(&bbio->refs);
+	WARN_ON(!refcount_read(&bbio->refs));
+	refcount_inc(&bbio->refs);
 }
 
 void btrfs_put_bbio(struct btrfs_bio *bbio)
 {
 	if (!bbio)
 		return;
-	if (atomic_dec_and_test(&bbio->refs))
+	if (refcount_dec_and_test(&bbio->refs))
 		kfree(bbio);
 }
 
diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index 59be812..ac0bf7d 100644
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -298,7 +298,7 @@ struct btrfs_bio;
 typedef void (btrfs_bio_end_io_t) (struct btrfs_bio *bio, int err);
 
 struct btrfs_bio {
-	atomic_t refs;
+	refcount_t refs;
 	atomic_t stripes_pending;
 	struct btrfs_fs_info *fs_info;
 	u64 map_type; /* get from map_lookup->type */
-- 
2.7.4

[PATCH 02/17] fs, btrfs: convert btrfs_transaction.use_count from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/disk-io.c      |  2 +-
 fs/btrfs/extent-tree.c  |  2 +-
 fs/btrfs/ordered-data.c |  2 +-
 fs/btrfs/transaction.c  | 20 ++++++++++----------
 fs/btrfs/transaction.h  |  3 ++-
 5 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 5f1b08c..dca6432 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -4615,7 +4615,7 @@ static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info)
 		t = list_first_entry(&fs_info->trans_list,
 				     struct btrfs_transaction, list);
 		if (t->state >= TRANS_STATE_COMMIT_START) {
-			atomic_inc(&t->use_count);
+			refcount_inc(&t->use_count);
 			spin_unlock(&fs_info->trans_lock);
 			btrfs_wait_for_commit(fs_info, t->transid);
 			btrfs_put_transaction(t);
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 6079465..63ba295 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -10849,7 +10849,7 @@ static int btrfs_trim_free_extents(struct btrfs_device *device,
 		spin_lock(&fs_info->trans_lock);
 		trans = fs_info->running_transaction;
 		if (trans)
-			atomic_inc(&trans->use_count);
+			refcount_inc(&trans->use_count);
 		spin_unlock(&fs_info->trans_lock);
 
 		ret = find_free_dev_extent_start(trans, device, minlen, start,
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 9a46878..da5399f 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -623,7 +623,7 @@ void btrfs_remove_ordered_extent(struct inode *inode,
 		spin_lock(&fs_info->trans_lock);
 		trans = fs_info->running_transaction;
 		if (trans)
-			atomic_inc(&trans->use_count);
+			refcount_inc(&trans->use_count);
 		spin_unlock(&fs_info->trans_lock);
 
 		ASSERT(trans);
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 61b807d..a7d7a7d 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -60,8 +60,8 @@ static const unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = {
 
 void btrfs_put_transaction(struct btrfs_transaction *transaction)
 {
-	WARN_ON(atomic_read(&transaction->use_count) == 0);
-	if (atomic_dec_and_test(&transaction->use_count)) {
+	WARN_ON(refcount_read(&transaction->use_count) == 0);
+	if (refcount_dec_and_test(&transaction->use_count)) {
 		BUG_ON(!list_empty(&transaction->list));
 		WARN_ON(!RB_EMPTY_ROOT(&transaction->delayed_refs.href_root));
 		if (transaction->delayed_refs.pending_csums)
@@ -207,7 +207,7 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,
 			spin_unlock(&fs_info->trans_lock);
 			return -EBUSY;
 		}
-		atomic_inc(&cur_trans->use_count);
+		refcount_inc(&cur_trans->use_count);
 		atomic_inc(&cur_trans->num_writers);
 		extwriter_counter_inc(cur_trans, type);
 		spin_unlock(&fs_info->trans_lock);
@@ -257,7 +257,7 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,
 	 * One for this trans handle, one so it will live on until we
 	 * commit the transaction.
 	 */
-	atomic_set(&cur_trans->use_count, 2);
+	refcount_set(&cur_trans->use_count, 2);
 	atomic_set(&cur_trans->pending_ordered, 0);
 	cur_trans->flags = 0;
 	cur_trans->start_time = get_seconds();
@@ -432,7 +432,7 @@ static void wait_current_trans(struct btrfs_fs_info *fs_info)
 	spin_lock(&fs_info->trans_lock);
 	cur_trans = fs_info->running_transaction;
 	if (cur_trans && is_transaction_blocked(cur_trans)) {
-		atomic_inc(&cur_trans->use_count);
+		refcount_inc(&cur_trans->use_count);
 		spin_unlock(&fs_info->trans_lock);
 
 		wait_event(fs_info->transaction_wait,
@@ -744,7 +744,7 @@ int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid)
 		list_for_each_entry(t, &fs_info->trans_list, list) {
 			if (t->transid == transid) {
 				cur_trans = t;
-				atomic_inc(&cur_trans->use_count);
+				refcount_inc(&cur_trans->use_count);
 				ret = 0;
 				break;
 			}
@@ -773,7 +773,7 @@ int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid)
 				if (t->state == TRANS_STATE_COMPLETED)
 					break;
 				cur_trans = t;
-				atomic_inc(&cur_trans->use_count);
+				refcount_inc(&cur_trans->use_count);
 				break;
 			}
 		}
@@ -1839,7 +1839,7 @@ int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
 
 	/* take transaction reference */
 	cur_trans = trans->transaction;
-	atomic_inc(&cur_trans->use_count);
+	refcount_inc(&cur_trans->use_count);
 
 	btrfs_end_transaction(trans);
 
@@ -2015,7 +2015,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)
 	spin_lock(&fs_info->trans_lock);
 	if (cur_trans->state >= TRANS_STATE_COMMIT_START) {
 		spin_unlock(&fs_info->trans_lock);
-		atomic_inc(&cur_trans->use_count);
+		refcount_inc(&cur_trans->use_count);
 		ret = btrfs_end_transaction(trans);
 
 		wait_for_commit(cur_trans);
@@ -2035,7 +2035,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)
 		prev_trans = list_entry(cur_trans->list.prev,
 					struct btrfs_transaction, list);
 		if (prev_trans->state != TRANS_STATE_COMPLETED) {
-			atomic_inc(&prev_trans->use_count);
+			refcount_inc(&prev_trans->use_count);
 			spin_unlock(&fs_info->trans_lock);
 
 			wait_for_commit(prev_trans);
diff --git a/fs/btrfs/transaction.h b/fs/btrfs/transaction.h
index 5dfb559..2d9ad36 100644
--- a/fs/btrfs/transaction.h
+++ b/fs/btrfs/transaction.h
@@ -18,6 +18,7 @@
 
 #ifndef __BTRFS_TRANSACTION__
 #define __BTRFS_TRANSACTION__
+#include <linux/refcount.h>
 #include "btrfs_inode.h"
 #include "delayed-ref.h"
 #include "ctree.h"
@@ -49,7 +50,7 @@ struct btrfs_transaction {
 	 * transaction can end
 	 */
 	atomic_t num_writers;
-	atomic_t use_count;
+	refcount_t use_count;
 	atomic_t pending_ordered;
 
 	unsigned long flags;
-- 
2.7.4

[PATCH 03/17] fs, btrfs: convert extent_map.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/extent_io.c         |  4 ++--
 fs/btrfs/extent_map.c        | 10 +++++-----
 fs/btrfs/extent_map.h        |  3 ++-
 fs/btrfs/tree-log.c          |  2 +-
 fs/btrfs/volumes.c           |  2 +-
 include/trace/events/btrfs.h |  2 +-
 6 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index c3abf84..3cf0b02 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -2852,7 +2852,7 @@ __get_extent_map(struct inode *inode, struct page *page, size_t pg_offset,
 		em = *em_cached;
 		if (extent_map_in_tree(em) && start >= em->start &&
 		    start < extent_map_end(em)) {
-			atomic_inc(&em->refs);
+			refcount_inc(&em->refs);
 			return em;
 		}
 
@@ -2863,7 +2863,7 @@ __get_extent_map(struct inode *inode, struct page *page, size_t pg_offset,
 	em = get_extent(BTRFS_I(inode), page, pg_offset, start, len, 0);
 	if (em_cached && !IS_ERR_OR_NULL(em)) {
 		BUG_ON(*em_cached);
-		atomic_inc(&em->refs);
+		refcount_inc(&em->refs);
 		*em_cached = em;
 	}
 	return em;
diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c
index 26f9ac7..6985015 100644
--- a/fs/btrfs/extent_map.c
+++ b/fs/btrfs/extent_map.c
@@ -55,7 +55,7 @@ struct extent_map *alloc_extent_map(void)
 	em->flags = 0;
 	em->compress_type = BTRFS_COMPRESS_NONE;
 	em->generation = 0;
-	atomic_set(&em->refs, 1);
+	refcount_set(&em->refs, 1);
 	INIT_LIST_HEAD(&em->list);
 	return em;
 }
@@ -71,8 +71,8 @@ void free_extent_map(struct extent_map *em)
 {
 	if (!em)
 		return;
-	WARN_ON(atomic_read(&em->refs) == 0);
-	if (atomic_dec_and_test(&em->refs)) {
+	WARN_ON(refcount_read(&em->refs) == 0);
+	if (refcount_dec_and_test(&em->refs)) {
 		WARN_ON(extent_map_in_tree(em));
 		WARN_ON(!list_empty(&em->list));
 		if (test_bit(EXTENT_FLAG_FS_MAPPING, &em->flags))
@@ -322,7 +322,7 @@ static inline void setup_extent_mapping(struct extent_map_tree *tree,
 					struct extent_map *em,
 					int modified)
 {
-	atomic_inc(&em->refs);
+	refcount_inc(&em->refs);
 	em->mod_start = em->start;
 	em->mod_len = em->len;
 
@@ -381,7 +381,7 @@ __lookup_extent_mapping(struct extent_map_tree *tree,
 	if (strict && !(end > em->start && start < extent_map_end(em)))
 		return NULL;
 
-	atomic_inc(&em->refs);
+	refcount_inc(&em->refs);
 	return em;
 }
 
diff --git a/fs/btrfs/extent_map.h b/fs/btrfs/extent_map.h
index eb8b8fa..a67b2de 100644
--- a/fs/btrfs/extent_map.h
+++ b/fs/btrfs/extent_map.h
@@ -2,6 +2,7 @@
 #define __EXTENTMAP__
 
 #include <linux/rbtree.h>
+#include <linux/refcount.h>
 
 #define EXTENT_MAP_LAST_BYTE ((u64)-4)
 #define EXTENT_MAP_HOLE ((u64)-3)
@@ -41,7 +42,7 @@ struct extent_map {
 		 */
 		struct map_lookup *map_lookup;
 	};
-	atomic_t refs;
+	refcount_t refs;
 	unsigned int compress_type;
 	struct list_head list;
 };
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index a59674c..ccfe9fe 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -4196,7 +4196,7 @@ static int btrfs_log_changed_extents(struct btrfs_trans_handle *trans,
 		if (em->generation <= test_gen)
 			continue;
 		/* Need a ref to keep it from getting evicted from cache */
-		atomic_inc(&em->refs);
+		refcount_inc(&em->refs);
 		set_bit(EXTENT_FLAG_LOGGING, &em->flags);
 		list_add_tail(&em->list, &extents);
 		num++;
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index a8fd2e9..c23a383 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -4833,7 +4833,7 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
 	ret = add_extent_mapping(em_tree, em, 0);
 	if (!ret) {
 		list_add_tail(&em->list, &trans->transaction->pending_chunks);
-		atomic_inc(&em->refs);
+		refcount_inc(&em->refs);
 	}
 	write_unlock(&em_tree->lock);
 	if (ret) {
diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index a3c3cab..9dd29e8 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -213,7 +213,7 @@ TRACE_EVENT_CONDITION(btrfs_get_extent,
 		__entry->block_start	= map->block_start;
 		__entry->block_len	= map->block_len;
 		__entry->flags		= map->flags;
-		__entry->refs		= atomic_read(&map->refs);
+		__entry->refs		= refcount_read(&map->refs);
 		__entry->compress_type	= map->compress_type;
 	),
 
-- 
2.7.4

[PATCH 04/17] fs, btrfs: convert btrfs_ordered_extent.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/ordered-data.c      | 18 +++++++++---------
 fs/btrfs/ordered-data.h      |  2 +-
 include/trace/events/btrfs.h |  2 +-
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index da5399f..7b40e2e 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -212,7 +212,7 @@ static int __btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
 		set_bit(BTRFS_ORDERED_DIRECT, &entry->flags);
 
 	/* one ref for the tree */
-	atomic_set(&entry->refs, 1);
+	refcount_set(&entry->refs, 1);
 	init_waitqueue_head(&entry->wait);
 	INIT_LIST_HEAD(&entry->list);
 	INIT_LIST_HEAD(&entry->root_extent_list);
@@ -358,7 +358,7 @@ int btrfs_dec_test_first_ordered_pending(struct inode *inode,
 out:
 	if (!ret && cached && entry) {
 		*cached = entry;
-		atomic_inc(&entry->refs);
+		refcount_inc(&entry->refs);
 	}
 	spin_unlock_irqrestore(&tree->lock, flags);
 	return ret == 0;
@@ -425,7 +425,7 @@ int btrfs_dec_test_ordered_pending(struct inode *inode,
 out:
 	if (!ret && cached && entry) {
 		*cached = entry;
-		atomic_inc(&entry->refs);
+		refcount_inc(&entry->refs);
 	}
 	spin_unlock_irqrestore(&tree->lock, flags);
 	return ret == 0;
@@ -456,7 +456,7 @@ void btrfs_get_logged_extents(struct btrfs_inode *inode,
 		if (test_and_set_bit(BTRFS_ORDERED_LOGGED, &ordered->flags))
 			continue;
 		list_add(&ordered->log_list, logged_list);
-		atomic_inc(&ordered->refs);
+		refcount_inc(&ordered->refs);
 	}
 	spin_unlock_irq(&tree->lock);
 }
@@ -565,7 +565,7 @@ void btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
 
 	trace_btrfs_ordered_extent_put(entry->inode, entry);
 
-	if (atomic_dec_and_test(&entry->refs)) {
+	if (refcount_dec_and_test(&entry->refs)) {
 		ASSERT(list_empty(&entry->log_list));
 		ASSERT(list_empty(&entry->trans_list));
 		ASSERT(list_empty(&entry->root_extent_list));
@@ -690,7 +690,7 @@ int btrfs_wait_ordered_extents(struct btrfs_root *root, int nr,
 
 		list_move_tail(&ordered->root_extent_list,
 			       &root->ordered_extents);
-		atomic_inc(&ordered->refs);
+		refcount_inc(&ordered->refs);
 		spin_unlock(&root->ordered_extent_lock);
 
 		btrfs_init_work(&ordered->flush_work,
@@ -870,7 +870,7 @@ struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct inode *inode,
 	if (!offset_in_entry(entry, file_offset))
 		entry = NULL;
 	if (entry)
-		atomic_inc(&entry->refs);
+		refcount_inc(&entry->refs);
 out:
 	spin_unlock_irq(&tree->lock);
 	return entry;
@@ -911,7 +911,7 @@ struct btrfs_ordered_extent *btrfs_lookup_ordered_range(
 	}
 out:
 	if (entry)
-		atomic_inc(&entry->refs);
+		refcount_inc(&entry->refs);
 	spin_unlock_irq(&tree->lock);
 	return entry;
 }
@@ -948,7 +948,7 @@ btrfs_lookup_first_ordered_extent(struct inode *inode, u64 file_offset)
 		goto out;
 
 	entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
-	atomic_inc(&entry->refs);
+	refcount_inc(&entry->refs);
 out:
 	spin_unlock_irq(&tree->lock);
 	return entry;
diff --git a/fs/btrfs/ordered-data.h b/fs/btrfs/ordered-data.h
index 195c93b..e0c1d5b 100644
--- a/fs/btrfs/ordered-data.h
+++ b/fs/btrfs/ordered-data.h
@@ -113,7 +113,7 @@ struct btrfs_ordered_extent {
 	int compress_type;
 
 	/* reference count */
-	atomic_t refs;
+	refcount_t refs;
 
 	/* the inode we belong to */
 	struct inode *inode;
diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index 9dd29e8..8f206263 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -275,7 +275,7 @@ DECLARE_EVENT_CLASS(btrfs__ordered_extent,
 		__entry->bytes_left	= ordered->bytes_left;
 		__entry->flags		= ordered->flags;
 		__entry->compress_type	= ordered->compress_type;
-		__entry->refs		= atomic_read(&ordered->refs);
+		__entry->refs		= refcount_read(&ordered->refs);
 		__entry->root_objectid	=
 				BTRFS_I(inode)->root->root_key.objectid;
 		__entry->truncated_len	= ordered->truncated_len;
-- 
2.7.4

[PATCH 05/17] fs, btrfs: convert btrfs_caching_control.count from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/ctree.h       |  3 ++-
 fs/btrfs/extent-tree.c | 12 ++++++------
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 00e3518..557af39 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -38,6 +38,7 @@
 #include <linux/security.h>
 #include <linux/sizes.h>
 #include <linux/dynamic_debug.h>
+#include <linux/refcount.h>
 #include "extent_io.h"
 #include "extent_map.h"
 #include "async-thread.h"
@@ -517,7 +518,7 @@ struct btrfs_caching_control {
 	struct btrfs_work work;
 	struct btrfs_block_group_cache *block_group;
 	u64 progress;
-	atomic_t count;
+	refcount_t count;
 };
 
 /* Once caching_thread() finds this much free space, it will wake up waiters. */
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 63ba295..796001b 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -315,14 +315,14 @@ get_caching_control(struct btrfs_block_group_cache *cache)
 	}
 
 	ctl = cache->caching_ctl;
-	atomic_inc(&ctl->count);
+	refcount_inc(&ctl->count);
 	spin_unlock(&cache->lock);
 	return ctl;
 }
 
 static void put_caching_control(struct btrfs_caching_control *ctl)
 {
-	if (atomic_dec_and_test(&ctl->count))
+	if (refcount_dec_and_test(&ctl->count))
 		kfree(ctl);
 }
 
@@ -598,7 +598,7 @@ static int cache_block_group(struct btrfs_block_group_cache *cache,
 	init_waitqueue_head(&caching_ctl->wait);
 	caching_ctl->block_group = cache;
 	caching_ctl->progress = cache->key.objectid;
-	atomic_set(&caching_ctl->count, 1);
+	refcount_set(&caching_ctl->count, 1);
 	btrfs_init_work(&caching_ctl->work, btrfs_cache_helper,
 			caching_thread, NULL, NULL);
 
@@ -619,7 +619,7 @@ static int cache_block_group(struct btrfs_block_group_cache *cache,
 		struct btrfs_caching_control *ctl;
 
 		ctl = cache->caching_ctl;
-		atomic_inc(&ctl->count);
+		refcount_inc(&ctl->count);
 		prepare_to_wait(&ctl->wait, &wait, TASK_UNINTERRUPTIBLE);
 		spin_unlock(&cache->lock);
 
@@ -706,7 +706,7 @@ static int cache_block_group(struct btrfs_block_group_cache *cache,
 	}
 
 	down_write(&fs_info->commit_root_sem);
-	atomic_inc(&caching_ctl->count);
+	refcount_inc(&caching_ctl->count);
 	list_add_tail(&caching_ctl->list, &fs_info->caching_block_groups);
 	up_write(&fs_info->commit_root_sem);
 
@@ -10415,7 +10415,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
 				    &fs_info->caching_block_groups, list)
 				if (ctl->block_group == block_group) {
 					caching_ctl = ctl;
-					atomic_inc(&caching_ctl->count);
+					refcount_inc(&caching_ctl->count);
 					break;
 				}
 		}
-- 
2.7.4

[PATCH 06/17] fs, btrfs: convert btrfs_delayed_ref_node.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/backref.c     | 2 +-
 fs/btrfs/delayed-ref.c | 8 ++++----
 fs/btrfs/delayed-ref.h | 8 +++++---
 fs/btrfs/disk-io.c     | 2 +-
 fs/btrfs/extent-tree.c | 6 +++---
 5 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index 7699e16..1163383 100644
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -1286,7 +1286,7 @@ static int find_parent_nodes(struct btrfs_trans_handle *trans,
 		head = btrfs_find_delayed_ref_head(delayed_refs, bytenr);
 		if (head) {
 			if (!mutex_trylock(&head->mutex)) {
-				atomic_inc(&head->node.refs);
+				refcount_inc(&head->node.refs);
 				spin_unlock(&delayed_refs->lock);
 
 				btrfs_release_path(path);
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index 6eb8095..be70d90 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -164,7 +164,7 @@ int btrfs_delayed_ref_lock(struct btrfs_trans_handle *trans,
 	if (mutex_trylock(&head->mutex))
 		return 0;
 
-	atomic_inc(&head->node.refs);
+	refcount_inc(&head->node.refs);
 	spin_unlock(&delayed_refs->lock);
 
 	mutex_lock(&head->mutex);
@@ -590,7 +590,7 @@ add_delayed_ref_head(struct btrfs_fs_info *fs_info,
 	delayed_refs = &trans->transaction->delayed_refs;
 
 	/* first set the basic ref node struct up */
-	atomic_set(&ref->refs, 1);
+	refcount_set(&ref->refs, 1);
 	ref->bytenr = bytenr;
 	ref->num_bytes = num_bytes;
 	ref->ref_mod = count_mod;
@@ -682,7 +682,7 @@ add_delayed_tree_ref(struct btrfs_fs_info *fs_info,
 	delayed_refs = &trans->transaction->delayed_refs;
 
 	/* first set the basic ref node struct up */
-	atomic_set(&ref->refs, 1);
+	refcount_set(&ref->refs, 1);
 	ref->bytenr = bytenr;
 	ref->num_bytes = num_bytes;
 	ref->ref_mod = 1;
@@ -739,7 +739,7 @@ add_delayed_data_ref(struct btrfs_fs_info *fs_info,
 		seq = atomic64_read(&fs_info->tree_mod_seq);
 
 	/* first set the basic ref node struct up */
-	atomic_set(&ref->refs, 1);
+	refcount_set(&ref->refs, 1);
 	ref->bytenr = bytenr;
 	ref->num_bytes = num_bytes;
 	ref->ref_mod = 1;
diff --git a/fs/btrfs/delayed-ref.h b/fs/btrfs/delayed-ref.h
index 0e537f9..c0264ff 100644
--- a/fs/btrfs/delayed-ref.h
+++ b/fs/btrfs/delayed-ref.h
@@ -18,6 +18,8 @@
 #ifndef __DELAYED_REF__
 #define __DELAYED_REF__
 
+#include <linux/refcount.h>
+
 /* these are the possible values of struct btrfs_delayed_ref_node->action */
 #define BTRFS_ADD_DELAYED_REF    1 /* add one backref to the tree */
 #define BTRFS_DROP_DELAYED_REF   2 /* delete one backref from the tree */
@@ -53,7 +55,7 @@ struct btrfs_delayed_ref_node {
 	u64 seq;
 
 	/* ref count on this data structure */
-	atomic_t refs;
+	refcount_t refs;
 
 	/*
 	 * how many refs is this entry adding or deleting.  For
@@ -220,8 +222,8 @@ btrfs_free_delayed_extent_op(struct btrfs_delayed_extent_op *op)
 
 static inline void btrfs_put_delayed_ref(struct btrfs_delayed_ref_node *ref)
 {
-	WARN_ON(atomic_read(&ref->refs) == 0);
-	if (atomic_dec_and_test(&ref->refs)) {
+	WARN_ON(refcount_read(&ref->refs) == 0);
+	if (refcount_dec_and_test(&ref->refs)) {
 		WARN_ON(ref->in_tree);
 		switch (ref->type) {
 		case BTRFS_TREE_BLOCK_REF_KEY:
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index dca6432..913df60 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -4343,7 +4343,7 @@ static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
 		head = rb_entry(node, struct btrfs_delayed_ref_head,
 				href_node);
 		if (!mutex_trylock(&head->mutex)) {
-			atomic_inc(&head->node.refs);
+			refcount_inc(&head->node.refs);
 			spin_unlock(&delayed_refs->lock);
 
 			mutex_lock(&head->mutex);
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 796001b..11a1b07 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -891,7 +891,7 @@ int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
 	head = btrfs_find_delayed_ref_head(delayed_refs, bytenr);
 	if (head) {
 		if (!mutex_trylock(&head->mutex)) {
-			atomic_inc(&head->node.refs);
+			refcount_inc(&head->node.refs);
 			spin_unlock(&delayed_refs->lock);
 
 			btrfs_release_path(path);
@@ -2979,7 +2979,7 @@ int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
 				struct btrfs_delayed_ref_node *ref;
 
 				ref = &head->node;
-				atomic_inc(&ref->refs);
+				refcount_inc(&ref->refs);
 
 				spin_unlock(&delayed_refs->lock);
 				/*
@@ -3056,7 +3056,7 @@ static noinline int check_delayed_ref(struct btrfs_root *root,
 	}
 
 	if (!mutex_trylock(&head->mutex)) {
-		atomic_inc(&head->node.refs);
+		refcount_inc(&head->node.refs);
 		spin_unlock(&delayed_refs->lock);
 
 		btrfs_release_path(path);
-- 
2.7.4

[PATCH 07/17] fs, btrfs: convert btrfs_delayed_node.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/delayed-inode.c | 28 ++++++++++++++--------------
 fs/btrfs/delayed-inode.h |  3 ++-
 2 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 1aff676..7396c36 100644
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -52,7 +52,7 @@ static inline void btrfs_init_delayed_node(
 {
 	delayed_node->root = root;
 	delayed_node->inode_id = inode_id;
-	atomic_set(&delayed_node->refs, 0);
+	refcount_set(&delayed_node->refs, 0);
 	delayed_node->ins_root = RB_ROOT;
 	delayed_node->del_root = RB_ROOT;
 	mutex_init(&delayed_node->mutex);
@@ -81,7 +81,7 @@ static struct btrfs_delayed_node *btrfs_get_delayed_node(
 
 	node = READ_ONCE(btrfs_inode->delayed_node);
 	if (node) {
-		atomic_inc(&node->refs);
+		refcount_inc(&node->refs);
 		return node;
 	}
 
@@ -89,14 +89,14 @@ static struct btrfs_delayed_node *btrfs_get_delayed_node(
 	node = radix_tree_lookup(&root->delayed_nodes_tree, ino);
 	if (node) {
 		if (btrfs_inode->delayed_node) {
-			atomic_inc(&node->refs);	/* can be accessed */
+			refcount_inc(&node->refs);	/* can be accessed */
 			BUG_ON(btrfs_inode->delayed_node != node);
 			spin_unlock(&root->inode_lock);
 			return node;
 		}
 		btrfs_inode->delayed_node = node;
 		/* can be accessed and cached in the inode */
-		atomic_add(2, &node->refs);
+		refcount_add(2, &node->refs);
 		spin_unlock(&root->inode_lock);
 		return node;
 	}
@@ -125,7 +125,7 @@ static struct btrfs_delayed_node *btrfs_get_or_create_delayed_node(
 	btrfs_init_delayed_node(node, root, ino);
 
 	/* cached in the btrfs inode and can be accessed */
-	atomic_add(2, &node->refs);
+	refcount_set(&node->refs, 2);
 
 	ret = radix_tree_preload(GFP_NOFS);
 	if (ret) {
@@ -166,7 +166,7 @@ static void btrfs_queue_delayed_node(struct btrfs_delayed_root *root,
 	} else {
 		list_add_tail(&node->n_list, &root->node_list);
 		list_add_tail(&node->p_list, &root->prepare_list);
-		atomic_inc(&node->refs);	/* inserted into list */
+		refcount_inc(&node->refs);	/* inserted into list */
 		root->nodes++;
 		set_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags);
 	}
@@ -180,7 +180,7 @@ static void btrfs_dequeue_delayed_node(struct btrfs_delayed_root *root,
 	spin_lock(&root->lock);
 	if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) {
 		root->nodes--;
-		atomic_dec(&node->refs);	/* not in the list */
+		refcount_dec(&node->refs);	/* not in the list */
 		list_del_init(&node->n_list);
 		if (!list_empty(&node->p_list))
 			list_del_init(&node->p_list);
@@ -201,7 +201,7 @@ static struct btrfs_delayed_node *btrfs_first_delayed_node(
 
 	p = delayed_root->node_list.next;
 	node = list_entry(p, struct btrfs_delayed_node, n_list);
-	atomic_inc(&node->refs);
+	refcount_inc(&node->refs);
 out:
 	spin_unlock(&delayed_root->lock);
 
@@ -228,7 +228,7 @@ static struct btrfs_delayed_node *btrfs_next_delayed_node(
 		p = node->n_list.next;
 
 	next = list_entry(p, struct btrfs_delayed_node, n_list);
-	atomic_inc(&next->refs);
+	refcount_inc(&next->refs);
 out:
 	spin_unlock(&delayed_root->lock);
 
@@ -253,11 +253,11 @@ static void __btrfs_release_delayed_node(
 		btrfs_dequeue_delayed_node(delayed_root, delayed_node);
 	mutex_unlock(&delayed_node->mutex);
 
-	if (atomic_dec_and_test(&delayed_node->refs)) {
+	if (refcount_dec_and_test(&delayed_node->refs)) {
 		bool free = false;
 		struct btrfs_root *root = delayed_node->root;
 		spin_lock(&root->inode_lock);
-		if (atomic_read(&delayed_node->refs) == 0) {
+		if (refcount_read(&delayed_node->refs) == 0) {
 			radix_tree_delete(&root->delayed_nodes_tree,
 					  delayed_node->inode_id);
 			free = true;
@@ -286,7 +286,7 @@ static struct btrfs_delayed_node *btrfs_first_prepared_delayed_node(
 	p = delayed_root->prepare_list.next;
 	list_del_init(p);
 	node = list_entry(p, struct btrfs_delayed_node, p_list);
-	atomic_inc(&node->refs);
+	refcount_inc(&node->refs);
 out:
 	spin_unlock(&delayed_root->lock);
 
@@ -1621,7 +1621,7 @@ bool btrfs_readdir_get_delayed_items(struct inode *inode,
 	 * insert/delete delayed items in this period. So we also needn't
 	 * requeue or dequeue this delayed node.
 	 */
-	atomic_dec(&delayed_node->refs);
+	refcount_dec(&delayed_node->refs);
 
 	return true;
 }
@@ -1963,7 +1963,7 @@ void btrfs_kill_all_delayed_nodes(struct btrfs_root *root)
 		inode_id = delayed_nodes[n - 1]->inode_id + 1;
 
 		for (i = 0; i < n; i++)
-			atomic_inc(&delayed_nodes[i]->refs);
+			refcount_inc(&delayed_nodes[i]->refs);
 		spin_unlock(&root->inode_lock);
 
 		for (i = 0; i < n; i++) {
diff --git a/fs/btrfs/delayed-inode.h b/fs/btrfs/delayed-inode.h
index 40327cc..d234974 100644
--- a/fs/btrfs/delayed-inode.h
+++ b/fs/btrfs/delayed-inode.h
@@ -26,6 +26,7 @@
 #include <linux/list.h>
 #include <linux/wait.h>
 #include <linux/atomic.h>
+#include <linux/refcount.h>
 
 #include "ctree.h"
 
@@ -67,7 +68,7 @@ struct btrfs_delayed_node {
 	struct rb_root del_root;
 	struct mutex mutex;
 	struct btrfs_inode_item inode_item;
-	atomic_t refs;
+	refcount_t refs;
 	u64 index_cnt;
 	unsigned long flags;
 	int count;
-- 
2.7.4

[PATCH 08/17] fs, btrfs: convert btrfs_delayed_item.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/delayed-inode.c | 18 +++++++++---------
 fs/btrfs/delayed-inode.h |  2 +-
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 7396c36..8ae409b 100644
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -308,7 +308,7 @@ static struct btrfs_delayed_item *btrfs_alloc_delayed_item(u32 data_len)
 		item->ins_or_del = 0;
 		item->bytes_reserved = 0;
 		item->delayed_node = NULL;
-		atomic_set(&item->refs, 1);
+		refcount_set(&item->refs, 1);
 	}
 	return item;
 }
@@ -483,7 +483,7 @@ static void btrfs_release_delayed_item(struct btrfs_delayed_item *item)
 {
 	if (item) {
 		__btrfs_remove_delayed_item(item);
-		if (atomic_dec_and_test(&item->refs))
+		if (refcount_dec_and_test(&item->refs))
 			kfree(item);
 	}
 }
@@ -1600,14 +1600,14 @@ bool btrfs_readdir_get_delayed_items(struct inode *inode,
 	mutex_lock(&delayed_node->mutex);
 	item = __btrfs_first_delayed_insertion_item(delayed_node);
 	while (item) {
-		atomic_inc(&item->refs);
+		refcount_inc(&item->refs);
 		list_add_tail(&item->readdir_list, ins_list);
 		item = __btrfs_next_delayed_item(item);
 	}
 
 	item = __btrfs_first_delayed_deletion_item(delayed_node);
 	while (item) {
-		atomic_inc(&item->refs);
+		refcount_inc(&item->refs);
 		list_add_tail(&item->readdir_list, del_list);
 		item = __btrfs_next_delayed_item(item);
 	}
@@ -1634,13 +1634,13 @@ void btrfs_readdir_put_delayed_items(struct inode *inode,
 
 	list_for_each_entry_safe(curr, next, ins_list, readdir_list) {
 		list_del(&curr->readdir_list);
-		if (atomic_dec_and_test(&curr->refs))
+		if (refcount_dec_and_test(&curr->refs))
 			kfree(curr);
 	}
 
 	list_for_each_entry_safe(curr, next, del_list, readdir_list) {
 		list_del(&curr->readdir_list);
-		if (atomic_dec_and_test(&curr->refs))
+		if (refcount_dec_and_test(&curr->refs))
 			kfree(curr);
 	}
 
@@ -1667,7 +1667,7 @@ int btrfs_should_delete_dir_index(struct list_head *del_list,
 		list_del(&curr->readdir_list);
 		ret = (curr->key.offset == index);
 
-		if (atomic_dec_and_test(&curr->refs))
+		if (refcount_dec_and_test(&curr->refs))
 			kfree(curr);
 
 		if (ret)
@@ -1705,7 +1705,7 @@ int btrfs_readdir_delayed_dir_index(struct dir_context *ctx,
 		list_del(&curr->readdir_list);
 
 		if (curr->key.offset < ctx->pos) {
-			if (atomic_dec_and_test(&curr->refs))
+			if (refcount_dec_and_test(&curr->refs))
 				kfree(curr);
 			continue;
 		}
@@ -1722,7 +1722,7 @@ int btrfs_readdir_delayed_dir_index(struct dir_context *ctx,
 		over = !dir_emit(ctx, name, name_len,
 			       location.objectid, d_type);
 
-		if (atomic_dec_and_test(&curr->refs))
+		if (refcount_dec_and_test(&curr->refs))
 			kfree(curr);
 
 		if (over)
diff --git a/fs/btrfs/delayed-inode.h b/fs/btrfs/delayed-inode.h
index d234974..6d4f5a0 100644
--- a/fs/btrfs/delayed-inode.h
+++ b/fs/btrfs/delayed-inode.h
@@ -81,7 +81,7 @@ struct btrfs_delayed_item {
 	struct list_head readdir_list;	/* used for readdir items */
 	u64 bytes_reserved;
 	struct btrfs_delayed_node *delayed_node;
-	atomic_t refs;
+	refcount_t refs;
 	int ins_or_del;
 	u32 data_len;
 	char data[0];
-- 
2.7.4

[PATCH 09/17] fs, btrfs: convert btrfs_root.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/ctree.h   | 2 +-
 fs/btrfs/disk-io.c | 2 +-
 fs/btrfs/disk-io.h | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 557af39..c01bfca 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -1221,7 +1221,7 @@ struct btrfs_root {
 	dev_t anon_dev;
 
 	spinlock_t root_item_lock;
-	atomic_t refs;
+	refcount_t refs;
 
 	struct mutex delalloc_mutex;
 	spinlock_t delalloc_lock;
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 913df60..ca89ae3 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1340,7 +1340,7 @@ static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info,
 	atomic_set(&root->log_writers, 0);
 	atomic_set(&root->log_batch, 0);
 	atomic_set(&root->orphan_inodes, 0);
-	atomic_set(&root->refs, 1);
+	refcount_set(&root->refs, 1);
 	atomic_set(&root->will_be_snapshoted, 0);
 	atomic_set(&root->qgroup_meta_rsv, 0);
 	root->log_transid = 0;
diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h
index 2e0ec29..21f1ceb 100644
--- a/fs/btrfs/disk-io.h
+++ b/fs/btrfs/disk-io.h
@@ -101,14 +101,14 @@ struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info);
  */
 static inline struct btrfs_root *btrfs_grab_fs_root(struct btrfs_root *root)
 {
-	if (atomic_inc_not_zero(&root->refs))
+	if (refcount_inc_not_zero(&root->refs))
 		return root;
 	return NULL;
 }
 
 static inline void btrfs_put_fs_root(struct btrfs_root *root)
 {
-	if (atomic_dec_and_test(&root->refs))
+	if (refcount_dec_and_test(&root->refs))
 		kfree(root);
 }
 
-- 
2.7.4

[PATCH 10/17] fs, btrfs: convert extent_state.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/extent_io.c | 14 +++++++-------
 fs/btrfs/extent_io.h |  3 ++-
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 3cf0b02..0702be6 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -68,7 +68,7 @@ void btrfs_leak_debug_check(void)
 		pr_err("BTRFS: state leak: start %llu end %llu state %u in tree %d refs %d\n",
 		       state->start, state->end, state->state,
 		       extent_state_in_tree(state),
-		       atomic_read(&state->refs));
+		       refcount_read(&state->refs));
 		list_del(&state->leak_list);
 		kmem_cache_free(extent_state_cache, state);
 	}
@@ -238,7 +238,7 @@ static struct extent_state *alloc_extent_state(gfp_t mask)
 	state->failrec = NULL;
 	RB_CLEAR_NODE(&state->rb_node);
 	btrfs_leak_debug_add(&state->leak_list, &states);
-	atomic_set(&state->refs, 1);
+	refcount_set(&state->refs, 1);
 	init_waitqueue_head(&state->wq);
 	trace_alloc_extent_state(state, mask, _RET_IP_);
 	return state;
@@ -248,7 +248,7 @@ void free_extent_state(struct extent_state *state)
 {
 	if (!state)
 		return;
-	if (atomic_dec_and_test(&state->refs)) {
+	if (refcount_dec_and_test(&state->refs)) {
 		WARN_ON(extent_state_in_tree(state));
 		btrfs_leak_debug_del(&state->leak_list);
 		trace_free_extent_state(state, _RET_IP_);
@@ -641,7 +641,7 @@ static int __clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,
 		if (cached && extent_state_in_tree(cached) &&
 		    cached->start <= start && cached->end > start) {
 			if (clear)
-				atomic_dec(&cached->refs);
+				refcount_dec(&cached->refs);
 			state = cached;
 			goto hit_next;
 		}
@@ -793,7 +793,7 @@ static void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,
 
 		if (state->state & bits) {
 			start = state->start;
-			atomic_inc(&state->refs);
+			refcount_inc(&state->refs);
 			wait_on_state(tree, state);
 			free_extent_state(state);
 			goto again;
@@ -834,7 +834,7 @@ static void cache_state_if_flags(struct extent_state *state,
 	if (cached_ptr && !(*cached_ptr)) {
 		if (!flags || (state->state & flags)) {
 			*cached_ptr = state;
-			atomic_inc(&state->refs);
+			refcount_inc(&state->refs);
 		}
 	}
 }
@@ -1538,7 +1538,7 @@ static noinline u64 find_delalloc_range(struct extent_io_tree *tree,
 		if (!found) {
 			*start = state->start;
 			*cached_state = state;
-			atomic_inc(&state->refs);
+			refcount_inc(&state->refs);
 		}
 		found++;
 		*end = state->end;
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index c16260c..9ea9338 100644
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -2,6 +2,7 @@
 #define __EXTENTIO__
 
 #include <linux/rbtree.h>
+#include <linux/refcount.h>
 #include "ulist.h"
 
 /* bits for the extent state */
@@ -134,7 +135,7 @@ struct extent_state {
 
 	/* ADD NEW ELEMENTS AFTER THIS */
 	wait_queue_head_t wq;
-	atomic_t refs;
+	refcount_t refs;
 	unsigned state;
 
 	struct io_failure_record *failrec;
-- 
2.7.4

[PATCH 11/17] fs, btrfs: convert compressed_bio.pending_bios from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/compression.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index c7721a6..10e6b28 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -44,7 +44,7 @@
 
 struct compressed_bio {
 	/* number of bios pending for this compressed extent */
-	atomic_t pending_bios;
+	refcount_t pending_bios;
 
 	/* the pages with the compressed data on them */
 	struct page **compressed_pages;
@@ -161,7 +161,7 @@ static void end_compressed_bio_read(struct bio *bio)
 	/* if there are more bios still pending for this compressed
 	 * extent, just exit
 	 */
-	if (!atomic_dec_and_test(&cb->pending_bios))
+	if (!refcount_dec_and_test(&cb->pending_bios))
 		goto out;
 
 	inode = cb->inode;
@@ -274,7 +274,7 @@ static void end_compressed_bio_write(struct bio *bio)
 	/* if there are more bios still pending for this compressed
 	 * extent, just exit
 	 */
-	if (!atomic_dec_and_test(&cb->pending_bios))
+	if (!refcount_dec_and_test(&cb->pending_bios))
 		goto out;
 
 	/* ok, we're the last bio for this extent, step one is to
@@ -342,7 +342,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
 	cb = kmalloc(compressed_bio_size(fs_info, compressed_len), GFP_NOFS);
 	if (!cb)
 		return -ENOMEM;
-	atomic_set(&cb->pending_bios, 0);
+	refcount_set(&cb->pending_bios, 0);
 	cb->errors = 0;
 	cb->inode = inode;
 	cb->start = start;
@@ -363,7 +363,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
 	bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
 	bio->bi_private = cb;
 	bio->bi_end_io = end_compressed_bio_write;
-	atomic_inc(&cb->pending_bios);
+	refcount_set(&cb->pending_bios, 1);
 
 	/* create and submit bios for the compressed pages */
 	bytes_left = compressed_len;
@@ -388,7 +388,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
 			 * we inc the count.  Otherwise, the cb might get
 			 * freed before we're done setting it up
 			 */
-			atomic_inc(&cb->pending_bios);
+			refcount_inc(&cb->pending_bios);
 			ret = btrfs_bio_wq_end_io(fs_info, bio,
 						  BTRFS_WQ_ENDIO_DATA);
 			BUG_ON(ret); /* -ENOMEM */
@@ -607,7 +607,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
 	if (!cb)
 		goto out;
 
-	atomic_set(&cb->pending_bios, 0);
+	refcount_set(&cb->pending_bios, 0);
 	cb->errors = 0;
 	cb->inode = inode;
 	cb->mirror_num = mirror_num;
@@ -656,7 +656,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
 	bio_set_op_attrs (comp_bio, REQ_OP_READ, 0);
 	comp_bio->bi_private = cb;
 	comp_bio->bi_end_io = end_compressed_bio_read;
-	atomic_inc(&cb->pending_bios);
+	refcount_set(&cb->pending_bios, 1);
 
 	for (pg_index = 0; pg_index < nr_pages; pg_index++) {
 		page = cb->compressed_pages[pg_index];
@@ -685,7 +685,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
 			 * we inc the count.  Otherwise, the cb might get
 			 * freed before we're done setting it up
 			 */
-			atomic_inc(&cb->pending_bios);
+			refcount_inc(&cb->pending_bios);
 
 			if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {
 				ret = btrfs_lookup_bio_sums(inode, comp_bio,
-- 
2.7.4

[PATCH 12/17] fs, btrfs: convert scrub_recover.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/scrub.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index b0251eb..c9406bf 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -64,7 +64,7 @@ struct scrub_ctx;
 #define SCRUB_MAX_PAGES_PER_BLOCK	16	/* 64k per node/leaf/sector */
 
 struct scrub_recover {
-	atomic_t		refs;
+	refcount_t		refs;
 	struct btrfs_bio	*bbio;
 	u64			map_length;
 };
@@ -857,12 +857,12 @@ static void scrub_fixup_nodatasum(struct btrfs_work *work)
 
 static inline void scrub_get_recover(struct scrub_recover *recover)
 {
-	atomic_inc(&recover->refs);
+	refcount_inc(&recover->refs);
 }
 
 static inline void scrub_put_recover(struct scrub_recover *recover)
 {
-	if (atomic_dec_and_test(&recover->refs)) {
+	if (refcount_dec_and_test(&recover->refs)) {
 		btrfs_put_bbio(recover->bbio);
 		kfree(recover);
 	}
@@ -1343,7 +1343,7 @@ static int scrub_setup_recheck_block(struct scrub_block *original_sblock,
 			return -ENOMEM;
 		}
 
-		atomic_set(&recover->refs, 1);
+		refcount_set(&recover->refs, 1);
 		recover->bbio = bbio;
 		recover->map_length = mapped_length;
 
-- 
2.7.4

[PATCH 13/17] fs, btrfs: convert scrub_page.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/scrub.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index c9406bf..8299f64 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -79,7 +79,7 @@ struct scrub_page {
 	u64			logical;
 	u64			physical;
 	u64			physical_for_dev_replace;
-	atomic_t		refs;
+	refcount_t		refs;
 	struct {
 		unsigned int	mirror_num:8;
 		unsigned int	have_csum:1;
@@ -2017,12 +2017,12 @@ static void scrub_block_put(struct scrub_block *sblock)
 
 static void scrub_page_get(struct scrub_page *spage)
 {
-	atomic_inc(&spage->refs);
+	refcount_inc(&spage->refs);
 }
 
 static void scrub_page_put(struct scrub_page *spage)
 {
-	if (atomic_dec_and_test(&spage->refs)) {
+	if (refcount_dec_and_test(&spage->refs)) {
 		if (spage->page)
 			__free_page(spage->page);
 		kfree(spage);
-- 
2.7.4

[PATCH 14/17] fs, btrfs: convert scrub_block.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/scrub.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 8299f64..08895d8 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -112,7 +112,7 @@ struct scrub_block {
 	struct scrub_page	*pagev[SCRUB_MAX_PAGES_PER_BLOCK];
 	int			page_count;
 	atomic_t		outstanding_pages;
-	atomic_t		refs; /* free mem on transition to zero */
+	refcount_t		refs; /* free mem on transition to zero */
 	struct scrub_ctx	*sctx;
 	struct scrub_parity	*sparity;
 	struct {
@@ -1998,12 +1998,12 @@ static int scrub_checksum_super(struct scrub_block *sblock)
 
 static void scrub_block_get(struct scrub_block *sblock)
 {
-	atomic_inc(&sblock->refs);
+	refcount_inc(&sblock->refs);
 }
 
 static void scrub_block_put(struct scrub_block *sblock)
 {
-	if (atomic_dec_and_test(&sblock->refs)) {
+	if (refcount_dec_and_test(&sblock->refs)) {
 		int i;
 
 		if (sblock->sparity)
@@ -2255,7 +2255,7 @@ static int scrub_pages(struct scrub_ctx *sctx, u64 logical, u64 len,
 
 	/* one ref inside this function, plus one for each page added to
 	 * a bio later on */
-	atomic_set(&sblock->refs, 1);
+	refcount_set(&sblock->refs, 1);
 	sblock->sctx = sctx;
 	sblock->no_io_error_seen = 1;
 
@@ -2555,7 +2555,7 @@ static int scrub_pages_for_parity(struct scrub_parity *sparity,
 
 	/* one ref inside this function, plus one for each page added to
 	 * a bio later on */
-	atomic_set(&sblock->refs, 1);
+	refcount_set(&sblock->refs, 1);
 	sblock->sctx = sctx;
 	sblock->no_io_error_seen = 1;
 	sblock->sparity = sparity;
-- 
2.7.4

[PATCH 15/17] fs, btrfs: convert scrub_parity.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/scrub.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 08895d8..4d15112 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -142,7 +142,7 @@ struct scrub_parity {
 
 	int			stripe_len;
 
-	atomic_t		refs;
+	refcount_t		refs;
 
 	struct list_head	spages;
 
@@ -2822,12 +2822,12 @@ static inline int scrub_calc_parity_bitmap_len(int nsectors)
 
 static void scrub_parity_get(struct scrub_parity *sparity)
 {
-	atomic_inc(&sparity->refs);
+	refcount_inc(&sparity->refs);
 }
 
 static void scrub_parity_put(struct scrub_parity *sparity)
 {
-	if (!atomic_dec_and_test(&sparity->refs))
+	if (!refcount_dec_and_test(&sparity->refs))
 		return;
 
 	scrub_parity_check_and_repair(sparity);
@@ -2879,7 +2879,7 @@ static noinline_for_stack int scrub_raid56_parity(struct scrub_ctx *sctx,
 	sparity->scrub_dev = sdev;
 	sparity->logic_start = logic_start;
 	sparity->logic_end = logic_end;
-	atomic_set(&sparity->refs, 1);
+	refcount_set(&sparity->refs, 1);
 	INIT_LIST_HEAD(&sparity->spages);
 	sparity->dbitmap = sparity->bitmap;
 	sparity->ebitmap = (void *)sparity->bitmap + bitmap_len;
-- 
2.7.4

[PATCH 16/17] fs, btrfs: convert scrub_ctx.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/scrub.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 4d15112..ace634e 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -202,7 +202,7 @@ struct scrub_ctx {
 	 * doesn't free the scrub context before or while the workers are
 	 * doing the wakeup() call.
 	 */
-	atomic_t                refs;
+	refcount_t                refs;
 };
 
 struct scrub_fixup_nodatasum {
@@ -305,7 +305,7 @@ static void scrub_put_ctx(struct scrub_ctx *sctx);
 
 static void scrub_pending_bio_inc(struct scrub_ctx *sctx)
 {
-	atomic_inc(&sctx->refs);
+	refcount_inc(&sctx->refs);
 	atomic_inc(&sctx->bios_in_flight);
 }
 
@@ -356,7 +356,7 @@ static void scrub_pending_trans_workers_inc(struct scrub_ctx *sctx)
 {
 	struct btrfs_fs_info *fs_info = sctx->fs_info;
 
-	atomic_inc(&sctx->refs);
+	refcount_inc(&sctx->refs);
 	/*
 	 * increment scrubs_running to prevent cancel requests from
 	 * completing as long as a worker is running. we must also
@@ -447,7 +447,7 @@ static noinline_for_stack void scrub_free_ctx(struct scrub_ctx *sctx)
 
 static void scrub_put_ctx(struct scrub_ctx *sctx)
 {
-	if (atomic_dec_and_test(&sctx->refs))
+	if (refcount_dec_and_test(&sctx->refs))
 		scrub_free_ctx(sctx);
 }
 
@@ -462,7 +462,7 @@ struct scrub_ctx *scrub_setup_ctx(struct btrfs_device *dev, int is_dev_replace)
 	sctx = kzalloc(sizeof(*sctx), GFP_KERNEL);
 	if (!sctx)
 		goto nomem;
-	atomic_set(&sctx->refs, 1);
+	refcount_set(&sctx->refs, 1);
 	sctx->is_dev_replace = is_dev_replace;
 	sctx->pages_per_rd_bio = SCRUB_PAGES_PER_RD_BIO;
 	sctx->curr = -1;
-- 
2.7.4

[PATCH 17/17] fs, btrfs: convert btrfs_raid_bio.refs from atomic_t to refcount_t

[Elena Reshetova]

refcount_t type and corresponding API should be
used instead of atomic_t when the variable is used as
a reference counter. This allows to avoid accidental
refcounter overflows that might lead to use-after-free
situations.

Signed-off-by: Elena Reshetova <elena.reshetova@intel.com>
Signed-off-by: Hans Liljestrand <ishkamiel@gmail.com>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: David Windsor <dwindsor@gmail.com>
---
 fs/btrfs/raid56.c | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/fs/btrfs/raid56.c b/fs/btrfs/raid56.c
index 1571bf2..a8954f5 100644
--- a/fs/btrfs/raid56.c
+++ b/fs/btrfs/raid56.c
@@ -149,7 +149,7 @@ struct btrfs_raid_bio {
 
 	int generic_bio_cnt;
 
-	atomic_t refs;
+	refcount_t refs;
 
 	atomic_t stripes_pending;
 
@@ -389,7 +389,7 @@ static void __remove_rbio_from_cache(struct btrfs_raid_bio *rbio)
 		if (bio_list_empty(&rbio->bio_list)) {
 			if (!list_empty(&rbio->hash_list)) {
 				list_del_init(&rbio->hash_list);
-				atomic_dec(&rbio->refs);
+				refcount_dec(&rbio->refs);
 				BUG_ON(!list_empty(&rbio->plug_list));
 			}
 		}
@@ -480,7 +480,7 @@ static void cache_rbio(struct btrfs_raid_bio *rbio)
 
 	/* bump our ref if we were not in the list before */
 	if (!test_and_set_bit(RBIO_CACHE_BIT, &rbio->flags))
-		atomic_inc(&rbio->refs);
+		refcount_inc(&rbio->refs);
 
 	if (!list_empty(&rbio->stripe_cache)){
 		list_move(&rbio->stripe_cache, &table->stripe_cache);
@@ -689,7 +689,7 @@ static noinline int lock_stripe_add(struct btrfs_raid_bio *rbio)
 			    test_bit(RBIO_CACHE_BIT, &cur->flags) &&
 			    !test_bit(RBIO_RMW_LOCKED_BIT, &cur->flags)) {
 				list_del_init(&cur->hash_list);
-				atomic_dec(&cur->refs);
+				refcount_dec(&cur->refs);
 
 				steal_rbio(cur, rbio);
 				cache_drop = cur;
@@ -738,7 +738,7 @@ static noinline int lock_stripe_add(struct btrfs_raid_bio *rbio)
 		}
 	}
 lockit:
-	atomic_inc(&rbio->refs);
+	refcount_inc(&rbio->refs);
 	list_add(&rbio->hash_list, &h->hash_list);
 out:
 	spin_unlock_irqrestore(&h->lock, flags);
@@ -784,7 +784,7 @@ static noinline void unlock_stripe(struct btrfs_raid_bio *rbio)
 		}
 
 		list_del_init(&rbio->hash_list);
-		atomic_dec(&rbio->refs);
+		refcount_dec(&rbio->refs);
 
 		/*
 		 * we use the plug list to hold all the rbios
@@ -801,7 +801,7 @@ static noinline void unlock_stripe(struct btrfs_raid_bio *rbio)
 			list_del_init(&rbio->plug_list);
 
 			list_add(&next->hash_list, &h->hash_list);
-			atomic_inc(&next->refs);
+			refcount_inc(&next->refs);
 			spin_unlock(&rbio->bio_list_lock);
 			spin_unlock_irqrestore(&h->lock, flags);
 
@@ -843,8 +843,7 @@ static void __free_raid_bio(struct btrfs_raid_bio *rbio)
 {
 	int i;
 
-	WARN_ON(atomic_read(&rbio->refs) < 0);
-	if (!atomic_dec_and_test(&rbio->refs))
+	if (!refcount_dec_and_test(&rbio->refs))
 		return;
 
 	WARN_ON(!list_empty(&rbio->stripe_cache));
@@ -997,7 +996,7 @@ static struct btrfs_raid_bio *alloc_rbio(struct btrfs_fs_info *fs_info,
 	rbio->stripe_npages = stripe_npages;
 	rbio->faila = -1;
 	rbio->failb = -1;
-	atomic_set(&rbio->refs, 1);
+	refcount_set(&rbio->refs, 1);
 	atomic_set(&rbio->error, 0);
 	atomic_set(&rbio->stripes_pending, 0);
 
-- 
2.7.4

Re: [PATCH 00/17] fs, btrfs refcount conversions

[Qu Wenruo]

At 03/03/2017 04:55 PM, Elena Reshetova wrote:
> Now when new refcount_t type and API are finally merged
> (see include/linux/refcount.h), the following
> patches convert various refcounters in the btrfs filesystem from atomic_t
> to refcount_t. By doing this we prevent intentional or accidental
> underflows or overflows that can led to use-after-free vulnerabilities.
>
> The below patches are fully independent and can be cherry-picked separately.
> Since we convert all kernel subsystems in the same fashion, resulting
> in about 300 patches, we have to group them for sending at least in some
> fashion to be manageable. Please excuse the long cc list.
>
> These patches have been tested with xfstests by running btrfs-related tests.
> btrfs debug was enabled, warns on refcount errors, too. No output related to
> refcount errors produced. However, the following errors were during the run:
>  * tests btrfs/078, btrfs/114, btrfs/115, no errors anywhere in dmesg, but
>  process hangs. They all seem to be around qgroup, sometimes error visible
>  such as qgroup scan failed -4 before it blocks, but not always.

-EINTR? That's strange.

Any blocked process backtrace?

>  * test btrfs/104 dmesg has additional error output:
>  BTRFS warning (device vdc): qgroup 258 reserved space underflow, have: 0,
>  to free: 4096

Known one, and fixes already sent to mail list while not merged yet:
https://patchwork.kernel.org/patch/9592765/

Thanks,
Qu

>  I tried looking at the code on what causes the failure, but could not figure
>  it out. It doesn't seem to be related to any refcount changes at least IMO.
>
> The above test failures are hard for me to understand and interpreted, but
> they don't seem to relate to refcount conversions.
>
> Elena Reshetova (17):
>   fs, btrfs: convert btrfs_bio.refs from atomic_t to refcount_t
>   fs, btrfs: convert btrfs_transaction.use_count from atomic_t to
>     refcount_t
>   fs, btrfs: convert extent_map.refs from atomic_t to refcount_t
>   fs, btrfs: convert btrfs_ordered_extent.refs from atomic_t to
>     refcount_t
>   fs, btrfs: convert btrfs_caching_control.count from atomic_t to
>     refcount_t
>   fs, btrfs: convert btrfs_delayed_ref_node.refs from atomic_t to
>     refcount_t
>   fs, btrfs: convert btrfs_delayed_node.refs from atomic_t to refcount_t
>   fs, btrfs: convert btrfs_delayed_item.refs from atomic_t to refcount_t
>   fs, btrfs: convert btrfs_root.refs from atomic_t to refcount_t
>   fs, btrfs: convert extent_state.refs from atomic_t to refcount_t
>   fs, btrfs: convert compressed_bio.pending_bios from atomic_t to
>     refcount_t
>   fs, btrfs: convert scrub_recover.refs from atomic_t to refcount_t
>   fs, btrfs: convert scrub_page.refs from atomic_t to refcount_t
>   fs, btrfs: convert scrub_block.refs from atomic_t to refcount_t
>   fs, btrfs: convert scrub_parity.refs from atomic_t to refcount_t
>   fs, btrfs: convert scrub_ctx.refs from atomic_t to refcount_t
>   fs, btrfs: convert btrfs_raid_bio.refs from atomic_t to refcount_t
>
>  fs/btrfs/backref.c           |  2 +-
>  fs/btrfs/compression.c       | 18 ++++++++---------
>  fs/btrfs/ctree.h             |  5 +++--
>  fs/btrfs/delayed-inode.c     | 46 ++++++++++++++++++++++----------------------
>  fs/btrfs/delayed-inode.h     |  5 +++--
>  fs/btrfs/delayed-ref.c       |  8 ++++----
>  fs/btrfs/delayed-ref.h       |  8 +++++---
>  fs/btrfs/disk-io.c           |  6 +++---
>  fs/btrfs/disk-io.h           |  4 ++--
>  fs/btrfs/extent-tree.c       | 20 +++++++++----------
>  fs/btrfs/extent_io.c         | 18 ++++++++---------
>  fs/btrfs/extent_io.h         |  3 ++-
>  fs/btrfs/extent_map.c        | 10 +++++-----
>  fs/btrfs/extent_map.h        |  3 ++-
>  fs/btrfs/ordered-data.c      | 20 +++++++++----------
>  fs/btrfs/ordered-data.h      |  2 +-
>  fs/btrfs/raid56.c            | 19 +++++++++---------
>  fs/btrfs/scrub.c             | 42 ++++++++++++++++++++--------------------
>  fs/btrfs/transaction.c       | 20 +++++++++----------
>  fs/btrfs/transaction.h       |  3 ++-
>  fs/btrfs/tree-log.c          |  2 +-
>  fs/btrfs/volumes.c           | 10 +++++-----
>  fs/btrfs/volumes.h           |  2 +-
>  include/trace/events/btrfs.h |  4 ++--
>  24 files changed, 143 insertions(+), 137 deletions(-)
>

Re: [PATCH 00/17] fs, btrfs refcount conversions

[Qu Wenruo]

At 03/03/2017 04:55 PM, Elena Reshetova wrote:
> Now when new refcount_t type and API are finally merged
> (see include/linux/refcount.h), the following
> patches convert various refcounters in the btrfs filesystem from atomic_t
> to refcount_t. By doing this we prevent intentional or accidental
> underflows or overflows that can led to use-after-free vulnerabilities.
>
> The below patches are fully independent and can be cherry-picked separately.
> Since we convert all kernel subsystems in the same fashion, resulting
> in about 300 patches, we have to group them for sending at least in some
> fashion to be manageable. Please excuse the long cc list.
>
> These patches have been tested with xfstests by running btrfs-related tests.
> btrfs debug was enabled, warns on refcount errors, too. No output related to
> refcount errors produced. However, the following errors were during the run:
>  * tests btrfs/078, btrfs/114, btrfs/115, no errors anywhere in dmesg, but
>  process hangs. They all seem to be around qgroup, sometimes error visible
>  such as qgroup scan failed -4 before it blocks, but not always.

How reproducible of the hang?

I also see the -EINTR output, but that seems to be designed for 
btrfs/11[45].

btrfs/078 is unrelated to qgroup, and all these three test pass in my 
test environment, which is v4.11-rc1 with your patches applied.

I ran these 3 tests in a row with default and space_cache=v2 mount 
options, and 5 times for each mount option, no hang at all.

It would help much if more info can be provided, from blocked process 
backtrace to test mount option to base commit.

Thanks,
Qu

>  * test btrfs/104 dmesg has additional error output:
>  BTRFS warning (device vdc): qgroup 258 reserved space underflow, have: 0,
>  to free: 4096
>  I tried looking at the code on what causes the failure, but could not figure
>  it out. It doesn't seem to be related to any refcount changes at least IMO.
>
> The above test failures are hard for me to understand and interpreted, but
> they don't seem to relate to refcount conversions.
>
> Elena Reshetova (17):
>   fs, btrfs: convert btrfs_bio.refs from atomic_t to refcount_t
>   fs, btrfs: convert btrfs_transaction.use_count from atomic_t to
>     refcount_t
>   fs, btrfs: convert extent_map.refs from atomic_t to refcount_t
>   fs, btrfs: convert btrfs_ordered_extent.refs from atomic_t to
>     refcount_t
>   fs, btrfs: convert btrfs_caching_control.count from atomic_t to
>     refcount_t
>   fs, btrfs: convert btrfs_delayed_ref_node.refs from atomic_t to
>     refcount_t
>   fs, btrfs: convert btrfs_delayed_node.refs from atomic_t to refcount_t
>   fs, btrfs: convert btrfs_delayed_item.refs from atomic_t to refcount_t
>   fs, btrfs: convert btrfs_root.refs from atomic_t to refcount_t
>   fs, btrfs: convert extent_state.refs from atomic_t to refcount_t
>   fs, btrfs: convert compressed_bio.pending_bios from atomic_t to
>     refcount_t
>   fs, btrfs: convert scrub_recover.refs from atomic_t to refcount_t
>   fs, btrfs: convert scrub_page.refs from atomic_t to refcount_t
>   fs, btrfs: convert scrub_block.refs from atomic_t to refcount_t
>   fs, btrfs: convert scrub_parity.refs from atomic_t to refcount_t
>   fs, btrfs: convert scrub_ctx.refs from atomic_t to refcount_t
>   fs, btrfs: convert btrfs_raid_bio.refs from atomic_t to refcount_t
>
>  fs/btrfs/backref.c           |  2 +-
>  fs/btrfs/compression.c       | 18 ++++++++---------
>  fs/btrfs/ctree.h             |  5 +++--
>  fs/btrfs/delayed-inode.c     | 46 ++++++++++++++++++++++----------------------
>  fs/btrfs/delayed-inode.h     |  5 +++--
>  fs/btrfs/delayed-ref.c       |  8 ++++----
>  fs/btrfs/delayed-ref.h       |  8 +++++---
>  fs/btrfs/disk-io.c           |  6 +++---
>  fs/btrfs/disk-io.h           |  4 ++--
>  fs/btrfs/extent-tree.c       | 20 +++++++++----------
>  fs/btrfs/extent_io.c         | 18 ++++++++---------
>  fs/btrfs/extent_io.h         |  3 ++-
>  fs/btrfs/extent_map.c        | 10 +++++-----
>  fs/btrfs/extent_map.h        |  3 ++-
>  fs/btrfs/ordered-data.c      | 20 +++++++++----------
>  fs/btrfs/ordered-data.h      |  2 +-
>  fs/btrfs/raid56.c            | 19 +++++++++---------
>  fs/btrfs/scrub.c             | 42 ++++++++++++++++++++--------------------
>  fs/btrfs/transaction.c       | 20 +++++++++----------
>  fs/btrfs/transaction.h       |  3 ++-
>  fs/btrfs/tree-log.c          |  2 +-
>  fs/btrfs/volumes.c           | 10 +++++-----
>  fs/btrfs/volumes.h           |  2 +-
>  include/trace/events/btrfs.h |  4 ++--
>  24 files changed, 143 insertions(+), 137 deletions(-)
>

RE: [PATCH 00/17] fs, btrfs refcount conversions

[Reshetova, Elena]

[-- Attachment #1: Type: text/plain, Size: 5394 bytes --]


> At 03/03/2017 04:55 PM, Elena Reshetova wrote:
> > Now when new refcount_t type and API are finally merged
> > (see include/linux/refcount.h), the following
> > patches convert various refcounters in the btrfs filesystem from atomic_t
> > to refcount_t. By doing this we prevent intentional or accidental
> > underflows or overflows that can led to use-after-free vulnerabilities.
> >
> > The below patches are fully independent and can be cherry-picked separately.
> > Since we convert all kernel subsystems in the same fashion, resulting
> > in about 300 patches, we have to group them for sending at least in some
> > fashion to be manageable. Please excuse the long cc list.
> >
> > These patches have been tested with xfstests by running btrfs-related tests.
> > btrfs debug was enabled, warns on refcount errors, too. No output related to
> > refcount errors produced. However, the following errors were during the run:
> >  * tests btrfs/078, btrfs/114, btrfs/115, no errors anywhere in dmesg, but
> >  process hangs. They all seem to be around qgroup, sometimes error visible
> >  such as qgroup scan failed -4 before it blocks, but not always.
> 
> How reproducible of the hang?

Always in  my environment, but I would not much go into investigating why it happens, if it works for you. 
My test environment is far from ideal: I am testing in VM with rather old userspace and couple of additional changes in,
so there are many things that can potentially go wrong. Anyway the strace for 078 is in the attachment.

If the patches pass all tests on your side, could you please take them in and propagate further? 
I will continue with other kernel subsystems. 

Best Regards,
Elena.


> 
> I also see the -EINTR output, but that seems to be designed for
> btrfs/11[45].
> 
> btrfs/078 is unrelated to qgroup, and all these three test pass in my
> test environment, which is v4.11-rc1 with your patches applied.
> 
> I ran these 3 tests in a row with default and space_cache=v2 mount
> options, and 5 times for each mount option, no hang at all.
> 
> It would help much if more info can be provided, from blocked process
> backtrace to test mount option to base commit.
> 
> Thanks,
> Qu
> 
> >  * test btrfs/104 dmesg has additional error output:
> >  BTRFS warning (device vdc): qgroup 258 reserved space underflow, have: 0,
> >  to free: 4096
> >  I tried looking at the code on what causes the failure, but could not figure
> >  it out. It doesn't seem to be related to any refcount changes at least IMO.
> >
> > The above test failures are hard for me to understand and interpreted, but
> > they don't seem to relate to refcount conversions.
> >
> > Elena Reshetova (17):
> >   fs, btrfs: convert btrfs_bio.refs from atomic_t to refcount_t
> >   fs, btrfs: convert btrfs_transaction.use_count from atomic_t to
> >     refcount_t
> >   fs, btrfs: convert extent_map.refs from atomic_t to refcount_t
> >   fs, btrfs: convert btrfs_ordered_extent.refs from atomic_t to
> >     refcount_t
> >   fs, btrfs: convert btrfs_caching_control.count from atomic_t to
> >     refcount_t
> >   fs, btrfs: convert btrfs_delayed_ref_node.refs from atomic_t to
> >     refcount_t
> >   fs, btrfs: convert btrfs_delayed_node.refs from atomic_t to refcount_t
> >   fs, btrfs: convert btrfs_delayed_item.refs from atomic_t to refcount_t
> >   fs, btrfs: convert btrfs_root.refs from atomic_t to refcount_t
> >   fs, btrfs: convert extent_state.refs from atomic_t to refcount_t
> >   fs, btrfs: convert compressed_bio.pending_bios from atomic_t to
> >     refcount_t
> >   fs, btrfs: convert scrub_recover.refs from atomic_t to refcount_t
> >   fs, btrfs: convert scrub_page.refs from atomic_t to refcount_t
> >   fs, btrfs: convert scrub_block.refs from atomic_t to refcount_t
> >   fs, btrfs: convert scrub_parity.refs from atomic_t to refcount_t
> >   fs, btrfs: convert scrub_ctx.refs from atomic_t to refcount_t
> >   fs, btrfs: convert btrfs_raid_bio.refs from atomic_t to refcount_t
> >
> >  fs/btrfs/backref.c           |  2 +-
> >  fs/btrfs/compression.c       | 18 ++++++++---------
> >  fs/btrfs/ctree.h             |  5 +++--
> >  fs/btrfs/delayed-inode.c     | 46 ++++++++++++++++++++++----------------------
> >  fs/btrfs/delayed-inode.h     |  5 +++--
> >  fs/btrfs/delayed-ref.c       |  8 ++++----
> >  fs/btrfs/delayed-ref.h       |  8 +++++---
> >  fs/btrfs/disk-io.c           |  6 +++---
> >  fs/btrfs/disk-io.h           |  4 ++--
> >  fs/btrfs/extent-tree.c       | 20 +++++++++----------
> >  fs/btrfs/extent_io.c         | 18 ++++++++---------
> >  fs/btrfs/extent_io.h         |  3 ++-
> >  fs/btrfs/extent_map.c        | 10 +++++-----
> >  fs/btrfs/extent_map.h        |  3 ++-
> >  fs/btrfs/ordered-data.c      | 20 +++++++++----------
> >  fs/btrfs/ordered-data.h      |  2 +-
> >  fs/btrfs/raid56.c            | 19 +++++++++---------
> >  fs/btrfs/scrub.c             | 42 ++++++++++++++++++++--------------------
> >  fs/btrfs/transaction.c       | 20 +++++++++----------
> >  fs/btrfs/transaction.h       |  3 ++-
> >  fs/btrfs/tree-log.c          |  2 +-
> >  fs/btrfs/volumes.c           | 10 +++++-----
> >  fs/btrfs/volumes.h           |  2 +-
> >  include/trace/events/btrfs.h |  4 ++--
> >  24 files changed, 143 insertions(+), 137 deletions(-)
> >
> 


[-- Attachment #2: btrf_078_log --]
[-- Type: application/octet-stream, Size: 284572 bytes --]

elena@elena-Standard-PC-i440FX-PIIX-1996:~/fstest/xfstests$ sudo strace ./check btrfs/078
execve("./check", ["./check", "btrfs/078"], [/* 26 vars */]) = 0
brk(0)                                  = 0x11de000
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f8dd9866000
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=87605, ...}) = 0
mmap(NULL, 87605, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f8dd9850000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
open("/lib/x86_64-linux-gnu/libtinfo.so.5", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\320\303\0\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0644, st_size=167128, ...}) = 0
mmap(NULL, 2264480, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f8dd941c000
mprotect(0x7f8dd9441000, 2093056, PROT_NONE) = 0
mmap(0x7f8dd9640000, 20480, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x24000) = 0x7f8dd9640000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
open("/lib/x86_64-linux-gnu/libdl.so.2", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0`\16\0\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0644, st_size=14592, ...}) = 0
mmap(NULL, 2109712, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f8dd9218000
mprotect(0x7f8dd921b000, 2093056, PROT_NONE) = 0
mmap(0x7f8dd941a000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x2000) = 0x7f8dd941a000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
open("/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0`\v\2\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=1869392, ...}) = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f8dd984f000
mmap(NULL, 3972864, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f8dd8e4e000
mprotect(0x7f8dd900e000, 2097152, PROT_NONE) = 0
mmap(0x7f8dd920e000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1c0000) = 0x7f8dd920e000
mmap(0x7f8dd9214000, 16128, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7f8dd9214000
close(3)                                = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f8dd984e000
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f8dd984d000
arch_prctl(ARCH_SET_FS, 0x7f8dd984e700) = 0
mprotect(0x7f8dd920e000, 16384, PROT_READ) = 0
mprotect(0x7f8dd941a000, 4096, PROT_READ) = 0
mprotect(0x7f8dd9640000, 16384, PROT_READ) = 0
mprotect(0x6f3000, 4096, PROT_READ)     = 0
mprotect(0x7f8dd9868000, 4096, PROT_READ) = 0
munmap(0x7f8dd9850000, 87605)           = 0
open("/dev/tty", O_RDWR|O_NONBLOCK)     = 3
close(3)                                = 0
brk(0)                                  = 0x11de000
brk(0x11df000)                          = 0x11df000
open("/usr/lib/locale/locale-archive", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=8464304, ...}) = 0
mmap(NULL, 8464304, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f8dd863b000
close(3)                                = 0
brk(0x11e0000)                          = 0x11e0000
brk(0x11e1000)                          = 0x11e1000
brk(0x11e2000)                          = 0x11e2000
getuid()                                = 0
getgid()                                = 0
geteuid()                               = 0
getegid()                               = 0
rt_sigprocmask(SIG_BLOCK, NULL, [], 8)  = 0
brk(0x11e3000)                          = 0x11e3000
open("/proc/meminfo", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0444, st_size=0, ...}) = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f8dd9865000
read(3, "MemTotal:        2044176 kB\nMemF"..., 1024) = 1024
close(3)                                = 0
munmap(0x7f8dd9865000, 4096)            = 0
brk(0x11e4000)                          = 0x11e4000
rt_sigaction(SIGCHLD, {SIG_DFL, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGCHLD, {SIG_DFL, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGQUIT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGQUIT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_BLOCK, NULL, [], 8)  = 0
rt_sigaction(SIGQUIT, {SIG_IGN, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
uname({sys="Linux", node="elena-Standard-PC-i440FX-PIIX-1996", ...}) = 0
brk(0x11e5000)                          = 0x11e5000
brk(0x11e6000)                          = 0x11e6000
brk(0x11e8000)                          = 0x11e8000
getcwd("/home/elena/fstest/xfstests", 4096) = 28
getpid()                                = 1993
open("/usr/lib/x86_64-linux-gnu/gconv/gconv-modules.cache", O_RDONLY) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=26258, ...}) = 0
mmap(NULL, 26258, PROT_READ, MAP_SHARED, 3, 0) = 0x7f8dd985f000
close(3)                                = 0
brk(0x11e9000)                          = 0x11e9000
getppid()                               = 1990
gettimeofday({1488790083, 368782}, NULL) = 0
brk(0x11ea000)                          = 0x11ea000
getpgrp()                               = 1989
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
getrlimit(RLIMIT_NPROC, {rlim_cur=7847, rlim_max=7847}) = 0
brk(0x11eb000)                          = 0x11eb000
rt_sigprocmask(SIG_BLOCK, NULL, [], 8)  = 0
open("./check", O_RDONLY)               = 3
ioctl(3, SNDCTL_TMR_TIMEBASE or SNDRV_TIMER_IOCTL_NEXT_DEVICE or TCGETS, 0x7ffd027af4b0) = -1 ENOTTY (Inappropriate ioctl for device)
lseek(3, 0, SEEK_CUR)                   = 0
read(3, "#!/bin/bash\n#\n# Control script f"..., 80) = 80
lseek(3, 0, SEEK_SET)                   = 0
getrlimit(RLIMIT_NOFILE, {rlim_cur=1024, rlim_max=64*1024}) = 0
fcntl(255, F_GETFD)                     = -1 EBADF (Bad file descriptor)
dup2(3, 255)                            = 255
close(3)                                = 0
fcntl(255, F_SETFD, FD_CLOEXEC)         = 0
fcntl(255, F_GETFL)                     = 0x8000 (flags O_RDONLY|O_LARGEFILE)
fstat(255, {st_mode=S_IFREG|0775, st_size=17559, ...}) = 0
lseek(255, 0, SEEK_CUR)                 = 0
brk(0x11ed000)                          = 0x11ed000
brk(0x11ee000)                          = 0x11ee000
read(255, "#!/bin/bash\n#\n# Control script f"..., 8176) = 8176
brk(0x11ef000)                          = 0x11ef000
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
lseek(255, -7232, SEEK_CUR)             = 944
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 1994
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/home/elena/fstest/xfstests\n", 128) = 28
brk(0x11f0000)                          = 0x11f0000
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 1994
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=1994, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027aea90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
read(255, "xfile=\"\"\nbrief_test_summary=fals"..., 8176) = 8176
stat(".", {st_mode=S_IFDIR|0775, st_size=4096, ...}) = 0
stat("/usr/local/sbin/rm", 0x7ffd027af170) = -1 ENOENT (No such file or directory)
stat("/usr/local/bin/rm", 0x7ffd027af170) = -1 ENOENT (No such file or directory)
stat("/usr/sbin/rm", 0x7ffd027af170)    = -1 ENOENT (No such file or directory)
stat("/usr/bin/rm", 0x7ffd027af170)     = -1 ENOENT (No such file or directory)
stat("/sbin/rm", 0x7ffd027af170)        = -1 ENOENT (No such file or directory)
stat("/bin/rm", {st_mode=S_IFREG|0755, st_size=60160, ...}) = 0
stat("/bin/rm", {st_mode=S_IFREG|0755, st_size=60160, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/rm", X_OK)                 = 0
stat("/bin/rm", {st_mode=S_IFREG|0755, st_size=60160, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/rm", R_OK)                 = 0
stat("/bin/rm", {st_mode=S_IFREG|0755, st_size=60160, ...}) = 0
stat("/bin/rm", {st_mode=S_IFREG|0755, st_size=60160, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/rm", X_OK)                 = 0
stat("/bin/rm", {st_mode=S_IFREG|0755, st_size=60160, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/rm", R_OK)                 = 0
brk(0x11f1000)                          = 0x11f1000
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
lseek(255, -7775, SEEK_CUR)             = 1345
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 1995
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 1995
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=1995, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027aedd0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
read(255, "\nSRC_GROUPS=\"generic shared\"\nexp"..., 8176) = 8176
brk(0x11f2000)                          = 0x11f2000
brk(0x11f3000)                          = 0x11f3000
brk(0x11f4000)                          = 0x11f4000
brk(0x11f5000)                          = 0x11f5000
brk(0x11f6000)                          = 0x11f6000
brk(0x11f7000)                          = 0x11f7000
brk(0x11f8000)                          = 0x11f8000
brk(0x11f9000)                          = 0x11f9000
brk(0x11fa000)                          = 0x11fa000
brk(0x11fb000)                          = 0x11fb000
brk(0x11fc000)                          = 0x11fc000
brk(0x11fd000)                          = 0x11fd000
brk(0x11fe000)                          = 0x11fe000
brk(0x11ff000)                          = 0x11ff000
brk(0x1200000)                          = 0x1200000
brk(0x1201000)                          = 0x1201000
brk(0x1202000)                          = 0x1202000
brk(0x1203000)                          = 0x1203000
brk(0x1204000)                          = 0x1204000
brk(0x1205000)                          = 0x1205000
brk(0x1206000)                          = 0x1206000
brk(0x1207000)                          = 0x1207000
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
open("./common/config", O_RDONLY)       = 3
fstat(3, {st_mode=S_IFREG|0664, st_size=18034, ...}) = 0
brk(0x120f000)                          = 0x120f000
read(3, "##/bin/bash\n#\n# Copyright (c) 20"..., 18034) = 18034
close(3)                                = 0
brk(0x1210000)                          = 0x1210000
rt_sigprocmask(SIG_BLOCK, NULL, [], 8)  = 0
stat("/usr/bsd", 0x7ffd027aeae0)        = -1 ENOENT (No such file or directory)
stat("/usr/freeware/bin", 0x7ffd027aeae0) = -1 ENOENT (No such file or directory)
brk(0x1211000)                          = 0x1211000
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 1996
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "elena-Standard-PC-i440FX-PIIX-19"..., 128) = 35
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=1996, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 1996
wait4(-1, 0x7ffd027ae590, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 1998
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "Linux\n", 128)                 = 6
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=1998, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 1998
wait4(-1, 0x7ffd027ae590, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2000
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/home/elena/fstest/xfstests\n", 128) = 28
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2000, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2000
wait4(-1, 0x7ffd027ae590, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 28
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
brk(0x1212000)                          = 0x1212000
brk(0x1213000)                          = 0x1213000
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2001
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/sbin/mkfs\n", 128)            = 11
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2001, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2001
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 11
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2004
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/bin/mount\n", 128)            = 11
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2004, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2004
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 11
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2007
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/bin/umount\n", 128)           = 12
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2007, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2007
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
faccessat(AT_FDCWD, "./ltp/fsstress", X_OK) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2010
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/perl\n", 128)         = 14
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2010, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2010
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 14
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
brk(0x1214000)                          = 0x1214000
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2013
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/awk\n", 128)          = 13
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2013, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2013
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 13
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2016
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/bin/sed\n", 128)              = 9
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2016, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2016
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 9
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2019
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/bc\n", 128)           = 12
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2019, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2019
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 12
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2022
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/bin/df\n", 128)               = 8
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2022, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2022
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 8
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2025
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/sbin/xfs_io\n", 128)      = 17
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2025, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2025
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 17
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2028
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/sbin/xfs_logprint\n", 128) = 23
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2028, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2028
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 23
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
brk(0x1215000)                          = 0x1215000
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2031
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/sbin/xfs_repair\n", 128)      = 17
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2031, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2031
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 17
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2034
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/sbin/xfs_db\n", 128)      = 17
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2034, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2034
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 17
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2037
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/sbin/xfs_growfs\n", 128)  = 21
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2037, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2037
wait4(-1, 0x7ffd027ae590, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 21
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2040
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2040, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2040
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2043
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2043, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2043
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2046
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2046, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2046
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2049
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2049, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2049
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2052
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2052, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2052
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2055
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2055, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2055
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2058
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/getfattr\n", 128)     = 18
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2058
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2058, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae350, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2061
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/setfattr\n", 128)     = 18
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2061, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2061
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2064
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/chacl\n", 128)        = 15
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2064, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2064
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2067
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/attr\n", 128)         = 14
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2067, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2067
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 14
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2070
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/quota\n", 128)        = 15
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2070, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2070
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 15
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
brk(0x1216000)                          = 0x1216000
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2073
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/sbin/xfs_quota\n", 128)   = 20
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2073, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2073
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 20
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2076
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/killall\n", 128)      = 17
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2076, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2076
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 17
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2079
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2079, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2079
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2082
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/sbin/xfs_copy\n", 128)    = 19
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2082, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2082
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 19
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2085
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/sbin/fstrim\n", 128)          = 13
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2085
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2085, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae350, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2088
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/sbin/dumpe2fs\n", 128)        = 15
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2088, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2088
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 15
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2091
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/fio\n", 128)          = 13
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2091, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2091
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 13
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2094
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/sbin/filefrag\n", 128)    = 19
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2094, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2094
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 19
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2097
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/sbin/e4defrag\n", 128)    = 19
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2097, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2097
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 19
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2100
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/logger\n", 128)       = 16
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2100, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2100
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 16
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2103
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/dbench\n", 128)       = 16
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2103, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2103
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 16
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2106
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/sbin/dmsetup\n", 128)         = 14
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2106, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2106
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 14
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
brk(0x1217000)                          = 0x1217000
brk(0x1218000)                          = 0x1218000
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2109
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/sbin/wipefs\n", 128)          = 13
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2109, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2109
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 13
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2112
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2112, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2112
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2115
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2115, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2115
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2118
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2118, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2118
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2121
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/chattr\n", 128)       = 16
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2121, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2121
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 16
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2124
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/sbin/debugfs\n", 128)         = 14
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2124, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2124
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 14
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2127
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/uuidgen\n", 128)      = 17
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2127, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2127
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 17
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2130
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2130, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2130
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2133
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2133, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2133
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2136
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/bin/keyctl\n", 128)           = 12
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2136, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2136
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 12
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2139
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/xz\n", 128)           = 12
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2139, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2139
wait4(-1, 0x7ffd027ae490, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 12
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2142
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/sbin/udevadm\n", 128)         = 14
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2142, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2142
wait4(-1, 0x7ffd027ae390, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 14
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
brk(0x1219000)                          = 0x1219000
brk(0x121a000)                          = 0x121a000
brk(0x121b000)                          = 0x121b000
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2145
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/sbin/mkfs.xfs\n", 128)        = 15
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2145, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2145
wait4(-1, 0x7ffd027ad790, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 15
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2148
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/sbin/mkfs.ext4\n", 128)       = 16
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2148, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2148
wait4(-1, 0x7ffd027ad790, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 16
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2151
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2151, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2151
wait4(-1, 0x7ffd027ad890, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2154
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/bin/mkfs.btrfs -f\n", 128)    = 19
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2154, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2154
wait4(-1, 0x7ffd027ad990, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 19
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2159
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2159, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2159
wait4(-1, 0x7ffd027ada90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2162
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2162, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2162
wait4(-1, 0x7ffd027adb90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2165
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/bin/btrfs\n", 128)            = 11
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2165, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2165
wait4(-1, 0x7ffd027adc90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 11
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2168
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/bin/btrfs-show-super\n", 128) = 22
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2168, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2168
wait4(-1, 0x7ffd027add90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 22
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2171
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/sbin/xfs_fsr\n", 128)     = 18
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2171, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2171
wait4(-1, 0x7ffd027ade90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 18
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2174
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "\n", 128)                      = 1
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2174, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], WNOHANG, NULL) = 2174
wait4(-1, 0x7ffd027ae290, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 1
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
faccessat(AT_FDCWD, "/usr/sbin/selinuxenabled", X_OK) = -1 ENOENT (No such file or directory)
stat(".", {st_mode=S_IFDIR|0775, st_size=4096, ...}) = 0
stat(".", {st_mode=S_IFDIR|0775, st_size=4096, ...}) = 0
stat("./touch", 0x7ffd027aeb60)         = -1 ENOENT (No such file or directory)
stat("/usr/local/sbin/touch", 0x7ffd027aeb60) = -1 ENOENT (No such file or directory)
stat("/usr/local/bin/touch", 0x7ffd027aeb60) = -1 ENOENT (No such file or directory)
stat("/usr/sbin/touch", 0x7ffd027aeb60) = -1 ENOENT (No such file or directory)
stat("/usr/bin/touch", {st_mode=S_IFREG|0755, st_size=60224, ...}) = 0
stat("/usr/bin/touch", {st_mode=S_IFREG|0755, st_size=60224, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/usr/bin/touch", X_OK)          = 0
stat("/usr/bin/touch", {st_mode=S_IFREG|0755, st_size=60224, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/usr/bin/touch", R_OK)          = 0
stat("/usr/bin/touch", {st_mode=S_IFREG|0755, st_size=60224, ...}) = 0
stat("/usr/bin/touch", {st_mode=S_IFREG|0755, st_size=60224, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/usr/bin/touch", X_OK)          = 0
stat("/usr/bin/touch", {st_mode=S_IFREG|0755, st_size=60224, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/usr/bin/touch", R_OK)          = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2177
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2177
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2177, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae7d0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2178
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2178
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2178, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae7d0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
stat(".", {st_mode=S_IFDIR|0775, st_size=4096, ...}) = 0
stat(".", {st_mode=S_IFDIR|0775, st_size=4096, ...}) = 0
stat("./rm", 0x7ffd027aeb60)            = -1 ENOENT (No such file or directory)
stat("/usr/local/sbin/rm", 0x7ffd027aeb60) = -1 ENOENT (No such file or directory)
stat("/usr/local/bin/rm", 0x7ffd027aeb60) = -1 ENOENT (No such file or directory)
stat("/usr/sbin/rm", 0x7ffd027aeb60)    = -1 ENOENT (No such file or directory)
stat("/usr/bin/rm", 0x7ffd027aeb60)     = -1 ENOENT (No such file or directory)
stat("/sbin/rm", 0x7ffd027aeb60)        = -1 ENOENT (No such file or directory)
stat("/bin/rm", {st_mode=S_IFREG|0755, st_size=60160, ...}) = 0
stat("/bin/rm", {st_mode=S_IFREG|0755, st_size=60160, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/rm", X_OK)                 = 0
stat("/bin/rm", {st_mode=S_IFREG|0755, st_size=60160, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/rm", R_OK)                 = 0
stat("/bin/rm", {st_mode=S_IFREG|0755, st_size=60160, ...}) = 0
stat("/bin/rm", {st_mode=S_IFREG|0755, st_size=60160, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/rm", X_OK)                 = 0
stat("/bin/rm", {st_mode=S_IFREG|0755, st_size=60160, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/rm", R_OK)                 = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2179
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2179
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2179, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae7d0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
brk(0x121c000)                          = 0x121c000
brk(0x121d000)                          = 0x121d000
brk(0x121e000)                          = 0x121e000
brk(0x121f000)                          = 0x121f000
brk(0x1220000)                          = 0x1220000
brk(0x1221000)                          = 0x1221000
brk(0x1222000)                          = 0x1222000
brk(0x1223000)                          = 0x1223000
stat("local.config", {st_mode=S_IFREG|0664, st_size=313, ...}) = 0
brk(0x1224000)                          = 0x1224000
stat("local.config", {st_mode=S_IFREG|0664, st_size=313, ...}) = 0
brk(0x1225000)                          = 0x1225000
brk(0x1226000)                          = 0x1226000
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2180
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2180, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2180
wait4(-1, 0x7ffd027ae390, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
stat(".", {st_mode=S_IFDIR|0775, st_size=4096, ...}) = 0
stat(".", {st_mode=S_IFDIR|0775, st_size=4096, ...}) = 0
stat("./local.config", {st_mode=S_IFREG|0664, st_size=313, ...}) = 0
stat("./local.config", {st_mode=S_IFREG|0664, st_size=313, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("./local.config", X_OK)          = -1 EACCES (Permission denied)
stat("./local.config", {st_mode=S_IFREG|0664, st_size=313, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("./local.config", R_OK)          = 0
stat("./local.config", {st_mode=S_IFREG|0664, st_size=313, ...}) = 0
stat("./local.config", {st_mode=S_IFREG|0664, st_size=313, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("./local.config", X_OK)          = -1 EACCES (Permission denied)
stat("./local.config", {st_mode=S_IFREG|0664, st_size=313, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("./local.config", R_OK)          = 0
open("./local.config", O_RDONLY)        = 3
fstat(3, {st_mode=S_IFREG|0664, st_size=313, ...}) = 0
read(3, "# Ideally define at least these "..., 313) = 313
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, NULL, [], 8)  = 0
brk(0x1227000)                          = 0x1227000
brk(0x1228000)                          = 0x1228000
brk(0x1229000)                          = 0x1229000
brk(0x122a000)                          = 0x122a000
brk(0x122b000)                          = 0x122b000
brk(0x122c000)                          = 0x122c000
brk(0x122d000)                          = 0x122d000
brk(0x122e000)                          = 0x122e000
brk(0x122f000)                          = 0x122f000
brk(0x1230000)                          = 0x1230000
brk(0x1231000)                          = 0x1231000
brk(0x1232000)                          = 0x1232000
brk(0x1233000)                          = 0x1233000
brk(0x1234000)                          = 0x1234000
brk(0x1235000)                          = 0x1235000
brk(0x1236000)                          = 0x1236000
brk(0x1237000)                          = 0x1237000
brk(0x1238000)                          = 0x1238000
brk(0x1239000)                          = 0x1239000
brk(0x123a000)                          = 0x123a000
brk(0x123b000)                          = 0x123b000
brk(0x123c000)                          = 0x123c000
brk(0x123d000)                          = 0x123d000
brk(0x123e000)                          = 0x123e000
brk(0x123f000)                          = 0x123f000
brk(0x1240000)                          = 0x1240000
brk(0x1241000)                          = 0x1241000
brk(0x1242000)                          = 0x1242000
brk(0x1243000)                          = 0x1243000
brk(0x1244000)                          = 0x1244000
brk(0x1245000)                          = 0x1245000
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2182
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "-no-sections-\n", 128)         = 14
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2182, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2182
wait4(-1, 0x7ffd027adc90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
brk(0x1246000)                          = 0x1246000
brk(0x1247000)                          = 0x1247000
brk(0x1248000)                          = 0x1248000
brk(0x1249000)                          = 0x1249000
brk(0x124a000)                          = 0x124a000
brk(0x124b000)                          = 0x124b000
brk(0x124c000)                          = 0x124c000
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
pipe([3, 4])                            = 0
brk(0x124d000)                          = 0x124d000
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [CHLD], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2185
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(4)                                = 0
close(4)                                = -1 EBADF (Bad file descriptor)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [CHLD], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2186
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [CHLD], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2185
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], 0, NULL) = 2186
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(3)                                = -1 EBADF (Bad file descriptor)
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2185, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ad050, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
stat("/dev/vdb", {st_mode=S_IFBLK|0660, st_rdev=makedev(253, 16), ...}) = 0
stat("/media/elena/TEST", {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [CHLD], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2187
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(4)                                = 0
close(4)                                = -1 EBADF (Bad file descriptor)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [CHLD], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2188
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [CHLD], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], 0, NULL) = 2188
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2187
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(3)                                = -1 EBADF (Bad file descriptor)
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2188, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ad350, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
stat("/dev/vdc", {st_mode=S_IFBLK|0660, st_rdev=makedev(253, 32), ...}) = 0
stat("/media/elena/SCRATCH", {st_mode=S_IFDIR|0777, st_size=4096, ...}) = 0
brk(0x124e000)                          = 0x124e000
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2189
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "btrfs\n", 128)                 = 6
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2189, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2189
wait4(-1, 0x7ffd027adb90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2191
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/media/elena/TEST\n", 128)     = 18
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2191, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2191
wait4(-1, 0x7ffd027ae590, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2193
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/media/elena/SCRATCH\n", 128)  = 21
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2193
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2193, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae450, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2195
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2195
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2195, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae7d0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, NULL, [], 8)  = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
lseek(255, -1360, SEEK_CUR)             = 8161
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2196
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "btrfs/078\n", 128)             = 10
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2196, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2196
wait4(-1, 0x7ffd027ae450, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 10
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2197
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "btrfs\n", 128)                 = 6
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2197
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2197, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027adf50, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2198
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "078\n", 128)                   = 4
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2198
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2198, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae050, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
stat(".", {st_mode=S_IFDIR|0775, st_size=4096, ...}) = 0
stat(".", {st_mode=S_IFDIR|0775, st_size=4096, ...}) = 0
stat("./egrep", 0x7ffd027ae970)         = -1 ENOENT (No such file or directory)
stat("/usr/local/sbin/egrep", 0x7ffd027ae970) = -1 ENOENT (No such file or directory)
stat("/usr/local/bin/egrep", 0x7ffd027ae970) = -1 ENOENT (No such file or directory)
stat("/usr/sbin/egrep", 0x7ffd027ae970) = -1 ENOENT (No such file or directory)
stat("/usr/bin/egrep", 0x7ffd027ae970)  = -1 ENOENT (No such file or directory)
stat("/sbin/egrep", 0x7ffd027ae970)     = -1 ENOENT (No such file or directory)
stat("/bin/egrep", {st_mode=S_IFREG|0755, st_size=29, ...}) = 0
stat("/bin/egrep", {st_mode=S_IFREG|0755, st_size=29, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/egrep", X_OK)              = 0
stat("/bin/egrep", {st_mode=S_IFREG|0755, st_size=29, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/egrep", R_OK)              = 0
stat("/bin/egrep", {st_mode=S_IFREG|0755, st_size=29, ...}) = 0
stat("/bin/egrep", {st_mode=S_IFREG|0755, st_size=29, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/egrep", X_OK)              = 0
stat("/bin/egrep", {st_mode=S_IFREG|0755, st_size=29, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/egrep", R_OK)              = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2199
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2199
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2199, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae5d0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
open("/tmp/1993.arglist", O_WRONLY|O_CREAT|O_APPEND, 0666) = 3
fcntl(1, F_GETFD)                       = 0
fcntl(1, F_DUPFD, 10)                   = 10
fcntl(1, F_GETFD)                       = 0
fcntl(10, F_SETFD, FD_CLOEXEC)          = 0
dup2(3, 1)                              = 1
close(3)                                = 0
write(1, "tests/btrfs/078\n", 16)       = 16
dup2(10, 1)                             = 1
fcntl(10, F_GETFD)                      = 0x1 (flags FD_CLOEXEC)
close(10)                               = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
read(255, "\n# we need common/rc\nif ! . ./co"..., 8176) = 8176
open("./common/rc", O_RDONLY)           = 3
fstat(3, {st_mode=S_IFREG|0664, st_size=74605, ...}) = 0
brk(0x126e000)                          = 0x126e000
read(3, "##/bin/bash\n#-------------------"..., 74605) = 74605
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, NULL, [], 8)  = 0
rt_sigprocmask(SIG_BLOCK, NULL, [], 8)  = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2200
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/usr/bin/bc\n", 128)           = 12
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2200, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2200
wait4(-1, 0x7ffd027ae250, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
umask(022)                              = 022
open("./common/btrfs", O_RDONLY)        = 3
fstat(3, {st_mode=S_IFREG|0664, st_size=10137, ...}) = 0
read(3, "#\n# Common btrfs specific functi"..., 10137) = 10137
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, NULL, [], 8)  = 0
brk(0x126f000)                          = 0x126f000
brk(0x1270000)                          = 0x1270000
brk(0x1271000)                          = 0x1271000
brk(0x1272000)                          = 0x1272000
brk(0x1273000)                          = 0x1273000
brk(0x1274000)                          = 0x1274000
brk(0x1275000)                          = 0x1275000
brk(0x1276000)                          = 0x1276000
brk(0x1277000)                          = 0x1277000
brk(0x1278000)                          = 0x1278000
brk(0x1279000)                          = 0x1279000
brk(0x127a000)                          = 0x127a000
brk(0x127b000)                          = 0x127b000
brk(0x127c000)                          = 0x127c000
brk(0x127d000)                          = 0x127d000
brk(0x127e000)                          = 0x127e000
brk(0x127f000)                          = 0x127f000
brk(0x1280000)                          = 0x1280000
brk(0x1281000)                          = 0x1281000
brk(0x1282000)                          = 0x1282000
brk(0x1283000)                          = 0x1283000
brk(0x1284000)                          = 0x1284000
brk(0x1285000)                          = 0x1285000
brk(0x1286000)                          = 0x1286000
brk(0x1287000)                          = 0x1287000
brk(0x1288000)                          = 0x1288000
brk(0x1289000)                          = 0x1289000
brk(0x128a000)                          = 0x128a000
brk(0x128b000)                          = 0x128b000
brk(0x128c000)                          = 0x128c000
brk(0x128d000)                          = 0x128d000
brk(0x128e000)                          = 0x128e000
brk(0x128f000)                          = 0x128f000
brk(0x1290000)                          = 0x1290000
brk(0x1291000)                          = 0x1291000
brk(0x1292000)                          = 0x1292000
brk(0x1293000)                          = 0x1293000
brk(0x1294000)                          = 0x1294000
brk(0x1295000)                          = 0x1295000
brk(0x1296000)                          = 0x1296000
brk(0x1297000)                          = 0x1297000
brk(0x1298000)                          = 0x1298000
brk(0x1299000)                          = 0x1299000
brk(0x129a000)                          = 0x129a000
brk(0x129b000)                          = 0x129b000
brk(0x129c000)                          = 0x129c000
brk(0x129d000)                          = 0x129d000
brk(0x129e000)                          = 0x129e000
brk(0x129f000)                          = 0x129f000
brk(0x12a0000)                          = 0x12a0000
brk(0x12a1000)                          = 0x12a1000
brk(0x12a2000)                          = 0x12a2000
brk(0x12a3000)                          = 0x12a3000
brk(0x12a4000)                          = 0x12a4000
brk(0x12a5000)                          = 0x12a5000
brk(0x12a6000)                          = 0x12a6000
brk(0x12a7000)                          = 0x12a7000
brk(0x12a8000)                          = 0x12a8000
brk(0x12a9000)                          = 0x12a9000
brk(0x12aa000)                          = 0x12aa000
brk(0x12ab000)                          = 0x12ab000
brk(0x12ac000)                          = 0x12ac000
brk(0x12ad000)                          = 0x12ad000
brk(0x12ae000)                          = 0x12ae000
brk(0x12af000)                          = 0x12af000
brk(0x12b0000)                          = 0x12b0000
brk(0x12b1000)                          = 0x12b1000
brk(0x12b2000)                          = 0x12b2000
brk(0x12b3000)                          = 0x12b3000
brk(0x12b4000)                          = 0x12b4000
brk(0x12b5000)                          = 0x12b5000
brk(0x12b6000)                          = 0x12b6000
brk(0x12b7000)                          = 0x12b7000
brk(0x12b8000)                          = 0x12b8000
brk(0x12b9000)                          = 0x12b9000
brk(0x12ba000)                          = 0x12ba000
brk(0x12bb000)                          = 0x12bb000
brk(0x12bc000)                          = 0x12bc000
brk(0x12bd000)                          = 0x12bd000
brk(0x12be000)                          = 0x12be000
brk(0x12bf000)                          = 0x12bf000
brk(0x12c0000)                          = 0x12c0000
brk(0x12c1000)                          = 0x12c1000
brk(0x12c2000)                          = 0x12c2000
brk(0x12c3000)                          = 0x12c3000
brk(0x12c4000)                          = 0x12c4000
brk(0x12c5000)                          = 0x12c5000
brk(0x12c6000)                          = 0x12c6000
brk(0x12c7000)                          = 0x12c7000
brk(0x12c8000)                          = 0x12c8000
brk(0x12c9000)                          = 0x12c9000
brk(0x12ca000)                          = 0x12ca000
brk(0x12cb000)                          = 0x12cb000
brk(0x12cc000)                          = 0x12cc000
brk(0x12cd000)                          = 0x12cd000
brk(0x12ce000)                          = 0x12ce000
brk(0x12cf000)                          = 0x12cf000
brk(0x12d0000)                          = 0x12d0000
brk(0x12d1000)                          = 0x12d1000
brk(0x12d2000)                          = 0x12d2000
brk(0x12d3000)                          = 0x12d3000
brk(0x12d4000)                          = 0x12d4000
brk(0x12d5000)                          = 0x12d5000
brk(0x12d6000)                          = 0x12d6000
brk(0x12d7000)                          = 0x12d7000
brk(0x12d8000)                          = 0x12d8000
brk(0x12d9000)                          = 0x12d9000
brk(0x12da000)                          = 0x12da000
brk(0x12db000)                          = 0x12db000
brk(0x12dc000)                          = 0x12dc000
brk(0x12dd000)                          = 0x12dd000
brk(0x12de000)                          = 0x12de000
brk(0x12df000)                          = 0x12df000
brk(0x12e0000)                          = 0x12e0000
brk(0x12e1000)                          = 0x12e1000
brk(0x12e2000)                          = 0x12e2000
brk(0x12e3000)                          = 0x12e3000
brk(0x12e4000)                          = 0x12e4000
brk(0x12e5000)                          = 0x12e5000
brk(0x12e6000)                          = 0x12e6000
brk(0x12e7000)                          = 0x12e7000
brk(0x12e8000)                          = 0x12e8000
brk(0x12e9000)                          = 0x12e9000
brk(0x12ea000)                          = 0x12ea000
brk(0x12eb000)                          = 0x12eb000
brk(0x12ec000)                          = 0x12ec000
brk(0x12ed000)                          = 0x12ed000
brk(0x12ee000)                          = 0x12ee000
brk(0x12ef000)                          = 0x12ef000
brk(0x12f0000)                          = 0x12f0000
brk(0x12f1000)                          = 0x12f1000
brk(0x12f2000)                          = 0x12f2000
brk(0x12f3000)                          = 0x12f3000
brk(0x12f4000)                          = 0x12f4000
brk(0x12f5000)                          = 0x12f5000
brk(0x12f6000)                          = 0x12f6000
brk(0x12f7000)                          = 0x12f7000
brk(0x12f8000)                          = 0x12f8000
brk(0x12f9000)                          = 0x12f9000
brk(0x12fa000)                          = 0x12fa000
brk(0x12fb000)                          = 0x12fb000
brk(0x12fc000)                          = 0x12fc000
brk(0x12fd000)                          = 0x12fd000
brk(0x12fe000)                          = 0x12fe000
brk(0x12ff000)                          = 0x12ff000
brk(0x1300000)                          = 0x1300000
brk(0x1301000)                          = 0x1301000
brk(0x1302000)                          = 0x1302000
brk(0x1303000)                          = 0x1303000
brk(0x1304000)                          = 0x1304000
brk(0x1305000)                          = 0x1305000
brk(0x1306000)                          = 0x1306000
brk(0x1307000)                          = 0x1307000
brk(0x1308000)                          = 0x1308000
brk(0x1309000)                          = 0x1309000
brk(0x130a000)                          = 0x130a000
brk(0x130b000)                          = 0x130b000
brk(0x130c000)                          = 0x130c000
brk(0x130d000)                          = 0x130d000
brk(0x130e000)                          = 0x130e000
brk(0x130f000)                          = 0x130f000
brk(0x1310000)                          = 0x1310000
brk(0x1311000)                          = 0x1311000
brk(0x1312000)                          = 0x1312000
brk(0x1313000)                          = 0x1313000
brk(0x1314000)                          = 0x1314000
brk(0x1315000)                          = 0x1315000
brk(0x1316000)                          = 0x1316000
brk(0x1317000)                          = 0x1317000
brk(0x1318000)                          = 0x1318000
brk(0x1319000)                          = 0x1319000
brk(0x131a000)                          = 0x131a000
brk(0x131b000)                          = 0x131b000
brk(0x131c000)                          = 0x131c000
brk(0x131d000)                          = 0x131d000
brk(0x131e000)                          = 0x131e000
brk(0x131f000)                          = 0x131f000
brk(0x1320000)                          = 0x1320000
brk(0x1321000)                          = 0x1321000
brk(0x1322000)                          = 0x1322000
brk(0x1323000)                          = 0x1323000
brk(0x1324000)                          = 0x1324000
brk(0x1325000)                          = 0x1325000
brk(0x1326000)                          = 0x1326000
brk(0x1327000)                          = 0x1327000
brk(0x1328000)                          = 0x1328000
brk(0x1329000)                          = 0x1329000
brk(0x132a000)                          = 0x132a000
brk(0x132b000)                          = 0x132b000
brk(0x132c000)                          = 0x132c000
brk(0x132d000)                          = 0x132d000
brk(0x132e000)                          = 0x132e000
brk(0x132f000)                          = 0x132f000
brk(0x1330000)                          = 0x1330000
brk(0x1331000)                          = 0x1331000
brk(0x1332000)                          = 0x1332000
brk(0x1333000)                          = 0x1333000
brk(0x1334000)                          = 0x1334000
brk(0x1335000)                          = 0x1335000
brk(0x1336000)                          = 0x1336000
brk(0x1337000)                          = 0x1337000
brk(0x1338000)                          = 0x1338000
brk(0x1339000)                          = 0x1339000
brk(0x133a000)                          = 0x133a000
brk(0x133b000)                          = 0x133b000
brk(0x133c000)                          = 0x133c000
brk(0x133d000)                          = 0x133d000
brk(0x133e000)                          = 0x133e000
brk(0x133f000)                          = 0x133f000
brk(0x1340000)                          = 0x1340000
brk(0x1341000)                          = 0x1341000
brk(0x1342000)                          = 0x1342000
brk(0x1343000)                          = 0x1343000
brk(0x1344000)                          = 0x1344000
brk(0x1345000)                          = 0x1345000
brk(0x1346000)                          = 0x1346000
brk(0x1347000)                          = 0x1347000
brk(0x1348000)                          = 0x1348000
brk(0x1349000)                          = 0x1349000
brk(0x134a000)                          = 0x134a000
brk(0x134b000)                          = 0x134b000
brk(0x134c000)                          = 0x134c000
brk(0x134d000)                          = 0x134d000
brk(0x134e000)                          = 0x134e000
brk(0x134f000)                          = 0x134f000
brk(0x1350000)                          = 0x1350000
brk(0x1351000)                          = 0x1351000
brk(0x1352000)                          = 0x1352000
brk(0x1353000)                          = 0x1353000
brk(0x1354000)                          = 0x1354000
brk(0x1355000)                          = 0x1355000
brk(0x1356000)                          = 0x1356000
brk(0x1357000)                          = 0x1357000
brk(0x1358000)                          = 0x1358000
brk(0x1359000)                          = 0x1359000
brk(0x135a000)                          = 0x135a000
brk(0x135b000)                          = 0x135b000
brk(0x135c000)                          = 0x135c000
brk(0x135d000)                          = 0x135d000
brk(0x135e000)                          = 0x135e000
brk(0x135f000)                          = 0x135f000
brk(0x1360000)                          = 0x1360000
brk(0x1361000)                          = 0x1361000
brk(0x1362000)                          = 0x1362000
brk(0x1363000)                          = 0x1363000
brk(0x1364000)                          = 0x1364000
brk(0x1365000)                          = 0x1365000
brk(0x1366000)                          = 0x1366000
brk(0x1367000)                          = 0x1367000
brk(0x1368000)                          = 0x1368000
brk(0x1369000)                          = 0x1369000
brk(0x136a000)                          = 0x136a000
brk(0x136b000)                          = 0x136b000
brk(0x136c000)                          = 0x136c000
brk(0x136d000)                          = 0x136d000
brk(0x136e000)                          = 0x136e000
brk(0x136f000)                          = 0x136f000
brk(0x1370000)                          = 0x1370000
brk(0x1371000)                          = 0x1371000
brk(0x1372000)                          = 0x1372000
brk(0x1373000)                          = 0x1373000
brk(0x1374000)                          = 0x1374000
brk(0x1375000)                          = 0x1375000
brk(0x1376000)                          = 0x1376000
brk(0x1377000)                          = 0x1377000
brk(0x1378000)                          = 0x1378000
brk(0x1379000)                          = 0x1379000
brk(0x137a000)                          = 0x137a000
brk(0x137b000)                          = 0x137b000
brk(0x137c000)                          = 0x137c000
brk(0x137d000)                          = 0x137d000
brk(0x137e000)                          = 0x137e000
brk(0x137f000)                          = 0x137f000
brk(0x1380000)                          = 0x1380000
brk(0x1381000)                          = 0x1381000
brk(0x1382000)                          = 0x1382000
brk(0x1383000)                          = 0x1383000
brk(0x1384000)                          = 0x1384000
brk(0x1385000)                          = 0x1385000
brk(0x1386000)                          = 0x1386000
brk(0x1387000)                          = 0x1387000
brk(0x1388000)                          = 0x1388000
brk(0x1389000)                          = 0x1389000
brk(0x138a000)                          = 0x138a000
brk(0x138b000)                          = 0x138b000
brk(0x138c000)                          = 0x138c000
brk(0x138d000)                          = 0x138d000
brk(0x138e000)                          = 0x138e000
brk(0x138f000)                          = 0x138f000
brk(0x1390000)                          = 0x1390000
brk(0x1391000)                          = 0x1391000
brk(0x1392000)                          = 0x1392000
brk(0x1393000)                          = 0x1393000
brk(0x1394000)                          = 0x1394000
brk(0x1395000)                          = 0x1395000
brk(0x1396000)                          = 0x1396000
brk(0x1397000)                          = 0x1397000
brk(0x1398000)                          = 0x1398000
brk(0x1399000)                          = 0x1399000
brk(0x139a000)                          = 0x139a000
brk(0x139b000)                          = 0x139b000
brk(0x139c000)                          = 0x139c000
brk(0x139d000)                          = 0x139d000
brk(0x139e000)                          = 0x139e000
brk(0x139f000)                          = 0x139f000
brk(0x13a0000)                          = 0x13a0000
brk(0x13a1000)                          = 0x13a1000
brk(0x13a2000)                          = 0x13a2000
brk(0x13a3000)                          = 0x13a3000
brk(0x13a4000)                          = 0x13a4000
brk(0x13a5000)                          = 0x13a5000
brk(0x13a6000)                          = 0x13a6000
brk(0x13a7000)                          = 0x13a7000
brk(0x13a8000)                          = 0x13a8000
brk(0x13a9000)                          = 0x13a9000
brk(0x13aa000)                          = 0x13aa000
brk(0x13ab000)                          = 0x13ab000
brk(0x13ac000)                          = 0x13ac000
brk(0x13ad000)                          = 0x13ad000
brk(0x13ae000)                          = 0x13ae000
brk(0x13af000)                          = 0x13af000
brk(0x13b0000)                          = 0x13b0000
brk(0x13b1000)                          = 0x13b1000
brk(0x13b2000)                          = 0x13b2000
brk(0x13b3000)                          = 0x13b3000
brk(0x13b4000)                          = 0x13b4000
brk(0x13b5000)                          = 0x13b5000
brk(0x13b6000)                          = 0x13b6000
brk(0x13b7000)                          = 0x13b7000
brk(0x13b8000)                          = 0x13b8000
brk(0x13b9000)                          = 0x13b9000
brk(0x13ba000)                          = 0x13ba000
brk(0x13bb000)                          = 0x13bb000
brk(0x13bc000)                          = 0x13bc000
brk(0x13bd000)                          = 0x13bd000
brk(0x13be000)                          = 0x13be000
brk(0x13bf000)                          = 0x13bf000
brk(0x13c0000)                          = 0x13c0000
brk(0x13c1000)                          = 0x13c1000
brk(0x13c2000)                          = 0x13c2000
brk(0x13c3000)                          = 0x13c3000
brk(0x13c4000)                          = 0x13c4000
brk(0x13c5000)                          = 0x13c5000
brk(0x13c6000)                          = 0x13c6000
brk(0x13c7000)                          = 0x13c7000
brk(0x13c8000)                          = 0x13c8000
brk(0x13c9000)                          = 0x13c9000
brk(0x13ca000)                          = 0x13ca000
brk(0x13cb000)                          = 0x13cb000
brk(0x13cc000)                          = 0x13cc000
brk(0x13cd000)                          = 0x13cd000
brk(0x13ce000)                          = 0x13ce000
brk(0x13cf000)                          = 0x13cf000
brk(0x13d0000)                          = 0x13d0000
brk(0x13d1000)                          = 0x13d1000
brk(0x13d2000)                          = 0x13d2000
brk(0x13d3000)                          = 0x13d3000
brk(0x13d4000)                          = 0x13d4000
brk(0x13d5000)                          = 0x13d5000
brk(0x13d6000)                          = 0x13d6000
brk(0x13d7000)                          = 0x13d7000
brk(0x13d8000)                          = 0x13d8000
brk(0x13d9000)                          = 0x13d9000
brk(0x13da000)                          = 0x13da000
brk(0x13db000)                          = 0x13db000
brk(0x13dc000)                          = 0x13dc000
brk(0x13dd000)                          = 0x13dd000
brk(0x13de000)                          = 0x13de000
brk(0x13df000)                          = 0x13df000
brk(0x13e0000)                          = 0x13e0000
brk(0x13e1000)                          = 0x13e1000
brk(0x13e2000)                          = 0x13e2000
brk(0x13e3000)                          = 0x13e3000
brk(0x13e4000)                          = 0x13e4000
brk(0x13e5000)                          = 0x13e5000
brk(0x13e6000)                          = 0x13e6000
brk(0x13e7000)                          = 0x13e7000
brk(0x13e8000)                          = 0x13e8000
brk(0x13e9000)                          = 0x13e9000
brk(0x13ea000)                          = 0x13ea000
brk(0x13eb000)                          = 0x13eb000
brk(0x13ec000)                          = 0x13ec000
brk(0x13ed000)                          = 0x13ed000
brk(0x13ee000)                          = 0x13ee000
brk(0x13ef000)                          = 0x13ef000
brk(0x13f0000)                          = 0x13f0000
brk(0x13f1000)                          = 0x13f1000
brk(0x13f2000)                          = 0x13f2000
brk(0x13f3000)                          = 0x13f3000
brk(0x13f4000)                          = 0x13f4000
brk(0x13f5000)                          = 0x13f5000
brk(0x13f6000)                          = 0x13f6000
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2202
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2202, si_status=0, si_utime=0, si_stime=2} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2202
wait4(-1, 0x7ffd027adbd0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
brk(0x13f7000)                          = 0x13f7000
brk(0x13f8000)                          = 0x13f8000
brk(0x13f9000)                          = 0x13f9000
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2208
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "-t btrfs /dev/vdb /media/elena/T"..., 128) = 36
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2208, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2208
wait4(-1, 0x7ffd027ad550, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2213
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2213
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2213, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ad790, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2236
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "btrfs\n", 128)                 = 6
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2236, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2236
wait4(-1, 0x7ffd027adcd0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [CHLD], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2244
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(4)                                = 0
close(4)                                = -1 EBADF (Bad file descriptor)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [CHLD], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2245
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [CHLD], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2244
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], 0, NULL) = 2245
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(3)                                = -1 EBADF (Bad file descriptor)
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2244, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae110, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2246
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], 0, NULL) = 2246
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2246, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae210, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2247
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2247
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2247, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae7d0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
lseek(255, -7990, SEEK_CUR)             = 8347
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2248
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "0\n", 128)                     = 2
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2248
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2248, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae990, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
read(255, "\n_wipe_counters()\n{\n\tn_try=\"0\"\n\t"..., 8176) = 8176
brk(0x13fa000)                          = 0x13fa000
stat("/tmp/1993.arglist", {st_mode=S_IFREG|0644, st_size=16, ...}) = 0
stat(".", {st_mode=S_IFDIR|0775, st_size=4096, ...}) = 0
stat(".", {st_mode=S_IFDIR|0775, st_size=4096, ...}) = 0
stat("./cat", 0x7ffd027ae6c0)           = -1 ENOENT (No such file or directory)
stat("/usr/local/sbin/cat", 0x7ffd027ae6c0) = -1 ENOENT (No such file or directory)
stat("/usr/local/bin/cat", 0x7ffd027ae6c0) = -1 ENOENT (No such file or directory)
stat("/usr/sbin/cat", 0x7ffd027ae6c0)   = -1 ENOENT (No such file or directory)
stat("/usr/bin/cat", 0x7ffd027ae6c0)    = -1 ENOENT (No such file or directory)
stat("/sbin/cat", 0x7ffd027ae6c0)       = -1 ENOENT (No such file or directory)
stat("/bin/cat", {st_mode=S_IFREG|0755, st_size=52000, ...}) = 0
stat("/bin/cat", {st_mode=S_IFREG|0755, st_size=52000, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/cat", X_OK)                = 0
stat("/bin/cat", {st_mode=S_IFREG|0755, st_size=52000, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/cat", R_OK)                = 0
stat("/bin/cat", {st_mode=S_IFREG|0755, st_size=52000, ...}) = 0
stat("/bin/cat", {st_mode=S_IFREG|0755, st_size=52000, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/cat", X_OK)                = 0
stat("/bin/cat", {st_mode=S_IFREG|0755, st_size=52000, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/cat", R_OK)                = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
lseek(255, -6089, SEEK_CUR)             = 10434
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2249
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2249
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2249, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae310, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2250
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "tests/btrfs/078\n", 128)       = 16
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2250, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2250
wait4(-1, 0x7ffd027ae4d0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 16
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
stat("./rm", 0x7ffd027aeda0)            = -1 ENOENT (No such file or directory)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2253
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2253
rt_sigaction(SIGINT, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2253, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae910, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
read(255, "\nif $OPTIONS_HAVE_SECTIONS; then"..., 8176) = 7125
rt_sigaction(SIGHUP, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGINT, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGILL, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGTRAP, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGABRT, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGFPE, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGBUS, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGSEGV, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGSYS, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGPIPE, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGALRM, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGTERM, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGXCPU, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGXFSZ, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGVTALRM, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGUSR1, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGUSR2, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], 0}, 8) = 0
rt_sigaction(SIGHUP, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGHUP, {0x45f880, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_BLOCK, [HUP], [], 8) = 0
rt_sigaction(SIGHUP, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45f880, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT], [], 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [QUIT], [], 8) = 0
rt_sigaction(SIGQUIT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_IGN, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGTERM, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45f880, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGTERM, {0x45f880, [], SA_RESTORER, 0x7f8dd8e832f0}, {SIG_DFL, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_BLOCK, [TERM], [], 8) = 0
rt_sigaction(SIGTERM, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45f880, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
brk(0x13fb000)                          = 0x13fb000
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
brk(0x13fc000)                          = 0x13fc000
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
brk(0x13fd000)                          = 0x13fd000
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
brk(0x13fe000)                          = 0x13fe000
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
brk(0x13ff000)                          = 0x13ff000
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
brk(0x1400000)                          = 0x1400000
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
stat(".", {st_mode=S_IFDIR|0775, st_size=4096, ...}) = 0
stat(".", {st_mode=S_IFDIR|0775, st_size=4096, ...}) = 0
stat("./mkdir", 0x7ffd027ada90)         = -1 ENOENT (No such file or directory)
stat("/usr/local/sbin/mkdir", 0x7ffd027ada90) = -1 ENOENT (No such file or directory)
stat("/usr/local/bin/mkdir", 0x7ffd027ada90) = -1 ENOENT (No such file or directory)
stat("/usr/sbin/mkdir", 0x7ffd027ada90) = -1 ENOENT (No such file or directory)
stat("/usr/bin/mkdir", 0x7ffd027ada90)  = -1 ENOENT (No such file or directory)
stat("/sbin/mkdir", 0x7ffd027ada90)     = -1 ENOENT (No such file or directory)
stat("/bin/mkdir", {st_mode=S_IFREG|0755, st_size=80832, ...}) = 0
stat("/bin/mkdir", {st_mode=S_IFREG|0755, st_size=80832, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/mkdir", X_OK)              = 0
stat("/bin/mkdir", {st_mode=S_IFREG|0755, st_size=80832, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/mkdir", R_OK)              = 0
stat("/bin/mkdir", {st_mode=S_IFREG|0755, st_size=80832, ...}) = 0
stat("/bin/mkdir", {st_mode=S_IFREG|0755, st_size=80832, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/mkdir", X_OK)              = 0
stat("/bin/mkdir", {st_mode=S_IFREG|0755, st_size=80832, ...}) = 0
geteuid()                               = 0
getegid()                               = 0
getuid()                                = 0
getgid()                                = 0
access("/bin/mkdir", R_OK)              = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
lseek(255, -45, SEEK_CUR)               = 17514
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2254
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2254, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2254
wait4(-1, 0x7ffd027ad5d0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
stat("/home/elena/fstest/xfstests/results/", {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2255
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "btrfs\n", 128)                 = 6
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2255, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2255
wait4(-1, 0x7ffd027acf10, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 6
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2261
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "btrfs\n", 128)                 = 6
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2261, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2261
wait4(-1, 0x7ffd027ad010, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 6
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [CHLD], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2267
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(4)                                = 0
close(4)                                = -1 EBADF (Bad file descriptor)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [CHLD], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2268
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [CHLD], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2267
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], 0, NULL) = 2268
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(3)                                = -1 EBADF (Bad file descriptor)
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2267, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ad450, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2269
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 1}], 0, NULL) = 2269
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2269, si_status=1, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ad550, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
stat("./rm", 0x7ffd027ae270)            = -1 ENOENT (No such file or directory)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2270
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2270
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2270, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ade10, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
stat("/home/elena/fstest/xfstests/results//check.time", {st_mode=S_IFREG|0644, st_size=1939, ...}) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2271
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "btrfs\n", 128)                 = 6
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2271, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2271
wait4(-1, 0x7ffd027adcd0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 6
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
write(1, "FSTYP         -- btrfs\n", 23FSTYP         -- btrfs
) = 23
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2272
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "Linux/x86_64 elena-Standard-PC-i"..., 128) = 76
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2272, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2272
wait4(-1, 0x7ffd027addd0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 76
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
brk(0x1401000)                          = 0x1401000
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
write(1, "PLATFORM      -- Linux/x86_64 el"..., 93PLATFORM      -- Linux/x86_64 elena-Standard-PC-i440FX-PIIX-1996 4.10.0-next-20170228-custom
) = 93
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2281
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/dev/vdc\n", 128)              = 9
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2281
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2281, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027adb90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
write(1, "MKFS_OPTIONS  -- /dev/vdc\n", 26MKFS_OPTIONS  -- /dev/vdc
) = 26
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2282
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/dev/vdc /media/elena/SCRATCH\n", 128) = 30
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2282, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2282
wait4(-1, 0x7ffd027adcd0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 30
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
write(1, "MOUNT_OPTIONS -- /dev/vdc /media"..., 47MOUNT_OPTIONS -- /dev/vdc /media/elena/SCRATCH
) = 47
write(1, "\n", 1
)                       = 1
open("/dev/null", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 3
fcntl(2, F_GETFD)                       = 0
fcntl(2, F_DUPFD, 10)                   = 10
fcntl(2, F_GETFD)                       = 0
fcntl(10, F_SETFD, FD_CLOEXEC)          = 0
dup2(3, 2)                              = 2
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2284
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 32}], 0, NULL) = 2284
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2284, si_status=32, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ade10, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
dup2(10, 2)                             = 2
fcntl(10, F_GETFD)                      = 0x1 (flags FD_CLOEXEC)
close(10)                               = 0
open("/tmp/1993.err", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 3
fcntl(1, F_GETFD)                       = 0
fcntl(1, F_DUPFD, 10)                   = 10
fcntl(1, F_GETFD)                       = 0
fcntl(10, F_SETFD, FD_CLOEXEC)          = 0
dup2(3, 1)                              = 1
close(3)                                = 0
fcntl(2, F_GETFD)                       = 0
fcntl(2, F_DUPFD, 10)                   = 11
fcntl(2, F_GETFD)                       = 0
fcntl(11, F_SETFD, FD_CLOEXEC)          = 0
dup2(1, 2)                              = 2
fcntl(1, F_GETFD)                       = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2285
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/tmp/tmp.UGIYSjQdy0\n", 128)   = 20
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2285, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2285
wait4(-1, 0x7ffd027acf90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 20
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
open("/tmp/tmp.UGIYSjQdy0.mkfserr", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 3
fcntl(2, F_GETFD)                       = 0
fcntl(2, F_DUPFD, 10)                   = 12
fcntl(2, F_GETFD)                       = 0
fcntl(12, F_SETFD, FD_CLOEXEC)          = 0
dup2(3, 2)                              = 2
close(3)                                = 0
open("/tmp/tmp.UGIYSjQdy0.mkfsstd", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 3
fcntl(1, F_GETFD)                       = 0
fcntl(1, F_DUPFD, 10)                   = 13
fcntl(1, F_GETFD)                       = 0
fcntl(13, F_SETFD, FD_CLOEXEC)          = 0
dup2(3, 1)                              = 1
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, NULL, [], 8)  = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2286
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2286
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2286, si_status=0, si_utime=0, si_stime=1} ---
wait4(-1, 0x7ffd027acf90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
dup2(13, 1)                             = 1
fcntl(13, F_GETFD)                      = 0x1 (flags FD_CLOEXEC)
close(13)                               = 0
dup2(12, 2)                             = 2
fcntl(12, F_GETFD)                      = 0x1 (flags FD_CLOEXEC)
close(12)                               = 0
stat("./cat", 0x7ffd027ada30)           = -1 ENOENT (No such file or directory)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2287
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2287
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2287, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ad5d0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
fcntl(1, F_GETFD)                       = 0
fcntl(1, F_DUPFD, 10)                   = 12
fcntl(1, F_GETFD)                       = 0
fcntl(12, F_SETFD, FD_CLOEXEC)          = 0
dup2(2, 1)                              = 1
fcntl(2, F_GETFD)                       = 0
rt_sigprocmask(SIG_BLOCK, NULL, [], 8)  = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [CHLD], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2288
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(4)                                = 0
close(4)                                = -1 EBADF (Bad file descriptor)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [CHLD], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2289
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [CHLD], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2288
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2289
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
close(3)                                = -1 EBADF (Bad file descriptor)
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2288, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ad390, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
dup2(12, 1)                             = 1
fcntl(12, F_GETFD)                      = 0x1 (flags FD_CLOEXEC)
close(12)                               = 0
openat(AT_FDCWD, "/tmp/", O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC) = 3
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
brk(0x1411000)                          = 0x1411000
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
getdents(3, /* 18 entries */, 32768)    = 816
getdents(3, /* 0 entries */, 32768)     = 0
brk(0x1401000)                          = 0x1401000
close(3)                                = 0
stat("./rm", 0x7ffd027adc30)            = -1 ENOENT (No such file or directory)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2290
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2290
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2290, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ad7d0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
dup2(11, 2)                             = 2
fcntl(11, F_GETFD)                      = 0x1 (flags FD_CLOEXEC)
close(11)                               = 0
dup2(10, 1)                             = 1
fcntl(10, F_GETFD)                      = 0x1 (flags FD_CLOEXEC)
close(10)                               = 0
open("/tmp/1993.err", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 3
fcntl(1, F_GETFD)                       = 0
fcntl(1, F_DUPFD, 10)                   = 10
fcntl(1, F_GETFD)                       = 0
fcntl(10, F_SETFD, FD_CLOEXEC)          = 0
dup2(3, 1)                              = 1
close(3)                                = 0
fcntl(2, F_GETFD)                       = 0
fcntl(2, F_DUPFD, 10)                   = 11
fcntl(2, F_GETFD)                       = 0
fcntl(11, F_SETFD, FD_CLOEXEC)          = 0
dup2(1, 2)                              = 2
fcntl(1, F_GETFD)                       = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2291
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/dev/vdc /media/elena/SCRATCH\n", 128) = 30
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2291, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2291
wait4(-1, 0x7ffd027adc50, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 30
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2293
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "-t btrfs /dev/vdc /media/elena/S"..., 128) = 39
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2293, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2293
wait4(-1, 0x7ffd027ad950, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2298
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2298
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2298, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027adb90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
dup2(11, 2)                             = 2
fcntl(11, F_GETFD)                      = 0x1 (flags FD_CLOEXEC)
close(11)                               = 0
dup2(10, 1)                             = 1
fcntl(10, F_GETFD)                      = 0x1 (flags FD_CLOEXEC)
close(10)                               = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2323
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "btrfs\n", 128)                 = 6
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2323, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2323
wait4(-1, 0x7ffd027ad350, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2331
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/media/elena/TEST\n", 128)     = 18
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2331, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2331
wait4(-1, 0x7ffd027ad450, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 18
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
stat("/require_scratch.require_qgroup_report", 0x7ffd027adc90) = -1 ENOENT (No such file or directory)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2349
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2349
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2349, si_status=0, si_utime=0, si_stime=1} ---
wait4(-1, 0x7ffd027ada90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
stat("./rm", 0x7ffd027ae0f0)            = -1 ENOENT (No such file or directory)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2351
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2351
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2351, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027adc90, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2352
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "-t btrfs /dev/vdb /media/elena/T"..., 128) = 36
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2352, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2352
wait4(-1, 0x7ffd027acdd0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 36
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2358
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2358
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2358, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ad010, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
stat("tests/btrfs/078", {st_mode=S_IFREG|0775, st_size=2428, ...}) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2381
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "btrfs/078\n", 128)             = 10
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2381, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2381
wait4(-1, 0x7ffd027adbd0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
brk(0x1402000)                          = 0x1402000
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [], 8) = 0
brk(0x1403000)                          = 0x1403000
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2384
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "tests/btrfs\n", 128)           = 12
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2384, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2384
wait4(-1, 0x7ffd027adbd0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 12
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2385
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "/home/elena/fstest/xfstests/resu"..., 128) = 43
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2385, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2385
wait4(-1, 0x7ffd027adbd0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 43
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
stat("./mkdir", 0x7ffd027ae590)         = -1 ENOENT (No such file or directory)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2388
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2388
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2388, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ae110, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
write(1, "btrfs/078", 9btrfs/078)                = 9
stat("tests/btrfs/078", {st_mode=S_IFREG|0775, st_size=2428, ...}) = 0
stat("./rm", 0x7ffd027ad790)            = -1 ENOENT (No such file or directory)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2389
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2389
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2389, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ad310, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
stat("/tmp/1993.xlist", 0x7ffd027ad650) = -1 ENOENT (No such file or directory)
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2390
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2390, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2390
wait4(-1, 0x7ffd027ad110, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
write(1, "\t", 1	)                       = 1
stat("./rm", 0x7ffd027adab0)            = -1 ENOENT (No such file or directory)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2393
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2393
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2393, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ad650, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2394
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "1488790088\n", 128)            = 11
read(3, "", 128)                        = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2394, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG, NULL) = 2394
wait4(-1, 0x7ffd027ad410, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
faccessat(AT_FDCWD, "tests/btrfs/078", X_OK) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2396
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2396
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2396, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ada50, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
faccessat(AT_FDCWD, "/dev/kmsg", W_OK)  = 0
pipe([3, 4])                            = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2397
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigaction(SIGCHLD, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, {0x447990, [], SA_RESTORER|SA_RESTART, 0x7f8dd8e832f0}, 8) = 0
close(4)                                = 0
read(3, "2017-03-06 10:48:08\n", 128)   = 20
read(3, "", 128)                        = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2397
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2397, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ad4d0, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
open("/dev/kmsg", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 3
fcntl(1, F_GETFD)                       = 0
fcntl(1, F_DUPFD, 10)                   = 10
fcntl(1, F_GETFD)                       = 0
fcntl(10, F_SETFD, FD_CLOEXEC)          = 0
dup2(3, 1)                              = 1
close(3)                                = 0
write(1, "run fstests btrfs/078 at 2017-03"..., 45) = 45
dup2(10, 1)                             = 1
fcntl(10, F_GETFD)                      = 0x1 (flags FD_CLOEXEC)
close(10)                               = 0
stat("./touch", 0x7ffd027addd0)         = -1 ENOENT (No such file or directory)
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [INT CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [INT CHLD], NULL, 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2398
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 2398
rt_sigaction(SIGINT, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2398, si_status=0, si_utime=0, si_stime=0} ---
wait4(-1, 0x7ffd027ad950, WNOHANG, NULL) = -1 ECHILD (No child processes)
rt_sigreturn()                          = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f8dd984e9d0) = 2399
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGINT, {0x444870, [], SA_RESTORER, 0x7f8dd8e832f0}, {0x45c740, [], SA_RESTORER, 0x7f8dd8e832f0}, 8) = 0
wait4(-1, [

Re: [PATCH 00/17] fs, btrfs refcount conversions

[Qu Wenruo]

At 03/06/2017 05:43 PM, Reshetova, Elena wrote:
>
>> At 03/03/2017 04:55 PM, Elena Reshetova wrote:
>>> Now when new refcount_t type and API are finally merged
>>> (see include/linux/refcount.h), the following
>>> patches convert various refcounters in the btrfs filesystem from atomic_t
>>> to refcount_t. By doing this we prevent intentional or accidental
>>> underflows or overflows that can led to use-after-free vulnerabilities.
>>>
>>> The below patches are fully independent and can be cherry-picked separately.
>>> Since we convert all kernel subsystems in the same fashion, resulting
>>> in about 300 patches, we have to group them for sending at least in some
>>> fashion to be manageable. Please excuse the long cc list.
>>>
>>> These patches have been tested with xfstests by running btrfs-related tests.
>>> btrfs debug was enabled, warns on refcount errors, too. No output related to
>>> refcount errors produced. However, the following errors were during the run:
>>>  * tests btrfs/078, btrfs/114, btrfs/115, no errors anywhere in dmesg, but
>>>  process hangs. They all seem to be around qgroup, sometimes error visible
>>>  such as qgroup scan failed -4 before it blocks, but not always.
>>
>> How reproducible of the hang?
>
> Always in  my environment, but I would not much go into investigating why it happens, if it works for you.
> My test environment is far from ideal: I am testing in VM with rather old userspace and couple of additional changes in,
> so there are many things that can potentially go wrong. Anyway the strace for 078 is in the attachment.

Thanks for the strace.

However no "-f" is passed to strace, so it doesn't contain much useful info.

>
> If the patches pass all tests on your side, could you please take them in and propagate further?
> I will continue with other kernel subsystems.

The patchset itself looks like a common cleanup, while I did encounter 
several cases (almost all scrub tests) causing kernel warning due to 
underflow.

So I'm afraid the patchset will not be merged until we fix all the 
underflows.

But thanks for the patchset, it helps us to expose a lot of problem.

Thanks,
Qu

>
> Best Regards,
> Elena.
>
>
>>
>> I also see the -EINTR output, but that seems to be designed for
>> btrfs/11[45].
>>
>> btrfs/078 is unrelated to qgroup, and all these three test pass in my
>> test environment, which is v4.11-rc1 with your patches applied.
>>
>> I ran these 3 tests in a row with default and space_cache=v2 mount
>> options, and 5 times for each mount option, no hang at all.
>>
>> It would help much if more info can be provided, from blocked process
>> backtrace to test mount option to base commit.
>>
>> Thanks,
>> Qu
>>
>>>  * test btrfs/104 dmesg has additional error output:
>>>  BTRFS warning (device vdc): qgroup 258 reserved space underflow, have: 0,
>>>  to free: 4096
>>>  I tried looking at the code on what causes the failure, but could not figure
>>>  it out. It doesn't seem to be related to any refcount changes at least IMO.
>>>
>>> The above test failures are hard for me to understand and interpreted, but
>>> they don't seem to relate to refcount conversions.
>>>
>>> Elena Reshetova (17):
>>>   fs, btrfs: convert btrfs_bio.refs from atomic_t to refcount_t
>>>   fs, btrfs: convert btrfs_transaction.use_count from atomic_t to
>>>     refcount_t
>>>   fs, btrfs: convert extent_map.refs from atomic_t to refcount_t
>>>   fs, btrfs: convert btrfs_ordered_extent.refs from atomic_t to
>>>     refcount_t
>>>   fs, btrfs: convert btrfs_caching_control.count from atomic_t to
>>>     refcount_t
>>>   fs, btrfs: convert btrfs_delayed_ref_node.refs from atomic_t to
>>>     refcount_t
>>>   fs, btrfs: convert btrfs_delayed_node.refs from atomic_t to refcount_t
>>>   fs, btrfs: convert btrfs_delayed_item.refs from atomic_t to refcount_t
>>>   fs, btrfs: convert btrfs_root.refs from atomic_t to refcount_t
>>>   fs, btrfs: convert extent_state.refs from atomic_t to refcount_t
>>>   fs, btrfs: convert compressed_bio.pending_bios from atomic_t to
>>>     refcount_t
>>>   fs, btrfs: convert scrub_recover.refs from atomic_t to refcount_t
>>>   fs, btrfs: convert scrub_page.refs from atomic_t to refcount_t
>>>   fs, btrfs: convert scrub_block.refs from atomic_t to refcount_t
>>>   fs, btrfs: convert scrub_parity.refs from atomic_t to refcount_t
>>>   fs, btrfs: convert scrub_ctx.refs from atomic_t to refcount_t
>>>   fs, btrfs: convert btrfs_raid_bio.refs from atomic_t to refcount_t
>>>
>>>  fs/btrfs/backref.c           |  2 +-
>>>  fs/btrfs/compression.c       | 18 ++++++++---------
>>>  fs/btrfs/ctree.h             |  5 +++--
>>>  fs/btrfs/delayed-inode.c     | 46 ++++++++++++++++++++++----------------------
>>>  fs/btrfs/delayed-inode.h     |  5 +++--
>>>  fs/btrfs/delayed-ref.c       |  8 ++++----
>>>  fs/btrfs/delayed-ref.h       |  8 +++++---
>>>  fs/btrfs/disk-io.c           |  6 +++---
>>>  fs/btrfs/disk-io.h           |  4 ++--
>>>  fs/btrfs/extent-tree.c       | 20 +++++++++----------
>>>  fs/btrfs/extent_io.c         | 18 ++++++++---------
>>>  fs/btrfs/extent_io.h         |  3 ++-
>>>  fs/btrfs/extent_map.c        | 10 +++++-----
>>>  fs/btrfs/extent_map.h        |  3 ++-
>>>  fs/btrfs/ordered-data.c      | 20 +++++++++----------
>>>  fs/btrfs/ordered-data.h      |  2 +-
>>>  fs/btrfs/raid56.c            | 19 +++++++++---------
>>>  fs/btrfs/scrub.c             | 42 ++++++++++++++++++++--------------------
>>>  fs/btrfs/transaction.c       | 20 +++++++++----------
>>>  fs/btrfs/transaction.h       |  3 ++-
>>>  fs/btrfs/tree-log.c          |  2 +-
>>>  fs/btrfs/volumes.c           | 10 +++++-----
>>>  fs/btrfs/volumes.h           |  2 +-
>>>  include/trace/events/btrfs.h |  4 ++--
>>>  24 files changed, 143 insertions(+), 137 deletions(-)
>>>
>>
>
>
>

RE: [PATCH 00/17] fs, btrfs refcount conversions

[Reshetova, Elena]

> At 03/06/2017 05:43 PM, Reshetova, Elena wrote:
> >
> >> At 03/03/2017 04:55 PM, Elena Reshetova wrote:
> >>> Now when new refcount_t type and API are finally merged
> >>> (see include/linux/refcount.h), the following
> >>> patches convert various refcounters in the btrfs filesystem from atomic_t
> >>> to refcount_t. By doing this we prevent intentional or accidental
> >>> underflows or overflows that can led to use-after-free vulnerabilities.
> >>>
> >>> The below patches are fully independent and can be cherry-picked separately.
> >>> Since we convert all kernel subsystems in the same fashion, resulting
> >>> in about 300 patches, we have to group them for sending at least in some
> >>> fashion to be manageable. Please excuse the long cc list.
> >>>
> >>> These patches have been tested with xfstests by running btrfs-related tests.
> >>> btrfs debug was enabled, warns on refcount errors, too. No output related to
> >>> refcount errors produced. However, the following errors were during the run:
> >>>  * tests btrfs/078, btrfs/114, btrfs/115, no errors anywhere in dmesg, but
> >>>  process hangs. They all seem to be around qgroup, sometimes error visible
> >>>  such as qgroup scan failed -4 before it blocks, but not always.
> >>
> >> How reproducible of the hang?
> >
> > Always in  my environment, but I would not much go into investigating why it
> happens, if it works for you.
> > My test environment is far from ideal: I am testing in VM with rather old
> userspace and couple of additional changes in,
> > so there are many things that can potentially go wrong. Anyway the strace for
> 078 is in the attachment.
> 
> Thanks for the strace.
> 
> However no "-f" is passed to strace, so it doesn't contain much useful info.
> 
> >
> > If the patches pass all tests on your side, could you please take them in and
> propagate further?
> > I will continue with other kernel subsystems.
> 
> The patchset itself looks like a common cleanup, while I did encounter
> several cases (almost all scrub tests) causing kernel warning due to
> underflow.

Oh, could you please send me the warning outputs? I can hopefully analyze and fix them. 

Best Regards,
Elena.

> 
> So I'm afraid the patchset will not be merged until we fix all the
> underflows.
> 
> But thanks for the patchset, it helps us to expose a lot of problem.
> 
> Thanks,
> Qu
> 
> >
> > Best Regards,
> > Elena.
> >
> >
> >>
> >> I also see the -EINTR output, but that seems to be designed for
> >> btrfs/11[45].
> >>
> >> btrfs/078 is unrelated to qgroup, and all these three test pass in my
> >> test environment, which is v4.11-rc1 with your patches applied.
> >>
> >> I ran these 3 tests in a row with default and space_cache=v2 mount
> >> options, and 5 times for each mount option, no hang at all.
> >>
> >> It would help much if more info can be provided, from blocked process
> >> backtrace to test mount option to base commit.
> >>
> >> Thanks,
> >> Qu
> >>
> >>>  * test btrfs/104 dmesg has additional error output:
> >>>  BTRFS warning (device vdc): qgroup 258 reserved space underflow, have: 0,
> >>>  to free: 4096
> >>>  I tried looking at the code on what causes the failure, but could not figure
> >>>  it out. It doesn't seem to be related to any refcount changes at least IMO.
> >>>
> >>> The above test failures are hard for me to understand and interpreted, but
> >>> they don't seem to relate to refcount conversions.
> >>>
> >>> Elena Reshetova (17):
> >>>   fs, btrfs: convert btrfs_bio.refs from atomic_t to refcount_t
> >>>   fs, btrfs: convert btrfs_transaction.use_count from atomic_t to
> >>>     refcount_t
> >>>   fs, btrfs: convert extent_map.refs from atomic_t to refcount_t
> >>>   fs, btrfs: convert btrfs_ordered_extent.refs from atomic_t to
> >>>     refcount_t
> >>>   fs, btrfs: convert btrfs_caching_control.count from atomic_t to
> >>>     refcount_t
> >>>   fs, btrfs: convert btrfs_delayed_ref_node.refs from atomic_t to
> >>>     refcount_t
> >>>   fs, btrfs: convert btrfs_delayed_node.refs from atomic_t to refcount_t
> >>>   fs, btrfs: convert btrfs_delayed_item.refs from atomic_t to refcount_t
> >>>   fs, btrfs: convert btrfs_root.refs from atomic_t to refcount_t
> >>>   fs, btrfs: convert extent_state.refs from atomic_t to refcount_t
> >>>   fs, btrfs: convert compressed_bio.pending_bios from atomic_t to
> >>>     refcount_t
> >>>   fs, btrfs: convert scrub_recover.refs from atomic_t to refcount_t
> >>>   fs, btrfs: convert scrub_page.refs from atomic_t to refcount_t
> >>>   fs, btrfs: convert scrub_block.refs from atomic_t to refcount_t
> >>>   fs, btrfs: convert scrub_parity.refs from atomic_t to refcount_t
> >>>   fs, btrfs: convert scrub_ctx.refs from atomic_t to refcount_t
> >>>   fs, btrfs: convert btrfs_raid_bio.refs from atomic_t to refcount_t
> >>>
> >>>  fs/btrfs/backref.c           |  2 +-
> >>>  fs/btrfs/compression.c       | 18 ++++++++---------
> >>>  fs/btrfs/ctree.h             |  5 +++--
> >>>  fs/btrfs/delayed-inode.c     | 46 ++++++++++++++++++++++----------------------
> >>>  fs/btrfs/delayed-inode.h     |  5 +++--
> >>>  fs/btrfs/delayed-ref.c       |  8 ++++----
> >>>  fs/btrfs/delayed-ref.h       |  8 +++++---
> >>>  fs/btrfs/disk-io.c           |  6 +++---
> >>>  fs/btrfs/disk-io.h           |  4 ++--
> >>>  fs/btrfs/extent-tree.c       | 20 +++++++++----------
> >>>  fs/btrfs/extent_io.c         | 18 ++++++++---------
> >>>  fs/btrfs/extent_io.h         |  3 ++-
> >>>  fs/btrfs/extent_map.c        | 10 +++++-----
> >>>  fs/btrfs/extent_map.h        |  3 ++-
> >>>  fs/btrfs/ordered-data.c      | 20 +++++++++----------
> >>>  fs/btrfs/ordered-data.h      |  2 +-
> >>>  fs/btrfs/raid56.c            | 19 +++++++++---------
> >>>  fs/btrfs/scrub.c             | 42 ++++++++++++++++++++--------------------
> >>>  fs/btrfs/transaction.c       | 20 +++++++++----------
> >>>  fs/btrfs/transaction.h       |  3 ++-
> >>>  fs/btrfs/tree-log.c          |  2 +-
> >>>  fs/btrfs/volumes.c           | 10 +++++-----
> >>>  fs/btrfs/volumes.h           |  2 +-
> >>>  include/trace/events/btrfs.h |  4 ++--
> >>>  24 files changed, 143 insertions(+), 137 deletions(-)
> >>>
> >>
> >
> >
> >
> 

Re: [PATCH 00/17] fs, btrfs refcount conversions

[Qu Wenruo]

[-- Attachment #1: Type: text/plain, Size: 6569 bytes --]



At 03/07/2017 03:41 PM, Reshetova, Elena wrote:
>> At 03/06/2017 05:43 PM, Reshetova, Elena wrote:
>>>
>>>> At 03/03/2017 04:55 PM, Elena Reshetova wrote:
>>>>> Now when new refcount_t type and API are finally merged
>>>>> (see include/linux/refcount.h), the following
>>>>> patches convert various refcounters in the btrfs filesystem from atomic_t
>>>>> to refcount_t. By doing this we prevent intentional or accidental
>>>>> underflows or overflows that can led to use-after-free vulnerabilities.
>>>>>
>>>>> The below patches are fully independent and can be cherry-picked separately.
>>>>> Since we convert all kernel subsystems in the same fashion, resulting
>>>>> in about 300 patches, we have to group them for sending at least in some
>>>>> fashion to be manageable. Please excuse the long cc list.
>>>>>
>>>>> These patches have been tested with xfstests by running btrfs-related tests.
>>>>> btrfs debug was enabled, warns on refcount errors, too. No output related to
>>>>> refcount errors produced. However, the following errors were during the run:
>>>>>  * tests btrfs/078, btrfs/114, btrfs/115, no errors anywhere in dmesg, but
>>>>>  process hangs. They all seem to be around qgroup, sometimes error visible
>>>>>  such as qgroup scan failed -4 before it blocks, but not always.
>>>>
>>>> How reproducible of the hang?
>>>
>>> Always in  my environment, but I would not much go into investigating why it
>> happens, if it works for you.
>>> My test environment is far from ideal: I am testing in VM with rather old
>> userspace and couple of additional changes in,
>>> so there are many things that can potentially go wrong. Anyway the strace for
>> 078 is in the attachment.
>>
>> Thanks for the strace.
>>
>> However no "-f" is passed to strace, so it doesn't contain much useful info.
>>
>>>
>>> If the patches pass all tests on your side, could you please take them in and
>> propagate further?
>>> I will continue with other kernel subsystems.
>>
>> The patchset itself looks like a common cleanup, while I did encounter
>> several cases (almost all scrub tests) causing kernel warning due to
>> underflow.
>
> Oh, could you please send me the warning outputs? I can hopefully analyze and fix them.

Attached. Which is the generated by running btrfs/070 test case.
And I canceled the case almost instantly, so output is not much, but 
still contains enough info.

Both refcount_inc() and refcount_sub_and_test() are causing warning.

So now I'm not sure which is the cause, btrfs or bad use of refcount?

Thanks,
Qu

>
> Best Regards,
> Elena.
>
>>
>> So I'm afraid the patchset will not be merged until we fix all the
>> underflows.
>>
>> But thanks for the patchset, it helps us to expose a lot of problem.
>>
>> Thanks,
>> Qu
>>
>>>
>>> Best Regards,
>>> Elena.
>>>
>>>
>>>>
>>>> I also see the -EINTR output, but that seems to be designed for
>>>> btrfs/11[45].
>>>>
>>>> btrfs/078 is unrelated to qgroup, and all these three test pass in my
>>>> test environment, which is v4.11-rc1 with your patches applied.
>>>>
>>>> I ran these 3 tests in a row with default and space_cache=v2 mount
>>>> options, and 5 times for each mount option, no hang at all.
>>>>
>>>> It would help much if more info can be provided, from blocked process
>>>> backtrace to test mount option to base commit.
>>>>
>>>> Thanks,
>>>> Qu
>>>>
>>>>>  * test btrfs/104 dmesg has additional error output:
>>>>>  BTRFS warning (device vdc): qgroup 258 reserved space underflow, have: 0,
>>>>>  to free: 4096
>>>>>  I tried looking at the code on what causes the failure, but could not figure
>>>>>  it out. It doesn't seem to be related to any refcount changes at least IMO.
>>>>>
>>>>> The above test failures are hard for me to understand and interpreted, but
>>>>> they don't seem to relate to refcount conversions.
>>>>>
>>>>> Elena Reshetova (17):
>>>>>   fs, btrfs: convert btrfs_bio.refs from atomic_t to refcount_t
>>>>>   fs, btrfs: convert btrfs_transaction.use_count from atomic_t to
>>>>>     refcount_t
>>>>>   fs, btrfs: convert extent_map.refs from atomic_t to refcount_t
>>>>>   fs, btrfs: convert btrfs_ordered_extent.refs from atomic_t to
>>>>>     refcount_t
>>>>>   fs, btrfs: convert btrfs_caching_control.count from atomic_t to
>>>>>     refcount_t
>>>>>   fs, btrfs: convert btrfs_delayed_ref_node.refs from atomic_t to
>>>>>     refcount_t
>>>>>   fs, btrfs: convert btrfs_delayed_node.refs from atomic_t to refcount_t
>>>>>   fs, btrfs: convert btrfs_delayed_item.refs from atomic_t to refcount_t
>>>>>   fs, btrfs: convert btrfs_root.refs from atomic_t to refcount_t
>>>>>   fs, btrfs: convert extent_state.refs from atomic_t to refcount_t
>>>>>   fs, btrfs: convert compressed_bio.pending_bios from atomic_t to
>>>>>     refcount_t
>>>>>   fs, btrfs: convert scrub_recover.refs from atomic_t to refcount_t
>>>>>   fs, btrfs: convert scrub_page.refs from atomic_t to refcount_t
>>>>>   fs, btrfs: convert scrub_block.refs from atomic_t to refcount_t
>>>>>   fs, btrfs: convert scrub_parity.refs from atomic_t to refcount_t
>>>>>   fs, btrfs: convert scrub_ctx.refs from atomic_t to refcount_t
>>>>>   fs, btrfs: convert btrfs_raid_bio.refs from atomic_t to refcount_t
>>>>>
>>>>>  fs/btrfs/backref.c           |  2 +-
>>>>>  fs/btrfs/compression.c       | 18 ++++++++---------
>>>>>  fs/btrfs/ctree.h             |  5 +++--
>>>>>  fs/btrfs/delayed-inode.c     | 46 ++++++++++++++++++++++----------------------
>>>>>  fs/btrfs/delayed-inode.h     |  5 +++--
>>>>>  fs/btrfs/delayed-ref.c       |  8 ++++----
>>>>>  fs/btrfs/delayed-ref.h       |  8 +++++---
>>>>>  fs/btrfs/disk-io.c           |  6 +++---
>>>>>  fs/btrfs/disk-io.h           |  4 ++--
>>>>>  fs/btrfs/extent-tree.c       | 20 +++++++++----------
>>>>>  fs/btrfs/extent_io.c         | 18 ++++++++---------
>>>>>  fs/btrfs/extent_io.h         |  3 ++-
>>>>>  fs/btrfs/extent_map.c        | 10 +++++-----
>>>>>  fs/btrfs/extent_map.h        |  3 ++-
>>>>>  fs/btrfs/ordered-data.c      | 20 +++++++++----------
>>>>>  fs/btrfs/ordered-data.h      |  2 +-
>>>>>  fs/btrfs/raid56.c            | 19 +++++++++---------
>>>>>  fs/btrfs/scrub.c             | 42 ++++++++++++++++++++--------------------
>>>>>  fs/btrfs/transaction.c       | 20 +++++++++----------
>>>>>  fs/btrfs/transaction.h       |  3 ++-
>>>>>  fs/btrfs/tree-log.c          |  2 +-
>>>>>  fs/btrfs/volumes.c           | 10 +++++-----
>>>>>  fs/btrfs/volumes.h           |  2 +-
>>>>>  include/trace/events/btrfs.h |  4 ++--
>>>>>  24 files changed, 143 insertions(+), 137 deletions(-)
>>>>>
>>>>
>>>
>>>
>>>
>>
>
>
>



[-- Attachment #2: output --]
[-- Type: text/plain, Size: 27170 bytes --]

[17805.205289] run fstests btrfs/070 at 2017-03-07 14:02:47
[17805.765749] BTRFS: device fsid ef047ab3-6c98-4d0c-b76c-f10631b58a51 devid 1 transid 2 /dev/vdb6
[17805.776084] BTRFS: device fsid ef047ab3-6c98-4d0c-b76c-f10631b58a51 devid 2 transid 3 /dev/vdb7
[17805.779794] BTRFS: device fsid ef047ab3-6c98-4d0c-b76c-f10631b58a51 devid 3 transid 3 /dev/vdb8
[17805.783487] BTRFS: device fsid ef047ab3-6c98-4d0c-b76c-f10631b58a51 devid 4 transid 3 /dev/vdb9
[17806.124656] BTRFS info (device vdb9): disk space caching is enabled
[17806.125164] BTRFS info (device vdb9): has skinny extents
[17806.125528] BTRFS info (device vdb9): flagging fs with big metadata feature
[17806.129091] BTRFS info (device vdb9): creating UUID tree
[17807.145227] BTRFS info (device vdb9): dev_replace from /dev/vdb7 (devid 2) to /dev/vdb10 started
[17808.335771] ------------[ cut here ]------------
[17808.336144] WARNING: CPU: 0 PID: 9448 at lib/refcount.c:114 refcount_inc+0x27/0x30
[17808.336786] refcount_t: increment on 0; use-after-free.
[17808.337143] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.337753] CPU: 0 PID: 9448 Comm: btrfs Tainted: G        W  O    4.11.0-rc1+ #71
[17808.338134] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.338134] Call Trace:
[17808.338134]  dump_stack+0x68/0x93
[17808.338134]  __warn+0xcb/0xf0
[17808.338134]  warn_slowpath_fmt+0x4f/0x60
[17808.338134]  refcount_inc+0x27/0x30
[17808.338134]  scrub_pages+0x118/0x410 [btrfs]
[17808.338134]  scrub_stripe+0x851/0x1170 [btrfs]
[17808.338134]  ? trace_hardirqs_on+0xd/0x10
[17808.338134]  scrub_chunk+0x109/0x150 [btrfs]
[17808.338134]  scrub_enumerate_chunks+0x297/0x660 [btrfs]
[17808.338134]  btrfs_scrub_dev+0x1f6/0x670 [btrfs]
[17808.338134]  btrfs_dev_replace_start+0x2f1/0x4f0 [btrfs]
[17808.338134]  btrfs_dev_replace_by_ioctl+0x3e/0x70 [btrfs]
[17808.338134]  btrfs_ioctl+0x1e40/0x27f0 [btrfs]
[17808.338134]  ? do_sigaction+0x69/0x1b0
[17808.338134]  do_vfs_ioctl+0x94/0x710
[17808.338134]  ? do_sigaction+0x193/0x1b0
[17808.338134]  SyS_ioctl+0x79/0x90
[17808.338134]  entry_SYSCALL_64_fastpath+0x18/0xad
[17808.338134] RIP: 0033:0x7fe702de1787
[17808.338134] RSP: 002b:00007ffd3dbf0758 EFLAGS: 00000246 ORIG_RAX: 0000000000000010
[17808.338134] RAX: ffffffffffffffda RBX: 0000000000000003 RCX: 00007fe702de1787
[17808.338134] RDX: 00007ffd3dbf0b90 RSI: 00000000ca289435 RDI: 0000000000000003
[17808.338134] RBP: 0000000000000004 R08: 0000000000000000 R09: 0000000000000000
[17808.338134] R10: 00000000ffffffff R11: 0000000000000246 R12: 0000561120154050
[17808.338134] R13: 00007ffd3dbf2e6f R14: 0000000000000000 R15: 0000000000000001
[17808.347969] ---[ end trace 42fc4dedec8f6207 ]---
[17808.349374] ------------[ cut here ]------------
[17808.349716] WARNING: CPU: 0 PID: 9448 at lib/refcount.c:114 refcount_inc+0x27/0x30
[17808.351339] refcount_t: increment on 0; use-after-free.
[17808.351667] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.352383] CPU: 0 PID: 9448 Comm: btrfs Tainted: G        W  O    4.11.0-rc1+ #71
[17808.353121] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.353371] Call Trace:
[17808.353371]  dump_stack+0x68/0x93
[17808.353371]  __warn+0xcb/0xf0
[17808.353371]  warn_slowpath_fmt+0x4f/0x60
[17808.353371]  refcount_inc+0x27/0x30
[17808.355021]  scrub_pages+0x118/0x410 [btrfs]
[17808.355021]  scrub_stripe+0x851/0x1170 [btrfs]
[17808.355021]  ? trace_hardirqs_on+0xd/0x10
[17808.355021]  scrub_chunk+0x109/0x150 [btrfs]
[17808.355021]  scrub_enumerate_chunks+0x297/0x660 [btrfs]
[17808.359021]  btrfs_scrub_dev+0x1f6/0x670 [btrfs]
[17808.363022]  btrfs_dev_replace_start+0x2f1/0x4f0 [btrfs]
[17808.363022]  btrfs_dev_replace_by_ioctl+0x3e/0x70 [btrfs]
[17808.363022]  btrfs_ioctl+0x1e40/0x27f0 [btrfs]
[17808.363022]  ? do_sigaction+0x69/0x1b0
[17808.363022]  do_vfs_ioctl+0x94/0x710
[17808.363022]  ? do_sigaction+0x193/0x1b0
[17808.363022]  SyS_ioctl+0x79/0x90
[17808.363022]  entry_SYSCALL_64_fastpath+0x18/0xad
[17808.363022] RIP: 0033:0x7fe702de1787
[17808.363022] RSP: 002b:00007ffd3dbf0758 EFLAGS: 00000246 ORIG_RAX: 0000000000000010
[17808.363022] RAX: ffffffffffffffda RBX: 0000000000000003 RCX: 00007fe702de1787
[17808.367025] RDX: 00007ffd3dbf0b90 RSI: 00000000ca289435 RDI: 0000000000000003
[17808.367025] RBP: 0000000000000004 R08: 0000000000000000 R09: 0000000000000000
[17808.367025] R10: 00000000ffffffff R11: 0000000000000246 R12: 0000561120154050
[17808.367025] R13: 00007ffd3dbf2e6f R14: 0000000000000000 R15: 0000000000000001
[17808.369634] ---[ end trace 42fc4dedec8f6208 ]---
[17808.375435] ------------[ cut here ]------------
[17808.381855] WARNING: CPU: 0 PID: 9448 at lib/refcount.c:114 refcount_inc+0x27/0x30
[17808.385910] refcount_t: increment on 0; use-after-free.
[17808.387980] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.388588] CPU: 0 PID: 9448 Comm: btrfs Tainted: G        W  O    4.11.0-rc1+ #71
[17808.389166] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.389578] Call Trace:
[17808.389865]  dump_stack+0x68/0x93
[17808.389865]  __warn+0xcb/0xf0
[17808.389865]  warn_slowpath_fmt+0x4f/0x60
[17808.389865]  refcount_inc+0x27/0x30
[17808.389865]  scrub_pages+0x118/0x410 [btrfs]
[17808.389865]  scrub_stripe+0x851/0x1170 [btrfs]
[17808.389865]  ? trace_hardirqs_on+0xd/0x10
[17808.389865]  scrub_chunk+0x109/0x150 [btrfs]
[17808.389865]  scrub_enumerate_chunks+0x297/0x660 [btrfs]
[17808.389865]  btrfs_scrub_dev+0x1f6/0x670 [btrfs]
[17808.389865]  btrfs_dev_replace_start+0x2f1/0x4f0 [btrfs]
[17808.389865]  btrfs_dev_replace_by_ioctl+0x3e/0x70 [btrfs]
[17808.389865]  btrfs_ioctl+0x1e40/0x27f0 [btrfs]
[17808.389865]  ? do_sigaction+0x69/0x1b0
[17808.389865]  do_vfs_ioctl+0x94/0x710
[17808.389865]  ? do_sigaction+0x193/0x1b0
[17808.389865]  SyS_ioctl+0x79/0x90
[17808.389865]  entry_SYSCALL_64_fastpath+0x18/0xad
[17808.389865] RIP: 0033:0x7fe702de1787
[17808.389865] RSP: 002b:00007ffd3dbf0758 EFLAGS: 00000246 ORIG_RAX: 0000000000000010
[17808.389865] RAX: ffffffffffffffda RBX: 0000000000000003 RCX: 00007fe702de1787
[17808.389865] RDX: 00007ffd3dbf0b90 RSI: 00000000ca289435 RDI: 0000000000000003
[17808.389865] RBP: 0000000000000004 R08: 0000000000000000 R09: 0000000000000000
[17808.389865] R10: 00000000ffffffff R11: 0000000000000246 R12: 0000561120154050
[17808.389865] R13: 00007ffd3dbf2e6f R14: 0000000000000000 R15: 0000000000000001
[17808.401890] ---[ end trace 42fc4dedec8f6209 ]---
[17808.402282] ------------[ cut here ]------------
[17808.402623] WARNING: CPU: 0 PID: 9448 at lib/refcount.c:114 refcount_inc+0x27/0x30
[17808.403358] refcount_t: increment on 0; use-after-free.
[17808.403701] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.404494] CPU: 0 PID: 9448 Comm: btrfs Tainted: G        W  O    4.11.0-rc1+ #71
[17808.405069] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.405455] Call Trace:
[17808.405455]  dump_stack+0x68/0x93
[17808.405455]  __warn+0xcb/0xf0
[17808.405455]  warn_slowpath_fmt+0x4f/0x60
[17808.405455]  refcount_inc+0x27/0x30
[17808.405455]  scrub_pages+0x118/0x410 [btrfs]
[17808.405455]  scrub_stripe+0x851/0x1170 [btrfs]
[17808.405455]  ? trace_hardirqs_on+0xd/0x10
[17808.405455]  scrub_chunk+0x109/0x150 [btrfs]
[17808.405455]  scrub_enumerate_chunks+0x297/0x660 [btrfs]
[17808.405455]  btrfs_scrub_dev+0x1f6/0x670 [btrfs]
[17808.405455]  btrfs_dev_replace_start+0x2f1/0x4f0 [btrfs]
[17808.405455]  btrfs_dev_replace_by_ioctl+0x3e/0x70 [btrfs]
[17808.405455]  btrfs_ioctl+0x1e40/0x27f0 [btrfs]
[17808.405455]  ? do_sigaction+0x69/0x1b0
[17808.405455]  do_vfs_ioctl+0x94/0x710
[17808.405455]  ? do_sigaction+0x193/0x1b0
[17808.405455]  SyS_ioctl+0x79/0x90
[17808.405455]  entry_SYSCALL_64_fastpath+0x18/0xad
[17808.405455] RIP: 0033:0x7fe702de1787
[17808.405455] RSP: 002b:00007ffd3dbf0758 EFLAGS: 00000246 ORIG_RAX: 0000000000000010
[17808.405455] RAX: ffffffffffffffda RBX: 0000000000000003 RCX: 00007fe702de1787
[17808.405455] RDX: 00007ffd3dbf0b90 RSI: 00000000ca289435 RDI: 0000000000000003
[17808.405455] RBP: 0000000000000004 R08: 0000000000000000 R09: 0000000000000000
[17808.405455] R10: 00000000ffffffff R11: 0000000000000246 R12: 0000561120154050
[17808.405455] R13: 00007ffd3dbf2e6f R14: 0000000000000000 R15: 0000000000000001
[17808.415683] ---[ end trace 42fc4dedec8f620a ]---
[17808.416261] ------------[ cut here ]------------
[17808.417080] WARNING: CPU: 1 PID: 9508 at lib/refcount.c:114 refcount_inc+0x27/0x30
[17808.417824] refcount_t: increment on 0; use-after-free.
[17808.418425] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.419194] CPU: 1 PID: 9508 Comm: kworker/u4:6 Tainted: G        W  O    4.11.0-rc1+ #71
[17808.419932] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.420179] Workqueue: btrfs-scrub btrfs_scrub_helper [btrfs]
[17808.420179] Call Trace:
[17808.420179]  dump_stack+0x68/0x93
[17808.420179]  __warn+0xcb/0xf0
[17808.420179]  ? scrub_workers_put+0x80/0x80 [btrfs]
[17808.420179]  warn_slowpath_fmt+0x4f/0x60
[17808.420179]  refcount_inc+0x27/0x30
[17808.420179]  scrub_write_page_to_dev_replace+0x1a1/0x2a0 [btrfs]
[17808.420179]  scrub_write_block_to_dev_replace+0x40/0x60 [btrfs]
[17808.420179]  scrub_bio_end_io_worker+0x36a/0x520 [btrfs]
[17808.420179]  ? debug_object_deactivate+0x56/0x130
[17808.420179]  btrfs_scrubparity_helper+0xef/0x620 [btrfs]
[17808.420179]  btrfs_scrub_helper+0xe/0x10 [btrfs]
[17808.420179]  process_one_work+0x2af/0x720
[17808.420179]  ? process_one_work+0x22b/0x720
[17808.420179]  worker_thread+0x4b/0x4f0
[17808.420179]  kthread+0x10f/0x150
[17808.420179]  ? process_one_work+0x720/0x720
[17808.420179]  ? kthread_create_on_node+0x40/0x40
[17808.420179]  ret_from_fork+0x2e/0x40
[17808.427447] ---[ end trace 42fc4dedec8f620b ]---
[17808.428357] ------------[ cut here ]------------
[17808.428828] WARNING: CPU: 1 PID: 9508 at lib/refcount.c:114 refcount_inc+0x27/0x30
[17808.429542] refcount_t: increment on 0; use-after-free.
[17808.430117] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.430766] CPU: 1 PID: 9508 Comm: kworker/u4:6 Tainted: G        W  O    4.11.0-rc1+ #71
[17808.431012] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.431012] Workqueue: btrfs-scrub btrfs_scrub_helper [btrfs]
[17808.431012] Call Trace:
[17808.431012]  dump_stack+0x68/0x93
[17808.431012]  __warn+0xcb/0xf0
[17808.431012]  ? scrub_workers_put+0x80/0x80 [btrfs]
[17808.431012]  warn_slowpath_fmt+0x4f/0x60
[17808.431012]  refcount_inc+0x27/0x30
[17808.431012]  scrub_write_page_to_dev_replace+0x1a1/0x2a0 [btrfs]
[17808.431012]  scrub_write_block_to_dev_replace+0x40/0x60 [btrfs]
[17808.436040]  scrub_bio_end_io_worker+0x36a/0x520 [btrfs]
[17808.436040]  ? debug_object_deactivate+0x56/0x130
[17808.436040]  btrfs_scrubparity_helper+0xef/0x620 [btrfs]
[17808.436040]  btrfs_scrub_helper+0xe/0x10 [btrfs]
[17808.436040]  process_one_work+0x2af/0x720
[17808.436040]  ? process_one_work+0x22b/0x720
[17808.436040]  worker_thread+0x4b/0x4f0
[17808.436040]  kthread+0x10f/0x150
[17808.436040]  ? process_one_work+0x720/0x720
[17808.436040]  ? kthread_create_on_node+0x40/0x40
[17808.436040]  ret_from_fork+0x2e/0x40
[17808.440016] ---[ end trace 42fc4dedec8f620c ]---
[17808.440464] ------------[ cut here ]------------
[17808.440951] WARNING: CPU: 1 PID: 9508 at lib/refcount.c:114 refcount_inc+0x27/0x30
[17808.441632] refcount_t: increment on 0; use-after-free.
[17808.442151] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.442884] CPU: 1 PID: 9508 Comm: kworker/u4:6 Tainted: G        W  O    4.11.0-rc1+ #71
[17808.443033] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.443033] Workqueue: btrfs-scrub btrfs_scrub_helper [btrfs]
[17808.443033] Call Trace:
[17808.443033]  dump_stack+0x68/0x93
[17808.443033]  __warn+0xcb/0xf0
[17808.443033]  ? scrub_workers_put+0x80/0x80 [btrfs]
[17808.443033]  warn_slowpath_fmt+0x4f/0x60
[17808.443033]  refcount_inc+0x27/0x30
[17808.443033]  scrub_write_page_to_dev_replace+0x1a1/0x2a0 [btrfs]
[17808.443033]  scrub_write_block_to_dev_replace+0x40/0x60 [btrfs]
[17808.443033]  scrub_bio_end_io_worker+0x36a/0x520 [btrfs]
[17808.443033]  ? debug_object_deactivate+0x56/0x130
[17808.443033]  btrfs_scrubparity_helper+0xef/0x620 [btrfs]
[17808.443033]  btrfs_scrub_helper+0xe/0x10 [btrfs]
[17808.443033]  process_one_work+0x2af/0x720
[17808.443033]  ? process_one_work+0x22b/0x720
[17808.443033]  worker_thread+0x4b/0x4f0
[17808.443033]  kthread+0x10f/0x150
[17808.443033]  ? process_one_work+0x720/0x720
[17808.443033]  ? kthread_create_on_node+0x40/0x40
[17808.443033]  ret_from_fork+0x2e/0x40
[17808.456507] ---[ end trace 42fc4dedec8f620d ]---
[17808.457696] ------------[ cut here ]------------
[17808.457998] WARNING: CPU: 1 PID: 9508 at lib/refcount.c:114 refcount_inc+0x27/0x30
[17808.458681] refcount_t: increment on 0; use-after-free.
[17808.459075] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.459685] CPU: 1 PID: 9508 Comm: kworker/u4:6 Tainted: G        W  O    4.11.0-rc1+ #71
[17808.460006] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.460006] Workqueue: btrfs-scrub btrfs_scrub_helper [btrfs]
[17808.460006] Call Trace:
[17808.460006]  dump_stack+0x68/0x93
[17808.460006]  __warn+0xcb/0xf0
[17808.460006]  ? scrub_workers_put+0x80/0x80 [btrfs]
[17808.460006]  warn_slowpath_fmt+0x4f/0x60
[17808.460006]  refcount_inc+0x27/0x30
[17808.460006]  scrub_write_page_to_dev_replace+0x1a1/0x2a0 [btrfs]
[17808.460006]  scrub_write_block_to_dev_replace+0x40/0x60 [btrfs]
[17808.460006]  scrub_bio_end_io_worker+0x36a/0x520 [btrfs]
[17808.460006]  ? debug_object_deactivate+0x56/0x130
[17808.460006]  btrfs_scrubparity_helper+0xef/0x620 [btrfs]
[17808.460006]  btrfs_scrub_helper+0xe/0x10 [btrfs]
[17808.460006]  process_one_work+0x2af/0x720
[17808.460006]  ? process_one_work+0x22b/0x720
[17808.460006]  worker_thread+0x4b/0x4f0
[17808.460006]  kthread+0x10f/0x150
[17808.460006]  ? process_one_work+0x720/0x720
[17808.460006]  ? kthread_create_on_node+0x40/0x40
[17808.460006]  ret_from_fork+0x2e/0x40
[17808.467673] ---[ end trace 42fc4dedec8f620e ]---
[17808.469434] ------------[ cut here ]------------
[17808.469913] WARNING: CPU: 1 PID: 9508 at lib/refcount.c:128 refcount_sub_and_test+0x60/0x70
[17808.470600] refcount_t: underflow; use-after-free.
[17808.471125] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.471836] CPU: 1 PID: 9508 Comm: kworker/u4:6 Tainted: G        W  O    4.11.0-rc1+ #71
[17808.472005] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.472005] Workqueue: btrfs-scrub btrfs_scrub_helper [btrfs]
[17808.472005] Call Trace:
[17808.472005]  dump_stack+0x68/0x93
[17808.472005]  __warn+0xcb/0xf0
[17808.472005]  warn_slowpath_fmt+0x4f/0x60
[17808.472005]  ? scrub_workers_put+0x80/0x80 [btrfs]
[17808.472005]  refcount_sub_and_test+0x60/0x70
[17808.472005]  refcount_dec_and_test+0x11/0x20
[17808.472005]  scrub_page_put+0x16/0x40 [btrfs]
[17808.472005]  scrub_block_put+0x5a/0x80 [btrfs]
[17808.472005]  scrub_bio_end_io_worker+0x77/0x520 [btrfs]
[17808.472005]  ? debug_object_deactivate+0x56/0x130
[17808.472005]  btrfs_scrubparity_helper+0xef/0x620 [btrfs]
[17808.472005]  btrfs_scrub_helper+0xe/0x10 [btrfs]
[17808.472005]  process_one_work+0x2af/0x720
[17808.472005]  ? process_one_work+0x22b/0x720
[17808.472005]  worker_thread+0x4b/0x4f0
[17808.472005]  kthread+0x10f/0x150
[17808.472005]  ? process_one_work+0x720/0x720
[17808.472005]  ? kthread_create_on_node+0x40/0x40
[17808.472005]  ret_from_fork+0x2e/0x40
[17808.479703] ---[ end trace 42fc4dedec8f620f ]---
[17808.480326] ------------[ cut here ]------------
[17808.480875] WARNING: CPU: 1 PID: 9508 at lib/refcount.c:128 refcount_sub_and_test+0x60/0x70
[17808.481584] refcount_t: underflow; use-after-free.
[17808.481885] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.482802] CPU: 1 PID: 9508 Comm: kworker/u4:6 Tainted: G        W  O    4.11.0-rc1+ #71
[17808.483383] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.483680] Workqueue: btrfs-scrub btrfs_scrub_helper [btrfs]
[17808.483680] Call Trace:
[17808.483680]  dump_stack+0x68/0x93
[17808.483680]  __warn+0xcb/0xf0
[17808.483680]  warn_slowpath_fmt+0x4f/0x60
[17808.483680]  ? scrub_workers_put+0x80/0x80 [btrfs]
[17808.483680]  refcount_sub_and_test+0x60/0x70
[17808.483680]  refcount_dec_and_test+0x11/0x20
[17808.483680]  scrub_page_put+0x16/0x40 [btrfs]
[17808.483680]  scrub_block_put+0x5a/0x80 [btrfs]
[17808.487038]  scrub_bio_end_io_worker+0x77/0x520 [btrfs]
[17808.487038]  ? debug_object_deactivate+0x56/0x130
[17808.487038]  btrfs_scrubparity_helper+0xef/0x620 [btrfs]
[17808.487038]  btrfs_scrub_helper+0xe/0x10 [btrfs]
[17808.487038]  process_one_work+0x2af/0x720
[17808.487038]  ? process_one_work+0x22b/0x720
[17808.487038]  worker_thread+0x4b/0x4f0
[17808.487038]  kthread+0x10f/0x150
[17808.487038]  ? process_one_work+0x720/0x720
[17808.487038]  ? kthread_create_on_node+0x40/0x40
[17808.487038]  ret_from_fork+0x2e/0x40
[17808.490757] ---[ end trace 42fc4dedec8f6210 ]---
[17808.491117] ------------[ cut here ]------------
[17808.491448] WARNING: CPU: 1 PID: 9508 at lib/refcount.c:128 refcount_sub_and_test+0x60/0x70
[17808.492062] refcount_t: underflow; use-after-free.
[17808.492393] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.493053] CPU: 1 PID: 9508 Comm: kworker/u4:6 Tainted: G        W  O    4.11.0-rc1+ #71
[17808.493648] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.494030] Workqueue: btrfs-scrub btrfs_scrub_helper [btrfs]
[17808.494030] Call Trace:
[17808.494030]  dump_stack+0x68/0x93
[17808.494030]  __warn+0xcb/0xf0
[17808.494030]  warn_slowpath_fmt+0x4f/0x60
[17808.494030]  ? scrub_workers_put+0x80/0x80 [btrfs]
[17808.494030]  refcount_sub_and_test+0x60/0x70
[17808.494030]  refcount_dec_and_test+0x11/0x20
[17808.494030]  scrub_page_put+0x16/0x40 [btrfs]
[17808.494030]  scrub_block_put+0x5a/0x80 [btrfs]
[17808.494030]  scrub_bio_end_io_worker+0x77/0x520 [btrfs]
[17808.494030]  ? debug_object_deactivate+0x56/0x130
[17808.494030]  btrfs_scrubparity_helper+0xef/0x620 [btrfs]
[17808.494030]  btrfs_scrub_helper+0xe/0x10 [btrfs]
[17808.494030]  process_one_work+0x2af/0x720
[17808.494030]  ? process_one_work+0x22b/0x720
[17808.494030]  worker_thread+0x4b/0x4f0
[17808.494030]  kthread+0x10f/0x150
[17808.494030]  ? process_one_work+0x720/0x720
[17808.494030]  ? kthread_create_on_node+0x40/0x40
[17808.494030]  ret_from_fork+0x2e/0x40
[17808.501354] ---[ end trace 42fc4dedec8f6211 ]---
[17808.502677] ------------[ cut here ]------------
[17808.503040] WARNING: CPU: 1 PID: 9508 at lib/refcount.c:128 refcount_sub_and_test+0x60/0x70
[17808.503639] refcount_t: underflow; use-after-free.
[17808.503954] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.504592] CPU: 1 PID: 9508 Comm: kworker/u4:6 Tainted: G        W  O    4.11.0-rc1+ #71
[17808.505187] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.505569] Workqueue: btrfs-scrub btrfs_scrub_helper [btrfs]
[17808.505569] Call Trace:
[17808.505569]  dump_stack+0x68/0x93
[17808.505569]  __warn+0xcb/0xf0
[17808.505569]  warn_slowpath_fmt+0x4f/0x60
[17808.505569]  ? scrub_workers_put+0x80/0x80 [btrfs]
[17808.505569]  refcount_sub_and_test+0x60/0x70
[17808.505569]  refcount_dec_and_test+0x11/0x20
[17808.505569]  scrub_page_put+0x16/0x40 [btrfs]
[17808.505569]  scrub_block_put+0x5a/0x80 [btrfs]
[17808.505569]  scrub_bio_end_io_worker+0x77/0x520 [btrfs]
[17808.505569]  ? debug_object_deactivate+0x56/0x130
[17808.505569]  btrfs_scrubparity_helper+0xef/0x620 [btrfs]
[17808.505569]  btrfs_scrub_helper+0xe/0x10 [btrfs]
[17808.505569]  process_one_work+0x2af/0x720
[17808.505569]  ? process_one_work+0x22b/0x720
[17808.505569]  worker_thread+0x4b/0x4f0
[17808.505569]  kthread+0x10f/0x150
[17808.505569]  ? process_one_work+0x720/0x720
[17808.505569]  ? kthread_create_on_node+0x40/0x40
[17808.505569]  ret_from_fork+0x2e/0x40
[17808.512438] ---[ end trace 42fc4dedec8f6212 ]---
[17808.512962] ------------[ cut here ]------------
[17808.513288] WARNING: CPU: 1 PID: 9508 at lib/refcount.c:128 refcount_sub_and_test+0x60/0x70
[17808.513895] refcount_t: underflow; use-after-free.
[17808.514241] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.514865] CPU: 1 PID: 9508 Comm: kworker/u4:6 Tainted: G        W  O    4.11.0-rc1+ #71
[17808.515220] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.515220] Workqueue: btrfs-scrubwrc btrfs_scrubwrc_helper [btrfs]
[17808.515220] Call Trace:
[17808.515220]  dump_stack+0x68/0x93
[17808.515220]  __warn+0xcb/0xf0
[17808.515220]  warn_slowpath_fmt+0x4f/0x60
[17808.515220]  ? debug_object_deactivate+0x56/0x130
[17808.515220]  refcount_sub_and_test+0x60/0x70
[17808.515220]  refcount_dec_and_test+0x11/0x20
[17808.515220]  scrub_page_put+0x16/0x40 [btrfs]
[17808.515220]  scrub_wr_bio_end_io_worker+0x93/0xe0 [btrfs]
[17808.515220]  btrfs_scrubparity_helper+0xef/0x620 [btrfs]
[17808.515220]  btrfs_scrubwrc_helper+0xe/0x10 [btrfs]
[17808.515220]  process_one_work+0x2af/0x720
[17808.515220]  ? process_one_work+0x22b/0x720
[17808.515220]  worker_thread+0x4b/0x4f0
[17808.515220]  kthread+0x10f/0x150
[17808.515220]  ? process_one_work+0x720/0x720
[17808.515220]  ? kthread_create_on_node+0x40/0x40
[17808.515220]  ret_from_fork+0x2e/0x40
[17808.528894] ---[ end trace 42fc4dedec8f6213 ]---
[17808.529383] ------------[ cut here ]------------
[17808.529760] WARNING: CPU: 1 PID: 9508 at lib/refcount.c:128 refcount_sub_and_test+0x60/0x70
[17808.530390] refcount_t: underflow; use-after-free.
[17808.530718] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.531354] CPU: 1 PID: 9508 Comm: kworker/u4:6 Tainted: G        W  O    4.11.0-rc1+ #71
[17808.531961] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.532329] Workqueue: btrfs-scrubwrc btrfs_scrubwrc_helper [btrfs]
[17808.532329] Call Trace:
[17808.532329]  dump_stack+0x68/0x93
[17808.532329]  __warn+0xcb/0xf0
[17808.532329]  warn_slowpath_fmt+0x4f/0x60
[17808.532329]  ? debug_object_deactivate+0x56/0x130
[17808.532329]  refcount_sub_and_test+0x60/0x70
[17808.532329]  refcount_dec_and_test+0x11/0x20
[17808.532329]  scrub_page_put+0x16/0x40 [btrfs]
[17808.532329]  scrub_wr_bio_end_io_worker+0x93/0xe0 [btrfs]
[17808.532329]  btrfs_scrubparity_helper+0xef/0x620 [btrfs]
[17808.532329]  btrfs_scrubwrc_helper+0xe/0x10 [btrfs]
[17808.532329]  process_one_work+0x2af/0x720
[17808.532329]  ? process_one_work+0x22b/0x720
[17808.532329]  worker_thread+0x4b/0x4f0
[17808.532329]  kthread+0x10f/0x150
[17808.532329]  ? process_one_work+0x720/0x720
[17808.538039]  ? kthread_create_on_node+0x40/0x40
[17808.538039]  ret_from_fork+0x2e/0x40
[17808.538830] ---[ end trace 42fc4dedec8f6214 ]---
[17808.539179] ------------[ cut here ]------------
[17808.539520] WARNING: CPU: 1 PID: 9508 at lib/refcount.c:128 refcount_sub_and_test+0x60/0x70
[17808.540144] refcount_t: underflow; use-after-free.
[17808.540472] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.541110] CPU: 1 PID: 9508 Comm: kworker/u4:6 Tainted: G        W  O    4.11.0-rc1+ #71
[17808.541704] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.542087] Workqueue: btrfs-scrubwrc btrfs_scrubwrc_helper [btrfs]
[17808.542087] Call Trace:
[17808.542087]  dump_stack+0x68/0x93
[17808.542087]  __warn+0xcb/0xf0
[17808.542087]  warn_slowpath_fmt+0x4f/0x60
[17808.542087]  ? debug_object_deactivate+0x56/0x130
[17808.542087]  refcount_sub_and_test+0x60/0x70
[17808.542087]  refcount_dec_and_test+0x11/0x20
[17808.542087]  scrub_page_put+0x16/0x40 [btrfs]
[17808.542087]  scrub_wr_bio_end_io_worker+0x93/0xe0 [btrfs]
[17808.542087]  btrfs_scrubparity_helper+0xef/0x620 [btrfs]
[17808.542087]  btrfs_scrubwrc_helper+0xe/0x10 [btrfs]
[17808.542087]  process_one_work+0x2af/0x720
[17808.542087]  ? process_one_work+0x22b/0x720
[17808.542087]  worker_thread+0x4b/0x4f0
[17808.542087]  kthread+0x10f/0x150
[17808.542087]  ? process_one_work+0x720/0x720
[17808.542087]  ? kthread_create_on_node+0x40/0x40
[17808.542087]  ret_from_fork+0x2e/0x40
[17808.548374] ---[ end trace 42fc4dedec8f6215 ]---
[17808.548700] ------------[ cut here ]------------
[17808.549074] WARNING: CPU: 1 PID: 9508 at lib/refcount.c:128 refcount_sub_and_test+0x60/0x70
[17808.549702] refcount_t: underflow; use-after-free.
[17808.550101] Modules linked in: btrfs(O) ext4 jbd2 mbcache xor raid6_pq netconsole xfs [last unloaded: btrfs]
[17808.550726] CPU: 1 PID: 9508 Comm: kworker/u4:6 Tainted: G        W  O    4.11.0-rc1+ #71
[17808.551079] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.1-20161122_114906-anatol 04/01/2014
[17808.551079] Workqueue: btrfs-scrubwrc btrfs_scrubwrc_helper [btrfs]
[17808.551079] Call Trace:
[17808.551079]  dump_stack+0x68/0x93
[17808.551079]  __warn+0xcb/0xf0
[17808.551079]  warn_slowpath_fmt+0x4f/0x60
[17808.551079]  ? debug_object_deactivate+0x56/0x130
[17808.551079]  refcount_sub_and_test+0x60/0x70
[17808.551079]  refcount_dec_and_test+0x11/0x20
[17808.551079]  scrub_page_put+0x16/0x40 [btrfs]
[17808.551079]  scrub_wr_bio_end_io_worker+0x93/0xe0 [btrfs]
[17808.551079]  btrfs_scrubparity_helper+0xef/0x620 [btrfs]
[17808.551079]  btrfs_scrubwrc_helper+0xe/0x10 [btrfs]
[17808.551079]  process_one_work+0x2af/0x720
[17808.551079]  ? process_one_work+0x22b/0x720
[17808.551079]  worker_thread+0x4b/0x4f0
[17808.551079]  kthread+0x10f/0x150
[17808.551079]  ? process_one_work+0x720/0x720
[17808.551079]  ? kthread_create_on_node+0x40/0x40
[17808.551079]  ret_from_fork+0x2e/0x40
[17808.559351] ---[ end trace 42fc4dedec8f6216 ]---
[17809.477360] BTRFS info (device vdb9): dev_replace from /dev/vdb7 (devid 2) to /dev/vdb10 finished
[17810.229098] BTRFS info (device vdb9): dev_replace from /dev/vdb8 (devid 3) to /dev/vdb7 started
[17810.518980] BTRFS info (device vdb9): dev_replace from /dev/vdb8 (devid 3) to /dev/vdb7 finished

Re: [PATCH 00/17] fs, btrfs refcount conversions

[David Sterba]

On Tue, Mar 07, 2017 at 03:49:52PM +0800, Qu Wenruo wrote:
> >>> If the patches pass all tests on your side, could you please take them in and
> >> propagate further?
> >>> I will continue with other kernel subsystems.
> >>
> >> The patchset itself looks like a common cleanup, while I did encounter
> >> several cases (almost all scrub tests) causing kernel warning due to
> >> underflow.
> >
> > Oh, could you please send me the warning outputs? I can hopefully analyze and fix them.
> 
> Attached. Which is the generated by running btrfs/070 test case.
> And I canceled the case almost instantly, so output is not much, but 
> still contains enough info.
> 
> Both refcount_inc() and refcount_sub_and_test() are causing warning.
> 
> So now I'm not sure which is the cause, btrfs or bad use of refcount?

We we do atomic_inc to get the first reference after initialization in
scrub_pages, instead of atomic_set (or an equivalent):

2266                 spage = kzalloc(sizeof(*spage), GFP_KERNEL);
2267                 if (!spage) {
...
2274                 }
...
2276                 scrub_page_get(spage);

so the references are 0 and refcount_inc will catch that, the fix is simple.

The refcount_sub_and_test reports seem to catch a bug in refcounting, I'm
analyzing it right now.

Re: [PATCH 00/17] fs, btrfs refcount conversions

[David Sterba]

On Fri, Mar 03, 2017 at 10:55:09AM +0200, Elena Reshetova wrote:
> Now when new refcount_t type and API are finally merged
> (see include/linux/refcount.h), the following
> patches convert various refcounters in the btrfs filesystem from atomic_t
> to refcount_t. By doing this we prevent intentional or accidental
> underflows or overflows that can led to use-after-free vulnerabilities.
> 
> The below patches are fully independent and can be cherry-picked separately.
> Since we convert all kernel subsystems in the same fashion, resulting
> in about 300 patches, we have to group them for sending at least in some
> fashion to be manageable. Please excuse the long cc list.

Thanks, the patchset looks good to me, I'm going to add it to the 4.12 queue.

> These patches have been tested with xfstests by running btrfs-related tests.
> btrfs debug was enabled, warns on refcount errors, too. No output related to
> refcount errors produced. However, the following errors were during the run:
>  * tests btrfs/078, btrfs/114, btrfs/115, no errors anywhere in dmesg, but
>  process hangs. They all seem to be around qgroup, sometimes error visible
>  such as qgroup scan failed -4 before it blocks, but not always.
>  * test btrfs/104 dmesg has additional error output:
>  BTRFS warning (device vdc): qgroup 258 reserved space underflow, have: 0,
>  to free: 4096
>  I tried looking at the code on what causes the failure, but could not figure
>  it out. It doesn't seem to be related to any refcount changes at least IMO.
> 
> The above test failures are hard for me to understand and interpreted, but
> they don't seem to relate to refcount conversions.

I don't think they're related to the refcount updates so we'll address
them.

RE: [PATCH 00/17] fs, btrfs refcount conversions

[Reshetova, Elena]

> On Fri, Mar 03, 2017 at 10:55:09AM +0200, Elena Reshetova wrote:
> > Now when new refcount_t type and API are finally merged
> > (see include/linux/refcount.h), the following
> > patches convert various refcounters in the btrfs filesystem from atomic_t
> > to refcount_t. By doing this we prevent intentional or accidental
> > underflows or overflows that can led to use-after-free vulnerabilities.
> >
> > The below patches are fully independent and can be cherry-picked separately.
> > Since we convert all kernel subsystems in the same fashion, resulting
> > in about 300 patches, we have to group them for sending at least in some
> > fashion to be manageable. Please excuse the long cc list.
> 
> Thanks, the patchset looks good to me, I'm going to add it to the 4.12 queue.

Thank you very much!

> 
> > These patches have been tested with xfstests by running btrfs-related tests.
> > btrfs debug was enabled, warns on refcount errors, too. No output related to
> > refcount errors produced. However, the following errors were during the run:
> >  * tests btrfs/078, btrfs/114, btrfs/115, no errors anywhere in dmesg, but
> >  process hangs. They all seem to be around qgroup, sometimes error visible
> >  such as qgroup scan failed -4 before it blocks, but not always.
> >  * test btrfs/104 dmesg has additional error output:
> >  BTRFS warning (device vdc): qgroup 258 reserved space underflow, have: 0,
> >  to free: 4096
> >  I tried looking at the code on what causes the failure, but could not figure
> >  it out. It doesn't seem to be related to any refcount changes at least IMO.
> >
> > The above test failures are hard for me to understand and interpreted, but
> > they don't seem to relate to refcount conversions.
> 
> I don't think they're related to the refcount updates so we'll address
> them.