lib: add safe_pthread_create() & safe_pthread_join()

testcases/kernel/syscalls/fcntl/fcntl34.c new file +75 -0

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <pthread.h>
+
+#include "lapi/fcntl.h"
+#include "tst_test.h"
+
+static int thread_cnt;
+static const int max_thread_cnt = 32;
+static const char fname[] = "tst_ofd_locks";
+const int writes_num = 100;
+const int write_size = 4096;
+
+static void setup(void)
+{
+	thread_cnt = tst_ncpus_conf() * 3;
+	if (thread_cnt > max_thread_cnt)
+		thread_cnt = max_thread_cnt;
+}
+
+static void spawn_threads(pthread_t *id, void *(*thread_fn)(void *))
+{
+	intptr_t i;
+
+	tst_res(TINFO, "spawning '%d' threads", thread_cnt);
+	for (i = 0; i < thread_cnt; ++i)
+		SAFE_PTHREAD_CREATE(id + i, NULL, thread_fn, (void *)i);
+}
+
+static void wait_threads(pthread_t *id)
+{
+	int i;
+
+	tst_res(TINFO, "waiting for '%d' threads", thread_cnt);
+	for (i = 0; i < thread_cnt; ++i)
+		SAFE_PTHREAD_JOIN(id[i], NULL);
+}
+
+void *thread_fn_01(void *arg)
+{
+	int i;
+	char buf[write_size];
+	int fd = SAFE_OPEN(fname, O_RDWR);
+
+	memset(buf, (intptr_t)arg, write_size);
+
+	struct flock lck = {
+		.l_whence = SEEK_SET,
+		.l_start  = 0,
+		.l_len    = 1,
+	};
+
+	for (i = 0; i < writes_num; ++i) {
+		lck.l_type = F_WRLCK;
+		if (fcntl(fd, F_OFD_SETLKW, &lck) == -1)
+			tst_brk(TBROK | TERRNO, "fcntl() failed");
+
+		SAFE_LSEEK(fd, 0, SEEK_END);
+		SAFE_WRITE(1, fd, buf, write_size);
+
+		lck.l_type = F_UNLCK;
+		if (fcntl(fd, F_OFD_SETLKW, &lck) == -1)
+			tst_brk(TBROK | TERRNO, "fcntl() failed");
+
+		pthread_yield();
+	}
+
+	SAFE_CLOSE(fd);
+
+	return NULL;
+}
+
+static void test01(void)

OFD lock is available since Linux 3.15 and new F_OFD_* macros added to lapi/fcntl.h

Test is based on [1] article and checks that OFD locks can syncronise access to a file between multiple threads.

[1] https://lwn.net/Articles/586904

Hi!

lib/safe_pthread.c line 50

Quoted 11 lines

lib/safe_pthread.c new file +11 -0

+int safe_pthread_join(const char *file, const int lineno,
+		      pthread_t thread_id, void **retval)
+{
+	int rval;
+
+	rval = pthread_join(thread_id, retval);
+
+	if (rval) {
+		tst_brk_(file, lineno, TBROK,
+			 "pthread_join(%lu,%p) failed: %s", thread_id, retval,
+			 tst_strerrno(rval));

Technically the thread_id does not need to be numeric type, POSIX defines it as a opaque, may be structure as well.

But on the other hand I doubt that there is a Linux libc implementation that actually defines it to be anything else than long int.

lib/safe_pthread.c line 38

Quoted 4 lines

lib/safe_pthread.c new file +4 -0

+	}
+
+	return rval;
+}

Otherwise this looks fine.

Quoted 2 lines

Technically the thread_id does not need to be numeric type, POSIX defines it as a opaque, may be structure as well.

We could print in hex like this:

if (rval) {
     unsigned int i;
     unsigned char *ptr = (unsigned char *)&thread_id;
     size_t tid_size = sizeof(thread_id);
     char buf[tid_size * 2 + 1];

     for (i = 0; i < tid_size; ++i)
         sprintf(buf + i * 2, "%02x", ptr[i]);

     tst_brk_(file, lineno, TBROK,
              "pthread_join(%s,%p) failed: %s", buf, retval, ...);
}

But bytes might be in different order due to endianness, supposing we compare this value with "%lx", e.g. on x86_64

00971fe3257f0000 vs 7f25e31f9700 (%lx)

What do you think?

Hi!

Quoted 20 lines

Quoted 2 lines

Technically the thread_id does not need to be numeric type, POSIX defines it as a opaque, may be structure as well.

We could print in hex like this:

if (rval) {
      unsigned int i;
      unsigned char *ptr = (unsigned char *)&thread_id;
      size_t tid_size = sizeof(thread_id);
      char buf[tid_size * 2 + 1];

      for (i = 0; i < tid_size; ++i)
          sprintf(buf + i * 2, "%02x", ptr[i]);

      tst_brk_(file, lineno, TBROK,
               "pthread_join(%s,%p) failed: %s", buf, retval, ...);
}

But bytes might be in different order due to endianness, supposing we compare this value with "%lx", e.g. on x86_64

Quoted 3 lines

00971fe3257f0000 vs 7f25e31f9700 (%lx)

What do you think?

I'm starting to consider not printing the value at all, since it's not that important as gdb and strace pthread ids are not related to the value of pthread_t. We can just print "pthread_join(..., %p)" instead.

Or we can add a configure check if pthread_t is actually numeric. Something as:

	pthread_t *t = (unsigned long*)NULL;

Should fail with -Werror unless pthread_t is defined as unsigned long.

Then we can proceed with printing it with "%ul" if the check was OK, but I'm not sure that it's worth of the work.