btrfs-progs: add Android compatibility code

Previous Android compatibility was removed in 51f15d3
("btrfs-progs: build: remove incomplete android support").

- add pthread_cancel() API stubs and pthread_setcanceltype() emulation,
  since Android NDK does not support it, use pthread_kill() instead

- add manual thread state tracking to 'rescue chunk-recover' command
  using atomics; code is from termux/termux-packages

- add stub for qsort_r() using tread-local storage

The compatibility code is in common/compat.h and should be include unles
the internal APIs include that already (like sort-utils.h or
task-utils.h).

The CI does not yet verify the Android build yet.

Pull-request: #982
Signed-off-by: Shadichy <shadichy@blisslabs.org>
Signed-off-by: David Sterba <dsterba@suse.com>

Author: shadichy

Makefile

@@ -216,6 +216,7 @@ objects = \
 	kernel-shared/volumes.o	\
 	kernel-shared/zoned.o	\
 	common/array.o		\
+	common/compat.o		\
 	common/cpu-utils.o	\
 	common/device-scan.o	\
 	common/device-utils.o	\

cmds/rescue-chunk-recover.c

@@ -37,12 +37,17 @@
 #include "kernel-shared/transaction.h"
 #include "kernel-shared/extent_io.h"
 #include "common/internal.h"
+#include "common/compat.h"
 #include "common/messages.h"
 #include "common/extent-cache.h"
 #include "common/utils.h"
 #include "cmds/rescue.h"
 #include "check/common.h"
 
+#ifdef __ANDROID__
+#include <stdatomic.h>
+#endif
+
 struct recover_control {
 	int verbose;
 	int yes;
@@ -82,6 +87,9 @@ struct device_scan {
 	struct btrfs_device *dev;
 	int fd;
 	u64 bytenr;
+#ifdef __ANDROID__
+	atomic_flag thread_running;
+#endif
 };
 
 static struct extent_record *btrfs_new_extent_record(struct extent_buffer *eb)
@@ -761,8 +769,12 @@ static int scan_one_device(void *dev_scan_struct)
 		return 1;
 
 	buf = malloc(sizeof(*buf) + rc->nodesize);
-	if (!buf)
+	if (!buf) {
+#ifdef __ANDROID__
+		atomic_flag_clear(&dev_scan->thread_running);
+#endif
 		return -ENOMEM;
+	}
 	buf->len = rc->nodesize;
 
 	bytenr = 0;
@@ -823,6 +835,9 @@ static int scan_one_device(void *dev_scan_struct)
 out:
 	close(fd);
 	free(buf);
+#ifdef __ANDROID__
+	atomic_flag_clear(&dev_scan->thread_running);
+#endif
 	return ret;
 }
 
@@ -869,6 +884,9 @@ static int scan_devices(struct recover_control *rc)
 		dev_scans[devidx].dev = dev;
 		dev_scans[devidx].fd = fd;
 		dev_scans[devidx].bytenr = -1;
+#ifdef __ANDROID__
+		atomic_flag_test_and_set(&dev_scans[devidx].thread_running);
+#endif
 		devidx++;
 	}
 
@@ -887,8 +905,15 @@ static int scan_devices(struct recover_control *rc)
 		for (i = 0; i < devidx; i++) {
 			if (dev_scans[i].bytenr == -1)
 				continue;
+#ifdef __ANDROID__
+			if (atomic_flag_test_and_set(&dev_scans[i].thread_running))
+				ret = EBUSY;
+			else
+				ret = pthread_join(t_scans[i], (void **)&t_rets[i]);
+#else
 			ret = pthread_tryjoin_np(t_scans[i],
 						 (void **)&t_rets[i]);
+#endif
 			if (ret == EBUSY) {
 				all_done = false;
 				continue;

cmds/scrub.c

@@ -45,6 +45,7 @@
 #include "kernel-lib/sizes.h"
 #include "kernel-shared/volumes.h"
 #include "common/defs.h"
+#include "common/compat.h"
 #include "common/messages.h"
 #include "common/utils.h"
 #include "common/open-utils.h"

common/compat.c

@@ -0,0 +1,94 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include <string.h>
+#include <signal.h>
+#include <stdlib.h>
+#include "common/compat.h"
+
+#ifdef __ANDROID__
+
+/*
+ * Workaround for pthread_cancel() in Android, using pthread_kill() instead, as
+ * Android NDK does not support pthread_cancel().
+ */
+
+int pthread_setcanceltype(int type, int *oldtype) { return 0; }
+
+int pthread_setcancelstate(int state, int *oldstate) { return 0; }
+
+int pthread_cancel(pthread_t thread_id) {
+	int status;
+
+	status = btrfs_set_thread_exit_handler();
+	if (status == 0)
+		status = pthread_kill(thread_id, SIGUSR1);
+
+	return status;
+}
+
+void btrfs_thread_exit_handler(int sig) {
+	pthread_exit(0);
+}
+
+int btrfs_set_thread_exit_handler() {
+	struct sigaction actions;
+
+	memset(&actions, 0, sizeof(actions));
+	sigemptyset(&actions.sa_mask);
+	actions.sa_flags = 0;
+	actions.sa_handler = btrfs_thread_exit_handler;
+
+	return sigaction(SIGUSR1, &actions, NULL);
+}
+
+struct qsort_r_context {
+	int (*compare)(const void *a, const void *b, void *context);
+	void *arg;
+};
+
+#if __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)
+static _Thread_local struct qsort_r_context *qsort_r_ctx = NULL;
+#else
+static __thread struct qsort_r_context *qsort_r_ctx = NULL;
+#endif
+
+static int qsort_r_stub_compare(const void *a, const void *b)
+{
+	return qsort_r_ctx->compare(a, b, qsort_r_ctx->arg);
+}
+
+void qsort_r(void *base, size_t nel, size_t width,
+	     int (*compare)(const void *a, const void *b, void *context),
+	     void *arg)
+{
+	struct qsort_r_context ctx;
+	struct qsort_r_context *old_ctx;
+
+	if (nel == 0)
+		return;
+
+	ctx.compare = compare;
+	ctx.arg = arg;
+	old_ctx = qsort_r_ctx;
+	qsort_r_ctx = &ctx;
+	qsort(base, nel, width, qsort_r_stub_compare);
+
+	/* Restore the old context after qsort is finished. */
+	qsort_r_ctx = old_ctx;
+}
+
+#endif

common/compat.h

@@ -0,0 +1,65 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#ifndef __BTRFS_COMPAT_H__
+#define __BTRFS_COMPAT_H__
+
+#ifdef __ANDROID__
+
+#include <pthread.h>
+
+/*
+ * Add missing pthread related definitions in Android.
+ */
+
+#define PTHREAD_CANCELED			((void *)-1)
+
+#define PTHREAD_CANCEL_DEFERRED			0
+#define PTHREAD_CANCEL_ASYNCHRONOUS		0
+#define PTHREAD_CANCEL_ENABLE			0
+#define PTHREAD_CANCEL_DISABLE			0
+
+int pthread_setcanceltype(int type, int *oldtype);
+int pthread_setcancelstate(int state, int *oldstate);
+int pthread_cancel(pthread_t thread_id);
+
+int btrfs_set_thread_exit_handler();
+void btrfs_thread_exit_handler(int sig);
+
+/**
+ * @brief A compatible implementation of the GNU C Library (Glibc) qsort_r.
+ *
+ * Sorts an array using the quicksort algorithm. This function is thread-safe
+ * by allowing a custom context pointer (arg) to be passed to the comparison
+ * function.
+ *
+ * @param base    A pointer to the first element of the array to be sorted.
+ * @param nel     The number of elements in the array.
+ * @param width   The size in bytes of each element in the array.
+ * @param compare The comparison function, which takes two elements and a context
+ *                pointer. The function must return:
+ *                - A negative integer if the first element is less than the second.
+ *                - Zero if the elements are equal.
+ *                - A positive integer if the first element is greater than the second.
+ * @param arg     The custom pointer passed to the comparison function.
+ */
+void qsort_r(void *base, size_t nel, size_t width,
+	     int (*compare)(const void *a, const void *b, void *context),
+	     void *arg);
+
+#endif
+
+#endif

common/sort-utils.h

@@ -18,6 +18,7 @@
 #define __COMMON_SORT_UTILS_H__
 
 #include <stdbool.h>
+#include "common/compat.h"
 
 /*
  * Example:

common/task-utils.c

@@ -20,6 +20,7 @@
 #include <unistd.h>
 #include <time.h>
 #include "common/task-utils.h"
+#include "common/compat.h"
 
 struct task_info *task_init(void *(*threadfn)(void *), int (*postfn)(void *),
 			    void *thread_private)