/*
 * Copyright © 2014 Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 *
 * Authors:
 *    Daniel Vetter <daniel.vetter@ffwll.ch>
 */

#include "igt.h"
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <drm.h>
#include <i915_drm.h>
#include <xf86drm.h>
#include <intel_bufmgr.h>
#include <errno.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/syscall.h>


int fd;
drm_intel_bufmgr *bufmgr;
int fd1;
drm_intel_bufmgr *bufmgr1;

bool use_flink;

static void new_buffers(void)
{
	unsigned int *buf1;
	drm_intel_bo *bo1, *bo2;


	bo1 = drm_intel_bo_alloc(bufmgr, "buf1",16384, 4096);
	igt_assert(bo1);
	drm_intel_bo_map(bo1, 1);
	bo2 = drm_intel_bo_alloc(bufmgr, "buf2", 16384, 4096);
	igt_assert(bo2);
	drm_intel_bo_map(bo2, 1);

	buf1 = (unsigned int *)bo1->virtual;
	igt_assert(buf1);
	memset(buf1, 0, 16384);
	buf1[4000]=0x05000000;

	drm_intel_bo_exec(bo1, 16384, NULL, 0,0);
	drm_intel_bo_wait_rendering(bo1);

	drm_intel_bo_unmap( bo1 );
	drm_intel_bo_unreference(bo1);

	drm_intel_bo_unmap( bo2 );
	drm_intel_bo_unreference(bo2);
}

static void test_surfaces(drm_intel_bo *bo_shared)
{
	drm_intel_bo * bo;
	int loop=2;

	while(loop--) {
		if (use_flink) {
			uint32_t name;
			drm_intel_bo_flink(bo_shared, &name);
			bo = drm_intel_bo_gem_create_from_name(bufmgr,
							       "shared resource",
							       name);
		} else {
			int prime_fd;

			drm_intel_bo_gem_export_to_prime(bo_shared, &prime_fd);
			bo = drm_intel_bo_gem_create_from_prime(bufmgr,
								prime_fd, 4096);
			close(prime_fd);
		}

		igt_assert(bo);
		new_buffers();
		drm_intel_bo_unreference(bo);
	}
}

static void start_test(void)
{
	int i;

	for (i=0; i < 16384; i++)
	{
		drm_intel_bo * bo_shared;

		bo_shared = drm_intel_bo_alloc(bufmgr1, "buf-shared",16384, 4096);
		test_surfaces(bo_shared);
		drm_intel_bo_unreference(bo_shared);
	}
}

static void * test_thread(void * par)
{
#ifdef __linux__
	igt_debug("start %ld\n", gettid());
#else
	igt_debug("start %ld\n", (long) pthread_self());
#endif
	start_test();

	return NULL;
}

struct import_race_thread_data {
	int prime_fd;
	uint32_t flink_name;
	unsigned int stop;
	pthread_mutex_t mutex;
};

/*
 * Attempt to import the bo. It is possible that GEM_CLOSE was already called
 * in different thread and from i915 point of view the handle is no longer
 * valid (thus create_from_prime/name should fail).
 */
static void *import_close_thread(void *data)
{
	struct import_race_thread_data *t = (struct import_race_thread_data *)data;
	drm_intel_bo *bo;
	pthread_mutex_lock(&t->mutex);
	while (!t->stop) {
		pthread_mutex_unlock(&t->mutex);
		bo = NULL;
		if (use_flink)
			bo = drm_intel_bo_gem_create_from_name(bufmgr, "buf-shared", t->flink_name);
		else {
			pthread_mutex_lock(&t->mutex);
			if (t->prime_fd != -1) {
				bo = drm_intel_bo_gem_create_from_prime(bufmgr, t->prime_fd, 4096);
				pthread_mutex_unlock(&t->mutex);
			}
			else
				/* Lock should be held on entering the loop */
				continue;
		}

		if (bo == NULL) {
			/*
			 * If the bo is NULL it means that we've unreferenced in other
			 * thread - therefore we should expect ENOENT
			 */
			igt_assert_eq(errno, ENOENT);
		} else {
			drm_intel_bo_unreference(bo);
		}

		pthread_mutex_lock(&t->mutex);
	}
	pthread_mutex_unlock(&t->mutex);

	return NULL;
}

/*
 * It is possible to race between unreference of the underlying BO and importing
 * it from prime_fd/name. Verify that the behaviour of libdrm is consistent for
 * prime/flink.
 */
static void test_import_close_race(void)
{
	pthread_t t;
	drm_intel_bo *bo;
	struct import_race_thread_data t_data;

	memset(&t_data, 0, sizeof(t_data));
	pthread_mutex_init(&t_data.mutex, NULL);
	t_data.prime_fd = -1;

	igt_assert_eq(pthread_create(&t, NULL, import_close_thread , &t_data), 0);

	igt_until_timeout(15) {
		bo = drm_intel_bo_alloc(bufmgr, "buf-shared", 4096, 4096);
		igt_assert(bo != NULL);
		/*
		 * We setup the test in such way, that create_from_* can race between
		 * unreference. If we're using prime, prime_fd is always a valid fd.
		 */
		if (use_flink)
			igt_assert_eq(drm_intel_bo_flink(bo, &(t_data.flink_name)), 0);
		else {
			pthread_mutex_lock(&t_data.mutex);
			igt_assert_eq(drm_intel_bo_gem_export_to_prime(bo, &(t_data.prime_fd)), 0);
			igt_assert_neq(t_data.prime_fd, -1);
			pthread_mutex_unlock(&t_data.mutex);
		}

		drm_intel_bo_unreference(bo);

		pthread_mutex_lock(&t_data.mutex);
		close(t_data.prime_fd);
		t_data.prime_fd = -1;
		pthread_mutex_unlock(&t_data.mutex);
	}

	pthread_mutex_lock(&t_data.mutex);
	t_data.stop = 1;
	pthread_mutex_unlock(&t_data.mutex);

	pthread_join(t, NULL);
	pthread_mutex_destroy(&t_data.mutex);
}

pthread_t test_thread_id1;
pthread_t test_thread_id2;
pthread_t test_thread_id3;
pthread_t test_thread_id4;

igt_main {
	igt_fixture {
		fd1 = drm_open_driver(DRIVER_INTEL);
		igt_assert(fd1 >= 0);
		bufmgr1 = drm_intel_bufmgr_gem_init(fd1, 8 *1024);
		igt_assert(bufmgr1);

		drm_intel_bufmgr_gem_enable_reuse(bufmgr1);

		fd = drm_open_driver(DRIVER_INTEL);
		igt_assert(fd >= 0);
		bufmgr = drm_intel_bufmgr_gem_init(fd, 8 *1024);
		igt_assert(bufmgr);

		drm_intel_bufmgr_gem_enable_reuse(bufmgr);
	}

	igt_subtest("import-close-race-flink") {
		use_flink = true;
		test_import_close_race();
	}

	igt_subtest("import-close-race-prime") {
		use_flink = false;
		test_import_close_race();
	}

	igt_subtest("flink") {
		use_flink = true;

		pthread_create(&test_thread_id1, NULL, test_thread, NULL);
		pthread_create(&test_thread_id2, NULL, test_thread, NULL);
		pthread_create(&test_thread_id3, NULL, test_thread, NULL);
		pthread_create(&test_thread_id4, NULL, test_thread, NULL);

		pthread_join(test_thread_id1, NULL);
		pthread_join(test_thread_id2, NULL);
		pthread_join(test_thread_id3, NULL);
		pthread_join(test_thread_id4, NULL);
	}

	igt_subtest("prime") {
		use_flink = false;

		pthread_create(&test_thread_id1, NULL, test_thread, NULL);
		pthread_create(&test_thread_id2, NULL, test_thread, NULL);
		pthread_create(&test_thread_id3, NULL, test_thread, NULL);
		pthread_create(&test_thread_id4, NULL, test_thread, NULL);

		pthread_join(test_thread_id1, NULL);
		pthread_join(test_thread_id2, NULL);
		pthread_join(test_thread_id3, NULL);
		pthread_join(test_thread_id4, NULL);
	}
}