path: root/sync-basic/sync-basic.c

/*******************************************************************************
 * Copyright (c) 2013 Linaro
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Linaro <linaro-dev@lists.linaro.org>
 *******************************************************************************/

/* sync framework test */

#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>

#ifdef ANDROID
/* kernel headers on android */
#include <linux/sync.h>
#include <linux/sw_sync.h>
#else
/* set KDIR in Makefile to point to these headers */
#include "sync.h"
#include "sw_sync.h"
#endif /* ANDROID */

#define SW_SYNC_DEV "/dev/sw_sync"

/* current test run */
int testno = -1;
char testname[32];

/* fd of SW_SYNC_DEV */
int sw_fd;

#define RED    "\x1B[31m"
#define GREEN  "\x1B[32m"
#define NORMAL "\x1B[0m"

void fatal (int error, const char *fmt, ...)
{
    va_list ap;

    fprintf (stderr, "Test %d: ", testno);
    va_start (ap, fmt);
    vfprintf (stderr, fmt, ap);
    if (error)
	fprintf (stderr, " (error %d [%s])", error, strerror (error));
    va_end (ap);
    fprintf (stderr, "\n");
/*    printf(RED); */
    printf ("%d [sync_basic_%s]: test failed\n", testno, testname);
/*    printf(NORMAL); */
    exit (1);
}

void pass (const char *fmt, ...)
{
    va_list ap;

    fprintf (stderr, "Test %d: ", testno);
    if (fmt == NULL)
	    fprintf (stderr, "Passed");
    else {
	    va_start (ap, fmt);
	    vfprintf (stderr, fmt, ap);
	    va_end (ap);
    }
    fprintf (stderr, "\n");
/*    printf(GREEN);  */
    printf ("%d [sync_basic_%s]: test passed\n", testno, testname);
/*    printf(NORMAL); */
}

void create_and_delete_fence (void)
{
  struct sw_sync_create_fence_data f;
  int ret;

  testno++;
  strcpy (testname, __func__);

  strncpy (f.name, "test fence 0", sizeof (f.name));
  f.value = 0;

  ret = ioctl (sw_fd, SW_SYNC_IOC_CREATE_FENCE, &f);
  if (ret < 0)
    fatal (errno, "can't create fence");
  ret = close (f.fence);
  if (ret < 0)
    fatal (errno, "can't delete fence");
  
  pass(NULL);
}

void create_fence_invalid (void)
{
  struct sw_sync_create_fence_data *f = (void *)0xdeaddead;
  int ret;

  testno++;
  strcpy (testname, __func__);

  ret = ioctl (sw_fd, SW_SYNC_IOC_CREATE_FENCE, f);
  if (ret >= 0 || errno != EFAULT)
    fatal (0, "expect -1 and EFAULT, but got %d and %d", ret, errno);

  pass(NULL);
}

#define TOOMANY 100000 /* should be larger than max fds per process */

void create_many_fences (void)
{
  struct sw_sync_create_fence_data f;
  static int fencefds[TOOMANY];
  int ret, nr, i;

  testno++;
  strcpy (testname, __func__);

  for (nr = 0; nr < TOOMANY; nr++) {
    sprintf (f.name, "fence %d", nr);
    f.value = nr;
    ret = ioctl (sw_fd, SW_SYNC_IOC_CREATE_FENCE, &f);
    if (ret < 0)
      break;
    else
      fencefds[nr] = f.fence;
  }

  if (errno != EMFILE)
    fatal (0, "expect EMFILE but got %d", errno);

  for (i = 0; i < nr; i++) {
    ret = close (fencefds[i]);
    if (ret < 0)
      fatal (errno, "error closing fence %d of %d", i, nr);
  }

  pass("%d fences were used", nr);
}

void fence_info (void)
{
  struct sw_sync_create_fence_data f;
  struct sync_fence_info_data *d;
  int ret;

  testno++;
  strcpy (testname, __func__);

  strncpy (f.name, "test fence 1", sizeof (f.name));
  f.value = 0;

  ret = ioctl (sw_fd, SW_SYNC_IOC_CREATE_FENCE, &f);
  if (ret < 0)
    fatal (errno, "can't create fence");

  d = malloc (128);
  if (!d)
    abort ();
  d->len = 128;
  ret = ioctl (f.fence, SYNC_IOC_FENCE_INFO, d);
  if (ret < 0)
    fatal (errno, "can't get fence %d info", f.fence);

  if (strcmp (d->name, "test fence 1"))
    fatal (0, "invalid fence name");
  if (d->status != 1)
    fatal (0, "invalid fence status");

  free (d);
  ret = close (f.fence);
  if (ret < 0)
    fatal (errno, "can't delete fence");

  pass(NULL);
}

void fence_info_invalid (void)
{
  struct sync_fence_info_data *d;
  int ret;

  testno++;
  strcpy (testname, __func__);

  d = malloc (128);
  if (!d)
    abort ();
  d->len = 128;

  ret = ioctl (fileno (stdout), SYNC_IOC_FENCE_INFO, d);
  if (ret >= 0 || errno != ENOTTY)
    fatal (0, "expect -1 and ENOTTY, but got %d and %d", ret, errno);

  free (d);

  pass(NULL);
}

void fence_merge (void)
{
  struct sw_sync_create_fence_data f1, f2;
  struct sync_merge_data f3;
  struct sync_fence_info_data *d;
  int ret;

  testno++;
  strcpy (testname, __func__);

  strncpy (f1.name, "test fence 1", sizeof (f1.name));
  f1.value = 1;
  ret = ioctl (sw_fd, SW_SYNC_IOC_CREATE_FENCE, &f1);
  if (ret < 0)
    fatal (errno, "can't create fence 1");

  strncpy (f2.name, "test fence 2", sizeof (f2.name));
  f2.value = 2;
  ret = ioctl (sw_fd, SW_SYNC_IOC_CREATE_FENCE, &f2);
  if (ret < 0)
    fatal (errno, "can't create fence 2");

  f3.fd2 = f2.fence;
  strncpy (f3.name, "merged fence 1 + 2", sizeof (f3.name));
  ret = ioctl (f1.fence, SYNC_IOC_MERGE, &f3);
  if (ret < 0)
    fatal (errno, "can't merge fences");

  d = malloc (128);
  if (!d)
    abort ();
  d->len = 128;
  ret = ioctl (f3.fence, SYNC_IOC_FENCE_INFO, d);
  if (ret < 0)
    fatal (errno, "can't get information about merged fence");
  if (strcmp (d->name, "merged fence 1 + 2"))
    fatal (0, "invalid merged fence name");
  free (d);

  if (f1.fence == f2.fence ||
      f2.fence == f3.fence ||
      f3.fence == f1.fence)
    fatal (0, "impossible fence fds: %d %d %d", f1.fence, f2.fence, f3.fence);

  ret = close (f3.fence);
  if (ret < 0)
    fatal (errno, "can't close merged fence");
  ret = close (f2.fence);
  if (ret < 0)
    fatal (errno, "can't close fence 2");
  ret = close (f1.fence);
  if (ret < 0)
    fatal (errno, "can't close fence 1");

  pass(NULL);
}

void fence_merge_itself (void)
{
  struct sw_sync_create_fence_data f1;
  struct sync_merge_data f2;
  int ret;

  testno++;
  strcpy (testname, __func__);

  strncpy (f1.name, "test fence 1", sizeof (f1.name));
  f1.value = 1;
  ret = ioctl (sw_fd, SW_SYNC_IOC_CREATE_FENCE, &f1);
  if (ret < 0)
    fatal (errno, "can't create fence 1");

  f2.fd2 = f1.fence;
  strncpy (f2.name, "copy of fence 1", sizeof (f2.name));
  ret = ioctl (f1.fence, SYNC_IOC_MERGE, &f2);
  if (ret < 0)
    fatal (errno, "can't merge fence with itself");

  ret = close (f2.fence);
  if (ret < 0)
    fatal (errno, "can't close copy fence");
  ret = close (f1.fence);
  if (ret < 0)
    fatal (errno, "can't close fence 1");

  pass(NULL);
}

void fence_merge_invalid (void)
{
  struct sw_sync_create_fence_data f1;
  struct sync_merge_data f2;
  int ret;

  testno++;
  strcpy (testname, __func__);

  strncpy (f1.name, "test fence 1", sizeof (f1.name));
  f1.value = 1;
  ret = ioctl (sw_fd, SW_SYNC_IOC_CREATE_FENCE, &f1);
  if (ret < 0)
    fatal (errno, "can't create fence 1");

  f2.fd2 = fileno (stdout);
  strncpy (f2.name, "impossible fence 2", sizeof (f2.name));
  ret = ioctl (f1.fence, SYNC_IOC_MERGE, &f2);

  if (ret >= 0 || errno != ENOENT)
    fatal (0, "expect -1 and ENOENT, but got %d and %d", ret, errno);

  ret = close (f1.fence);
  if (ret < 0)
    fatal (errno, "can't close fence 1");

  pass(NULL);
}

int main (int argc, char *argv[])
{
  /* 0 - just try to open */
  testno++;
  strcpy (testname, "try_open");
  sw_fd = open (SW_SYNC_DEV, O_RDWR);
  if (sw_fd < 0)
    fatal (errno, "can't open '%s'", SW_SYNC_DEV);
  pass(NULL);

  /* 1 - create and delete just one fence */
  create_and_delete_fence ();

  /* 2 - try to create fence fron invalid data */
  create_fence_invalid ();

  /* 3 - try to create as much as possible */
  create_many_fences ();

  /* 4 - basic fence info */
  fence_info ();

  /* 5 - invalid fence info */
  fence_info_invalid ();

  /* 6 - basic merge */
  fence_merge ();

  /* 7 - merge with itself (e.g. copy) */
  fence_merge_itself ();

  /* 8 - merge with invalid fence */
  fence_merge_invalid ();

  close (sw_fd);
  return 0;
}