/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/cred.h>

#include <sys/cmn_err.h>

#include <sys/debug.h>

#include <sys/systm.h>

#include <sys/kmem.h>

#include <sys/disp.h>

#include <sys/atomic.h>

#include <rpc/types.h>

#include <nfs/nfs.h>

#include <nfs/nfssys.h>

#include <nfs/export.h>

#include <nfs/rnode.h>

#include <rpc/auth.h>

#include <rpc/svc.h>

#include <rpc/xdr.h>

#include <rpc/clnt.h>

#include <nfs/nfs_log.h>

#define	NUM_RECORDS_TO_WRITE 256

#define	NUM_BYTES_TO_WRITE 65536

extern krwlock_t exported_lock;

static int nfslog_num_records_to_write = NUM_RECORDS_TO_WRITE;

static int nfslog_num_bytes_to_write = NUM_BYTES_TO_WRITE;

/*

 * This struct is used to 'hide' the details of managing the log

 * records internally to the logging code.  Allocation routines

 * are used to obtain pieces of memory for XDR encoding.  This struct

 * is a 'header' to those areas and a opaque cookie is used to pass

 * this data structure between the allocating function and the put

 * function.

 */

struct lr_alloc {

	struct lr_alloc		*next;		/* links for write queuing */

	struct lr_alloc		*prev;

#define	LR_ALLOC_NOFREE	0x1			/* not present, call free */

	int			lr_flags;

	caddr_t			log_record;	/* address to XDR encoding */

	size_t			size;		/* final size of encoding */

	struct kmem_cache	*alloc_cache;	/* keep track of cache ptr */

	struct exportinfo	*exi;		/* who are we related to? */

	struct log_buffer	*lb;

};

struct flush_thread_params {

	struct nfsl_flush_args tp_args;

	int tp_error;

};

static int log_file_create(caddr_t, struct log_file **);

static void log_file_rele(struct log_file *);

static struct log_buffer *log_buffer_create(caddr_t);

static void log_buffer_rele(struct log_buffer *);

static int nfslog_record_append2all(struct lr_alloc *);

static int nfslog_logbuffer_rename(struct log_buffer *);

static void nfslog_logfile_wait(struct log_file *);

static int nfslog_logfile_rename(char *, char *);

static void nfslog_do_flush(struct flush_thread_params *);

static void create_buffer_header(caddr_t *, size_t *, size_t *);

static int nfslog_write_logrecords(struct log_file *, struct lr_alloc *, int);

static void nfslog_free_logrecords(struct lr_alloc *);

static int nfslog_records_flush_to_disk(struct log_buffer *);

static int nfslog_records_flush_to_disk_nolock(struct log_buffer *);

/*

 * Read/Write lock that protects 'nfslog_buffer_list'.

 * This lock must be held when searching or modifying 'nfslog_buffer_list'.

 */

static krwlock_t nfslog_buffer_list_lock;

/*

 * The list of "log_buffer" structures.

 */

struct log_buffer *nfslog_buffer_list = NULL;

#define	LOG_BUFFER_HOLD(lbp)	{ \

	mutex_enter(&(lbp)->lb_lock); \

	(lbp)->lb_refcnt++; \

	mutex_exit(&(lbp)->lb_lock); \

}

#define	LOG_FILE_HOLD(lfp)	{ \

	mutex_enter(&(lfp)->lf_lock); \

	(lfp)->lf_refcnt++; \

	mutex_exit(&(lfp)->lf_lock); \

}

#define	LOG_FILE_RELE(lfp)	{ \

	log_file_rele(lfp); \

}

/*

 * These two macros are used to prep a logfile data structure and

 * associated file for writing data.  Note that the lf_lock is

 * held as a result of the call to the first macro.  This is used

 * for serialization correctness between the logbuffer struct and

 * the logfile struct.

 */

#define	LOG_FILE_LOCK_TO_WRITE(lfp)	{ \

	mutex_enter(&(lfp)->lf_lock); \

	(lfp)->lf_refcnt++; \

	(lfp)->lf_writers++; \

}

#define	LOG_FILE_UNLOCK_FROM_WRITE(lfp)	{ \

	(lfp)->lf_writers--; \

	if ((lfp)->lf_writers == 0 && ((lfp)->lf_flags & L_WAITING)) { \

		(lfp)->lf_flags &= ~L_WAITING; \

		cv_broadcast(&(lfp)->lf_cv_waiters); \

	} \

	mutex_exit(&(lfp)->lf_lock); \

	log_file_rele(lfp); \

}

int rfsl_log_buffer = 0;

static int rfsl_log_file = 0;

/* This array is used for memory allocation of record encoding spaces */

static struct {

	int	size;

	struct kmem_cache *mem_cache;

	char	*cache_name;

} nfslog_mem_alloc[] = {

#define	SMALL_INDX 0

	{ NFSLOG_SMALL_RECORD_SIZE - sizeof (struct lr_alloc),

	NULL, NFSLOG_SMALL_REC_NAME },

#define	MEDIUM_INDX 1

	{ NFSLOG_MEDIUM_RECORD_SIZE - sizeof (struct lr_alloc),

	NULL, NFSLOG_MEDIUM_REC_NAME },

#define	LARGE_INDX 2

	{ NFSLOG_LARGE_RECORD_SIZE - sizeof (struct lr_alloc),

	NULL, NFSLOG_LARGE_REC_NAME },

	{ (-1), NULL }

};

/* Used to calculate the 'real' allocation size */

#define	ALLOC_SIZE(index) \

	(nfslog_mem_alloc[index].size + sizeof (struct lr_alloc))

/*

 * Initialize logging data buffer cache

 */

void

nfslog_init()

{

	int indx;

	rw_init(&nfslog_buffer_list_lock, NULL, RW_DEFAULT, NULL);

	/*

	 * Initialize the kmem caches for encoding

	 */

	for (indx = 0; nfslog_mem_alloc[indx].size != (-1); indx++) {

		nfslog_mem_alloc[indx].mem_cache =

			kmem_cache_create(nfslog_mem_alloc[indx].cache_name,

				ALLOC_SIZE(indx),

				0, NULL, NULL, NULL, NULL, NULL, 0);

	}

}

/*

 * Sets up the necessary log file and related buffers to enable logging

 * on the given export point.

 * Returns 0 on success, non-zero on failure.

 */

int

nfslog_setup(struct exportinfo *exi)

{

	struct exportdata *kex;

	struct log_buffer *lbp;

	struct log_buffer *nlbp;

	kex = &exi->exi_export;

	ASSERT(kex->ex_flags & EX_LOG);

	/*

	 * Logging is enabled for the new export point, check

	 * the existing log_buffer structures to see if the

	 * desired buffer has already been opened. If so, point

	 * the new exportinfo's exi_logbuffer to the existing

	 * one.

	 */

	rw_enter(&nfslog_buffer_list_lock, RW_READER);

	for (lbp = nfslog_buffer_list; lbp != NULL; lbp = lbp->lb_next) {

		LOGGING_DPRINT((10,

		    "searching for buffer... found log_buffer '%s'\n",

				lbp->lb_path));

		if (strcmp(lbp->lb_path, kex->ex_log_buffer) == 0) {

			/* Found our match. Ref it and return */

			LOG_BUFFER_HOLD(lbp);

			exi->exi_logbuffer = lbp;

			LOGGING_DPRINT((10,  "\tfound log_buffer for '%s'\n",

				kex->ex_log_buffer));

			rw_exit(&nfslog_buffer_list_lock);

			return (0);

		}

	}

	rw_exit(&nfslog_buffer_list_lock);

	/*

	 * New buffer needed, allocate it.

	 * The buffer list lock has been dropped so we will need to search

	 * the list again to ensure that another thread has not added

	 * a matching buffer.

	 */

	if ((nlbp = log_buffer_create(kex->ex_log_buffer)) == NULL) {

		/*

		 * Failed the buffer creation for some reason so we

		 * will need to return.

		 */

		return (EIO);

	}

	rw_enter(&nfslog_buffer_list_lock, RW_WRITER);

	for (lbp = nfslog_buffer_list; lbp != NULL;

		lbp = lbp->lb_next) {

		if (strcmp(lbp->lb_path, kex->ex_log_buffer) == 0) {

				/*

				 * A log_buffer already exists for the

				 * indicated buffer, use it instead.

				 */

			LOG_BUFFER_HOLD(lbp);

			exi->exi_logbuffer = lbp;

			LOGGING_DPRINT((10,

				"found log_buffer for '%s' "

				"after allocation\n",

				kex->ex_log_buffer));

			rw_exit(&nfslog_buffer_list_lock);

			log_buffer_rele(nlbp);

			return (0);

		}

	}

	/*

	 * Didn't find an existing log_buffer for this buffer,

	 * use the the newly created one, and add to list.  We

	 * increment the reference count because the node is

	 * entered into the global list.

	 */

	LOGGING_DPRINT((10, "exportfs: adding nlbp=%p to list\n",

		nlbp));

	nlbp->lb_next = nfslog_buffer_list;

	nfslog_buffer_list = nlbp;

	LOG_BUFFER_HOLD(nlbp);	/* hold is for export entry */

	exi->exi_logbuffer = nlbp;

	rw_exit(&nfslog_buffer_list_lock);

	return (0);

}

/*

 * Disables logging for the given export point.

 */

void

nfslog_disable(struct exportinfo *exi)

{

	log_buffer_rele(exi->exi_logbuffer);

}

/*

 * Creates the corresponding log_buffer and log_file structures

 * for the the buffer named 'name'.

 * Returns a pointer to the log_buffer structure with reference one.

 */

static struct log_buffer *

log_buffer_create(caddr_t name)

{

	struct log_buffer *buffer;

	struct log_file *logfile;

	int namelen = strlen(name);

	LOGGING_DPRINT((10,  "log_buffer_create: %s\n", name));

	if (log_file_create(name, &logfile))

		return (NULL);

	buffer = (struct log_buffer *)kmem_alloc(sizeof (*buffer), KM_SLEEP);

	buffer->lb_refcnt = 1;

	buffer->lb_rec_id = 0;

	buffer->lb_path = (caddr_t)kmem_alloc(namelen + 1, KM_SLEEP);

	bcopy(name, buffer->lb_path, namelen + 1);

	buffer->lb_logfile = logfile;

	buffer->lb_records = NULL;

	buffer->lb_num_recs = 0;

	buffer->lb_size_queued = 0;

	mutex_init(&buffer->lb_lock, NULL, MUTEX_DEFAULT, NULL);

	rfsl_log_buffer++;

	return (buffer);

}

/*

 * Release a log_buffer structure

 */

static void

log_buffer_rele(struct log_buffer *lbp)

{

	int len;

	mutex_enter(&lbp->lb_lock);

	if (--lbp->lb_refcnt > 1) {

		mutex_exit(&lbp->lb_lock);

		return;

	}

	if (lbp->lb_refcnt < 0) {

		panic("log_rele: log_buffer refcnt < 0");

		/*NOTREACHED*/

	}

	/*

	 * Need to drop the lb_lock before acquiring the

	 * nfslog_buffer_list_lock. To avoid double free we need

	 * to hold an additional reference to the log buffer.

	 * This will ensure that no two threads will simultaneously

	 * be trying to free the same log buffer.

	 */

	if (lbp->lb_refcnt == 1) {

		/*

		 * If the ref count is 1, then the last

		 * unshare/reference has been given up and we need to

		 * clean up the buffer and remove it from the buffer

		 * list.

		 */

		LOGGING_DPRINT((10,

			"log_buffer_rele lbp=%p disconnecting\n", lbp));

		/*

		 * Hold additional reference before dropping the lb_lock

		 */

		lbp->lb_refcnt++;

		mutex_exit(&lbp->lb_lock);

		/*

		 * Make sure that all of the buffered records are written.

		 * Don't bother checking the write return value since there

		 * isn't much we can do at this point.

		 */

		(void) nfslog_records_flush_to_disk(lbp);

		rw_enter(&nfslog_buffer_list_lock, RW_WRITER);

		mutex_enter(&lbp->lb_lock);

		/*

		 * Drop the reference count held above.

		 * If the ref count is still > 1 then someone has

		 * stepped in to use this log buffer.  unlock and return.

		 */

		if (--lbp->lb_refcnt > 1) {

			mutex_exit(&lbp->lb_lock);

			rw_exit(&nfslog_buffer_list_lock);

			return;

		}

		if (lbp == nfslog_buffer_list) {

			nfslog_buffer_list = lbp->lb_next;

		} else {

			struct log_buffer *tlbp;

			/* Drop the log_buffer from the master list */

			for (tlbp = nfslog_buffer_list; tlbp->lb_next != NULL;

					tlbp = tlbp->lb_next) {

				if (tlbp->lb_next == lbp) {

					tlbp->lb_next = lbp->lb_next;

					break;

				}

			}

		}

		mutex_exit(&lbp->lb_lock);

		rw_exit(&nfslog_buffer_list_lock);

	}

	/*

	 * ref count zero; finish clean up.

	 */

	LOGGING_DPRINT((10, "log_buffer_rele lbp=%p freeing\n", lbp));

	log_file_rele(lbp->lb_logfile);

	len = strlen(lbp->lb_path) + 1;

	kmem_free(lbp->lb_path, len);

	kmem_free(lbp, sizeof (*lbp));

	rfsl_log_buffer--;

}

/*

 * Creates the corresponding log_file structure for the buffer

 * named 'log_file_name'.

 * 'log_file_name' is created by concatenating 'origname' and LOG_INPROG_STRING.

 * 'logfile' is set to be the log_file structure with reference one.

 */

static int

log_file_create(caddr_t origname, struct log_file **lfpp)

{

	vnode_t *vp = NULL;

	char *name;

	int namelen;

	int error;

	struct log_file *logfile = NULL;

	vattr_t va;

	caddr_t loghdr = NULL;

	size_t loghdr_len = 0;

	size_t loghdr_free = 0;

	namelen = strlen(origname) + strlen(LOG_INPROG_STRING);

	name = (caddr_t)kmem_alloc(namelen + 1, KM_SLEEP);

	(void) sprintf(name, "%s%s", origname, LOG_INPROG_STRING);

	LOGGING_DPRINT((3, "log_file_create: %s\n", name));

	if (error = vn_open(name, UIO_SYSSPACE, FCREAT|FWRITE|FOFFMAX,

			LOG_MODE, &vp, CRCREAT, 0)) {

		nfs_cmn_err(error, CE_WARN,

			"log_file_create: Can not open %s - error %m", name);

		goto out;

	}

	LOGGING_DPRINT((3, "log_file_create: %s vp=%p v_count=%d\n",

		name, vp, vp->v_count));

	logfile = (struct log_file *)kmem_zalloc(sizeof (*logfile), KM_SLEEP);

	logfile->lf_path = name;

	/*

	 * No need to bump the vnode reference count since it is set

	 * to one by vn_open().

	 */

	logfile->lf_vp = vp;

	logfile->lf_refcnt = 1;

	mutex_init(&logfile->lf_lock, NULL, MUTEX_DEFAULT, NULL);

	rfsl_log_file++;

	va.va_mask = AT_SIZE;

	error = VOP_GETATTR(vp, &va, 0, CRED());

	if (error) {

		nfs_cmn_err(error, CE_WARN,

			"log_file_create: Can not stat %s - error = %m",

			name);

		goto out;

	}

	if (va.va_size == 0) {

		struct lr_alloc lr;

		/*

		 * Write Header.

		 */

		create_buffer_header(&loghdr, &loghdr_len, &loghdr_free);

		/*

		 * Dummy up a lr_alloc struct for the write

		 */

		lr.next = lr.prev = &lr;

		lr.lr_flags = 0;

		lr.log_record = loghdr;

		lr.size = loghdr_len;

		lr.alloc_cache = NULL;

		lr.exi = NULL;

		lr.lb = NULL;

		mutex_enter(&logfile->lf_lock);

		error = nfslog_write_logrecords(logfile, &lr, 1);

		mutex_exit(&logfile->lf_lock);

		if (error != 0) {

			nfs_cmn_err(error, CE_WARN,

				"log_file_create: Can not write header "

				"on %s - error = %m", name);

			goto out;

		}

	}

	*lfpp = logfile;

	if (loghdr != NULL)

		kmem_free(loghdr, loghdr_free);

	return (0);

out:

	if (vp != NULL) {

		int error1;

		error1 = VOP_CLOSE(vp, FCREAT|FWRITE|FOFFMAX, 1, (offset_t)0,

				CRED());

		if (error1) {

			nfs_cmn_err(error1, CE_WARN,

				"log_file_create: Can not close %s - "

				"error = %m", name);

		}

		VN_RELE(vp);

	}

	kmem_free(name, namelen + 1);

	if (logfile != NULL) {