/* Copyright (c) 2015 Google Inc.
 * Barret Rhoden <brho@cs.berkeley.edu>
 * See LICENSE for details.
 *
 * User FDs
 *
 * There are a bunch of Linux APIs that we can implement in userspace that use
 * FDs as a handle.  Eventually that handle gets passed to close().  User FDs
 * are a chunk of reserved numbers in the space of FDs, used by various
 * userspace libraries that use FDs as their API.
 *
 * The user FD space starts where the kernel's leaves off.  Currently, the
 * kernel claims 19 bits of the 32 bit int for an FD.  The MSB flags whether it
 * is negative or not.  That leaves 12 bits for us. */

#include <sys/user_fd.h>
#include <parlib/arch/atomic.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

static struct user_fd **ufds = 0;
static size_t nr_ufds = 0;

/* Finds a free user FD and stores ufd there.  Returns the FD, or -1 on error
 * (out of FDs).  You can remove it with a close(). */
int ufd_get_fd(struct user_fd *ufd)
{
	struct user_fd **new_ufds;
	int fd;

	if (!ufds) {
		nr_ufds = 1 << (sizeof(int) * 8 - LOG2_UP(NR_FILE_DESC_MAX)
				- 1);
		/* Two things: instead of worrying about growing and reallocing
		 * (which would need a lock), let's just alloc the entire 2^15
		 * bytes (32KB).  Also, it's unlikely, but we might have two
		 * threads trying to init at once.  First one wins, second one
		 * aborts (and frees). */
		new_ufds = malloc(sizeof(struct user_fd*) * nr_ufds);
		memset(new_ufds, 0, sizeof(struct user_fd*) * nr_ufds);
		if (!atomic_cas_ptr((void**)&ufds, 0, new_ufds))
			free(new_ufds);
		cmb();
	}
	/* At this point, ufds is set.  Just do a linear search for an empty
	 * slot.  We're not actually bound to return the lowest number
	 * available, so in the future we could do things like partition the
	 * space based on vcoreid so we start in different areas, or maintain a
	 * 'last used' hint FD. */
	for (int i = 0; i < nr_ufds; i++) {
		if (!ufds[i]) {
			if (atomic_cas_ptr((void**)&ufds[i], 0, ufd)) {
				fd = i + USER_FD_BASE;
				ufds[i]->fd = fd;
				return fd;
			}
		}
	}
	__set_errno(ENFILE);
	return -1;
}

/* Given an FD, returns the user_fd struct.  Returns 0 and sets errno if there's
 * an error.  There's no protection for concurrent closes, just like how you
 * shouldn't attempt to use an FD after closing.  So don't do stuff like:
 * 	foo = ufd_lookup(7);
 * 	close(7);
 * 	foo->whatever = 6; // foo could be free!
 *
 * or
 * 	close(7);
 * 	foo = ufd_lookup(7);
 * 	// this might succeed if it races with close()
 * 	foo->whatever = 6; // foo could be free!
 */
struct user_fd *ufd_lookup(int fd)
{
	if (!ufds || (fd - USER_FD_BASE >= nr_ufds)) {
		__set_errno(EBADF);
		return 0;
	}
	return ufds[fd - USER_FD_BASE];
}

/* Removes the user_fd from the FD space, calls its callback.  Returns 0 on
 * success.  -1 and sets errno o/w (e.g. EBADF). */
int glibc_close_helper(int fd)
{
	struct user_fd *ufd = ufd_lookup(fd);
	if (!ufd)
		return -1;
	ufds[fd - USER_FD_BASE] = 0;
	ufd->close(ufd);
	return 0;
}