/* filexfer.c
 *
 * Copyright © 2013 - 2013 UNISYS CORPORATION
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 * NON INFRINGEMENT.  See the GNU General Public License for more
 * details.
 */

/* Code here-in is the "glue" that connects controlvm messages with the
 * sparfilexfer driver, which is used to transfer file contents as payload
 * across the controlvm channel.
 */

#include "globals.h"
#include "controlvm.h"
#include "visorchipset.h"
#include "filexfer.h"

#ifdef ENABLE_SPARFILEXFER /* sparfilexfer kernel module enabled in build */
#include "sparfilexfer.h"

/* Driver-global memory */
static LIST_HEAD(Request_list);	/* list of struct any_request *, via
				 * req_list memb */

/* lock for above pool for allocation of any_request structs, and pool
* name; note that kmem_cache_create requires that we keep the storage
* for the pool name for the life of the pool
 */
static DEFINE_SPINLOCK(Request_list_lock);

static struct kmem_cache *Request_memory_pool;
static const char Request_memory_pool_name[] = "filexfer_request_pool";
size_t Caller_req_context_bytes = 0;	/* passed to filexfer_constructor() */

/* This structure defines a single controlvm GETFILE conversation, which
 * consists of a single controlvm request message and 1 or more controlvm
 * response messages.
 */
struct getfile_request {
	CONTROLVM_MESSAGE_HEADER controlvm_header;
	atomic_t buffers_in_use;
	GET_CONTIGUOUS_CONTROLVM_PAYLOAD_FUNC get_contiguous_controlvm_payload;
	CONTROLVM_RESPOND_WITH_PAYLOAD_FUNC controlvm_respond_with_payload;
};

/* This structure defines a single controlvm PUTFILE conversation, which
 * consists of a single controlvm request with a filename, and additional
 * controlvm messages with file data.
 */
struct putfile_request {
	GET_CONTROLVM_FILEDATA_FUNC get_controlvm_filedata;
	CONTROLVM_RESPOND_FUNC controlvm_end_putFile;
};

/* This structure defines a single file transfer operation, which can either
 * be a GETFILE or PUTFILE.
 */
struct any_request {
	struct list_head req_list;
	ulong2 file_request_number;
	ulong2 data_sequence_number;
	TRANSMITFILE_DUMP_FUNC dump_func;
	BOOL is_get;
	union {
		struct getfile_request get;
		struct putfile_request put;
	};
	/* Size of caller_context_data will be
	 * <Caller_req_context_bytes> bytes.  I aligned this because I
	 * am paranoid about what happens when an arbitrary data
	 * structure with unknown alignment requirements gets copied
	 * here.  I want caller_context_data to be aligned to the
	 * coarsest possible alignment boundary that could be required
	 * for any user data structure.
	 */
	u8 caller_context_data[1] __aligned(sizeof(ulong2));
};

/*
 * Links the any_request into the global list of allocated requests
 * (<Request_list>).
 */
static void
unit_tracking_create(struct list_head *dev_list_link)
{
	unsigned long flags;
	spin_lock_irqsave(&Request_list_lock, flags);
	list_add(dev_list_link, &Request_list);
	spin_unlock_irqrestore(&Request_list_lock, flags);
}

/* Unlinks a any_request from the global list (<Request_list>).
 */
static void
unit_tracking_destroy(struct list_head *dev_list_link)
{
	unsigned long flags;
	spin_lock_irqsave(&Request_list_lock, flags);
	list_del(dev_list_link);
	spin_unlock_irqrestore(&Request_list_lock, flags);
}

/* Allocate memory for and return a new any_request struct, and
 * link it to the global list of outstanding requests.
 */
static struct any_request *
alloc_request(char *fn, int ln)
{
	struct any_request *req = (struct any_request *)
	    (visorchipset_cache_alloc(Request_memory_pool,
				      FALSE,
				      fn, ln));
	if (!req)
		return NULL;
	memset(req, 0, sizeof(struct any_request) + Caller_req_context_bytes);
	unit_tracking_create(&req->req_list);
	return req;
}

/* Book-end for alloc_request().
 */
static void
free_request(struct any_request *req, char *fn, int ln)
{
	unit_tracking_destroy(&req->req_list);
	visorchipset_cache_free(Request_memory_pool, req, fn, ln);
}

/* Constructor for filexfer.o.
 */
int
filexfer_constructor(size_t req_context_bytes)
{
	int rc = -1;

	Caller_req_context_bytes = req_context_bytes;
	Request_memory_pool =
	    kmem_cache_create(Request_memory_pool_name,
			      sizeof(struct any_request) +
			      Caller_req_context_bytes,
			      0, SLAB_HWCACHE_ALIGN, NULL);
	if (!Request_memory_pool) {
		LOGERR("failed to alloc Request_memory_pool");
		rc = -ENOMEM;
		goto Away;
	}
	rc = 0;
Away:
	if (rc < 0) {
		if (Request_memory_pool) {
			kmem_cache_destroy(Request_memory_pool);
			Request_memory_pool = NULL;
		}
	}
	return rc;
}

/* Destructor for filexfer.o.
 */
void
filexfer_destructor(void)
{
	if (Request_memory_pool) {
		kmem_cache_destroy(Request_memory_pool);
		Request_memory_pool = NULL;
	}
}

/* This function will obtain an available chunk from the controlvm payload area,
 * store the size in bytes of the chunk in <actual_size>, and return a pointer
 * to the chunk.  The function is passed to the sparfilexfer driver, which calls
 * it whenever payload space is required to copy file data into.
 */
static void *
get_empty_bucket_for_getfile_data(void *context,
				  ulong min_size, ulong max_size,
				  ulong *actual_size)
{
	void *bucket;
	struct any_request *req = (struct any_request *) context;

	if (!req->is_get) {
		LOGERR("%s - unexpected call", __func__);
		return NULL;
	}
	bucket = (*req->get.get_contiguous_controlvm_payload)
	    (min_size, max_size, actual_size);
	if (bucket != NULL) {
		atomic_inc(&req->get.buffers_in_use);
		DBGINF("%s - sent %lu-byte buffer", __func__, *actual_size);
	}
	return bucket;
}

/* This function will send a controlvm response with data in the payload
 * (whose space was obtained with get_empty_bucket_for_getfile_data).  The
 * function is passed to the sparfilexfer driver, which calls it whenever it
 * wants to send file data back across the controlvm channel.
 */
static int
send_full_getfile_data_bucket(void *context, void *bucket,
			      ulong bucket_actual_size, ulong bucket_used_size)
{
	struct any_request *req = (struct any_request *) context;

	if (!req->is_get) {
		LOGERR("%s - unexpected call", __func__);
		return 0;
	}
	DBGINF("sending buffer for %lu/%lu",
	       bucket_used_size, bucket_actual_size);
	if (!(*req->get.controlvm_respond_with_payload)
	    (&req->get.controlvm_header,
	     req->file_request_number,
	     req->data_sequence_number++,
	     0, bucket, bucket_actual_size, bucket_used_size, TRUE))
		atomic_dec(&req->get.buffers_in_use);
	return 0;
}

/* This function will send a controlvm response indicating the end of a
 * GETFILE transfer.  The function is passed to the sparfilexfer driver.
 */
static void
send_end_of_getfile_data(void *context, int status)
{
	struct any_request *req = (struct any_request *) context;
	if (!req->is_get) {
		LOGERR("%s - unexpected call", __func__);
		return;
	}
	LOGINF("status=%d", status);
	(*req->get.controlvm_respond_with_payload)
	    (&req->get.controlvm_header,
	     req->file_request_number,
	     req->data_sequence_number++, status, NULL, 0, 0, FALSE);
	free_request(req, __FILE__, __LINE__);
	module_put(THIS_MODULE);
}

/* This function supplies data for a PUTFILE transfer.
 * The function is passed to the sparfilexfer driver.
 */
static int
get_putfile_data(void *context, void *pbuf, size_t bufsize,
		 BOOL buf_is_userspace, size_t *bytes_transferred)
{
	struct any_request *req = (struct any_request *) context;
	if (req->is_get) {
		LOGERR("%s - unexpected call", __func__);
		return -1;
	}
	return (*req->put.get_controlvm_filedata) (&req->caller_context_data[0],
						   pbuf, bufsize,
						   buf_is_userspace,
						   bytes_transferred);
}

/* This function is called to indicate the end of a PUTFILE transfer.
 * The function is passed to the sparfilexfer driver.
 */
static void
end_putfile(void *context, int status)
{
	struct any_request *req = (struct any_request *) context;
	if (req->is_get) {
		LOGERR("%s - unexpected call", __func__);
		return;
	}
	(*req->put.controlvm_end_putFile) (&req->caller_context_data[0],
					   status);
	free_request(req, __FILE__, __LINE__);
	module_put(THIS_MODULE);
}

/* Refer to filexfer.h for description. */
BOOL
filexfer_getFile(CONTROLVM_MESSAGE_HEADER *msgHdr,
		 ulong2 file_request_number,
		 uint uplink_index,
		 uint disk_index,
		 char *file_name,
		 GET_CONTIGUOUS_CONTROLVM_PAYLOAD_FUNC
		 get_contiguous_controlvm_payload,
		 CONTROLVM_RESPOND_WITH_PAYLOAD_FUNC
		 controlvm_respond_with_payload,
		 TRANSMITFILE_DUMP_FUNC dump_func)
{
	BOOL use_count_up = FALSE;
	BOOL failed = TRUE;
	struct any_request *req = alloc_request(__FILE__, __LINE__);

	if (!req) {
		LOGERR("allocation of any_request failed");
		goto Away;
	}
	/* We need to increment this module's use count because we're handing
	 * off pointers to functions within this module to be used by
	 * another module.
	 */
	__module_get(THIS_MODULE);
	use_count_up = TRUE;
	req->is_get = TRUE;
	req->file_request_number = file_request_number;
	req->data_sequence_number = 0;
	req->dump_func = dump_func;
	req->get.controlvm_header = *msgHdr;
	atomic_set(&req->get.buffers_in_use, 0);
	req->get.get_contiguous_controlvm_payload =
	    get_contiguous_controlvm_payload;
	req->get.controlvm_respond_with_payload =
	    controlvm_respond_with_payload;
	if (sparfilexfer_local2remote(req,	/* context, passed to
						 * callback funcs */
				      file_name,
				      file_request_number,
				      uplink_index,
				      disk_index,
				      get_empty_bucket_for_getfile_data,
				      send_full_getfile_data_bucket,
				      send_end_of_getfile_data) < 0) {
		LOGERR("sparfilexfer_local2remote failed");
		goto Away;
	}
	failed = FALSE;
Away:
	if (failed) {
		if (use_count_up) {
			module_put(THIS_MODULE);
			use_count_up = FALSE;
		}
		if (req) {
			free_request(req, __FILE__, __LINE__);
			req = NULL;
		}
		return FALSE;
	} else {
		return TRUE;
		/* success; send callbacks will be called for responses */
	}
}

/* Refer to filexfer.h for description. */
void *
filexfer_putFile(CONTROLVM_MESSAGE_HEADER *msgHdr,
		 ulong2 file_request_number,
		 uint uplink_index,
		 uint disk_index,
		 char *file_name,
		 TRANSMITFILE_INIT_CONTEXT_FUNC init_context,
		 GET_CONTROLVM_FILEDATA_FUNC get_controlvm_filedata,
		 CONTROLVM_RESPOND_FUNC controlvm_end_putFile,
		 TRANSMITFILE_DUMP_FUNC dump_func)
{
	BOOL use_count_up = FALSE;
	BOOL failed = TRUE;
	struct any_request *req = alloc_request(__FILE__, __LINE__);
	void *caller_ctx = NULL;

	if (!req) {
		LOGERR("allocation of any_request failed");
		goto Away;
	}
	caller_ctx = (void *) (&(req->caller_context_data[0]));
	/* We need to increment this module's use count because we're handing
	 * off pointers to functions within this module to be used by
	 * another module.
	 */
	__module_get(THIS_MODULE);
	use_count_up = TRUE;
	req->is_get = FALSE;
	req->file_request_number = file_request_number;
	req->data_sequence_number = 0;
	req->dump_func = dump_func;
	req->put.get_controlvm_filedata = get_controlvm_filedata;
	req->put.controlvm_end_putFile = controlvm_end_putFile;
	(*init_context) (caller_ctx, msgHdr, file_request_number);
	if (sparfilexfer_remote2local(req,	/* context, passed to
						 * callback funcs */
				      file_name,
				      file_request_number,
				      uplink_index,
				      disk_index,
				      get_putfile_data, end_putfile) < 0) {
		LOGERR("sparfilexfer_remote2local failed");
		goto Away;
	}
	failed = FALSE;
Away:
	if (failed) {
		if (use_count_up) {
			module_put(THIS_MODULE);
			use_count_up = FALSE;
		}
		if (req) {
			free_request(req, __FILE__, __LINE__);
			req = NULL;
		}
		return NULL;
	} else {
		return caller_ctx;
		/* success; callbacks will be called for responses */
	}
}

static void
dump_get_request(struct seq_file *f, struct getfile_request *getreq)
{
	seq_printf(f, "  buffers_in_use=%d\n",
		   atomic_read(&getreq->buffers_in_use));
}

static void
dump_put_request(struct seq_file *f, struct putfile_request *putreq)
{
}

static void
dump_request(struct seq_file *f, struct any_request *req)
{
	seq_printf(f, "* %s id=%llu seq=%llu\n",
		   ((req->is_get) ? "Get" : "Put"),
		   req->file_request_number, req->data_sequence_number);
	if (req->is_get)
		dump_get_request(f, &req->get);
	else
		dump_put_request(f, &req->put);
	if (req->dump_func)
		(*req->dump_func) (f, &(req->caller_context_data[0]), "  ");
}

void
filexfer_dump(struct seq_file *f)
{
	ulong flags;
	struct list_head *entry;

	seq_puts(f, "Outstanding TRANSMIT_FILE requests:\n");
	spin_lock_irqsave(&Request_list_lock, flags);
	list_for_each(entry, &Request_list) {
		struct any_request *req;
		req = list_entry(entry, struct any_request, req_list);
		dump_request(f, req);
	}
	spin_unlock_irqrestore(&Request_list_lock, flags);
}

#else				/* ifdef ENABLE_SPARFILEXFER */
int
filexfer_constructor(size_t req_context_bytes)
{
	return 0;		/* success */
}

void
filexfer_destructor(void)
{
}

BOOL
filexfer_getFile(CONTROLVM_MESSAGE_HEADER *msgHdr,
		 u64 file_request_number,
		 uint uplink_index,
		 uint disk_index,
		 char *file_name,
		 GET_CONTIGUOUS_CONTROLVM_PAYLOAD_FUNC
		 get_contiguous_controlvm_payload,
		 CONTROLVM_RESPOND_WITH_PAYLOAD_FUNC
		 controlvm_respond_with_payload,
		 TRANSMITFILE_DUMP_FUNC dump_func)
{
	/* since no sparfilexfer module exists to call, we just fail */
	return FALSE;
}

void *
filexfer_putFile(CONTROLVM_MESSAGE_HEADER *msgHdr,
		 u64 file_request_number,
		 uint uplink_index,
		 uint disk_index,
		 char *file_name,
		 TRANSMITFILE_INIT_CONTEXT_FUNC init_context,
		 GET_CONTROLVM_FILEDATA_FUNC get_controlvm_filedata,
		 CONTROLVM_RESPOND_FUNC controlvm_end_putFile,
		 TRANSMITFILE_DUMP_FUNC dump_func)
{
	/* since no sparfilexfer module exists to call, we just fail */
	return NULL;
}

void
filexfer_dump(struct seq_file *f)
{
}

#endif				/* ifdef ENABLE_SPARFILEXFER */