[PATCH v6] tests/fcntl.c: add test for print_f_owner_ex

[Dmitry V. Levin]

On Mon, Apr 16, 2018 at 04:23:18PM +0800, Zhibin Li wrote:
> *tests/fcntl.c (test_f_owner_ex_type_pid)
> (test_f_owner_ex_umove, test_f_owner_ex_printaddr)
> (test_f_owner_ex): New functions.
> (main): Use test_f_owner_ex.
> ---
>  tests/fcntl.c | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 55 insertions(+)
> 
> diff --git a/tests/fcntl.c b/tests/fcntl.c
> index 4f62ca2a..3a7d243d 100644
> --- a/tests/fcntl.c
> +++ b/tests/fcntl.c
> @@ -69,12 +69,67 @@ test_flock64(void)
>  #endif
>  }
>  
> +static long
> +test_f_owner_ex_type_pid(const int cmd, const char *const cmd_name,
> +			 const int type, const char *const type_name,
> +			 const pid_t pid)
> +{
> +	TAIL_ALLOC_OBJECT_CONST_PTR(struct f_owner_ex, fo);
> +	fo->type = type;
> +	fo->pid = pid;
> +
> +	long rc = invoke_test_syscall(cmd, fo);
> +	printf("%s(0, %s, {type=%s, pid=%d}) = %s\n",
> +	       TEST_SYSCALL_STR, cmd_name, type_name, pid, sprintrc(rc));
> +	return rc;
> +}
> +
> +static void
> +test_f_owner_ex_umove(const int type, const char *const type_name, pid_t pid)
> +{
> +	long rc = test_f_owner_ex_type_pid(ARG_STR(F_SETOWN_EX),
> +					   type, type_name, pid);
> +	if (!rc)
> +		test_f_owner_ex_type_pid(ARG_STR(F_GETOWN_EX),
> +					 type, type_name, pid);
> +}
> +
> +static void
> +test_f_owner_ex_printaddr(const int cmd, const char *const cmd_name)
> +{
> +	TAIL_ALLOC_OBJECT_CONST_PTR(struct f_owner_ex, fo);
> +
> +	long rc = invoke_test_syscall(cmd, fo+1ULL);
> +	printf("%s(0, %s, %p) = %s\n",
> +	       TEST_SYSCALL_STR, cmd_name, fo+1ULL, sprintrc(rc));

I think this test could be done inside test_f_owner_ex_type_pid.

(fo + 1) will point to inaccessible memory.
If the purpose of this test is to check partial read,
then it should rather be (uinptr_t) fo + 1.

Anyway, there is no need for ULL suffix.

> +}
> +
> +static void
> +test_f_owner_ex(void)
> +{
> +	unsigned int i;
> +	unsigned int j;
> +	unsigned int k = 0;
> +	const int type[] = { F_OWNER_TID, F_OWNER_PID, F_OWNER_PGRP };
> +	const char *type_name[] = { "F_OWNER_TID", "F_OWNER_PID", "F_OWNER_PGRP" };
> +	const int pid[] = { 1234567890, 1298126790, 1294567890, 20, 30, 40 };
> +
> +	for (i = 0; i < 2; i++) {
> +		for (j = 0; j < ARRAY_SIZE(type); j++) {
> +			test_f_owner_ex_umove(type[j], type_name[j], pid[k++]);
> +		}
> +	}

The idea is to reduce redundancy, I'm not sure this edition with loops
implements it well enough.

What do you think about this (completely untested) approach:

	static const struct {
		int arg;
		const char *str;
		pid_t pid[2];
	} a[] = {
		{ ARG_STR(F_OWNER_TID), { 1234567890, 20 } },
		{ ARG_STR(F_OWNER_PID), { 1298126790, 30 } },
		{ ARG_STR(F_OWNER_PGRP), { 1294567890, 40 } }
	};

	for (int i = 0; i < ARRAY_SIZE(a); ++i)
		for (int j = 0; j < ARRAY_SIZE(a[0].pid); ++j)
			test_f_owner_ex_umove(a[i].arg, a[i].str, a[i].pid[j]);
	

-- 
ldv
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 801 bytes
Desc: not available
URL: <http://lists.strace.io/pipermail/strace-devel/attachments/20180416/4b43a34b/attachment.bin>