linux/drivers/dma-buf/sync_file.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * drivers/dma-buf/sync_file.c
 *
 * Copyright (C) 2012 Google, Inc.
 */

#include <linux/dma-fence-unwrap.h>
#include <linux/export.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/anon_inodes.h>
#include <linux/sync_file.h>
#include <uapi/linux/sync_file.h>

static const struct file_operations sync_file_fops;

static struct sync_file *sync_file_alloc(void)
{ … }

static void fence_check_cb_func(struct dma_fence *f, struct dma_fence_cb *cb)
{ … }

/**
 * sync_file_create() - creates a sync file
 * @fence:	fence to add to the sync_fence
 *
 * Creates a sync_file containg @fence. This function acquires and additional
 * reference of @fence for the newly-created &sync_file, if it succeeds. The
 * sync_file can be released with fput(sync_file->file). Returns the
 * sync_file or NULL in case of error.
 */
struct sync_file *sync_file_create(struct dma_fence *fence)
{ … }
EXPORT_SYMBOL(…);

static struct sync_file *sync_file_fdget(int fd)
{ … }

/**
 * sync_file_get_fence - get the fence related to the sync_file fd
 * @fd:		sync_file fd to get the fence from
 *
 * Ensures @fd references a valid sync_file and returns a fence that
 * represents all fence in the sync_file. On error NULL is returned.
 */
struct dma_fence *sync_file_get_fence(int fd)
{ … }
EXPORT_SYMBOL(…);

/**
 * sync_file_get_name - get the name of the sync_file
 * @sync_file:		sync_file to get the fence from
 * @buf:		destination buffer to copy sync_file name into
 * @len:		available size of destination buffer.
 *
 * Each sync_file may have a name assigned either by the user (when merging
 * sync_files together) or created from the fence it contains. In the latter
 * case construction of the name is deferred until use, and so requires
 * sync_file_get_name().
 *
 * Returns: a string representing the name.
 */
char *sync_file_get_name(struct sync_file *sync_file, char *buf, int len)
{ … }

/**
 * sync_file_merge() - merge two sync_files
 * @name:	name of new fence
 * @a:		sync_file a
 * @b:		sync_file b
 *
 * Creates a new sync_file which contains copies of all the fences in both
 * @a and @b.  @a and @b remain valid, independent sync_file. Returns the
 * new merged sync_file or NULL in case of error.
 */
static struct sync_file *sync_file_merge(const char *name, struct sync_file *a,
					 struct sync_file *b)
{ … }

static int sync_file_release(struct inode *inode, struct file *file)
{ … }

static __poll_t sync_file_poll(struct file *file, poll_table *wait)
{ … }

static long sync_file_ioctl_merge(struct sync_file *sync_file,
				  unsigned long arg)
{ … }

static int sync_fill_fence_info(struct dma_fence *fence,
				 struct sync_fence_info *info)
{ … }

static long sync_file_ioctl_fence_info(struct sync_file *sync_file,
				       unsigned long arg)
{ … }

static int sync_file_ioctl_set_deadline(struct sync_file *sync_file,
					unsigned long arg)
{ … }

static long sync_file_ioctl(struct file *file, unsigned int cmd,
			    unsigned long arg)
{ … }

static const struct file_operations sync_file_fops = …;