/*

 * CDDL HEADER START

 *

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

 * Common Development and Distribution License, Version 1.0 only

 * (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/types.h>

#include <sys/param.h>

#include <sys/time.h>

#include <sys/systm.h>

#include <sys/sysmacros.h>

#include <sys/resource.h>

#include <sys/vfs.h>

#include <sys/vnode.h>

#include <sys/file.h>

#include <sys/stat.h>

#include <sys/kmem.h>

#include <sys/taskq.h>

#include <sys/uio.h>

#include <sys/vmsystm.h>

#include <sys/atomic.h>

#include <vm/seg_vn.h>

#include <vm/pvn.h>

#include <vm/as.h>

#include <sys/mman.h>

#include <sys/pathname.h>

#include <sys/cmn_err.h>

#include <sys/errno.h>

#include <sys/unistd.h>

#include <sys/zfs_vfsops.h>

#include <sys/zfs_dir.h>

#include <sys/zfs_acl.h>

#include <sys/zfs_ioctl.h>

#include <sys/fs/zfs.h>

#include <sys/dmu.h>

#include <sys/spa.h>

#include <sys/txg.h>

#include <sys/refcount.h>  /* temporary for debugging purposes */

#include <sys/dbuf.h>

#include <sys/zap.h>

#include <sys/dirent.h>

#include <sys/policy.h>

#include <sys/sunddi.h>

#include <sys/filio.h>

#include "fs/fs_subr.h"

#include <sys/zfs_ctldir.h>

/*

 * Programming rules.

 *

 * Each vnode op performs some logical unit of work.  To do this, the ZPL must

 * properly lock its in-core state, create a DMU transaction, do the work,

 * record this work in the intent log (ZIL), commit the DMU transaction,

 * and wait the the intent log to commit if it's is a synchronous operation.

 * Morover, the vnode ops must work in both normal and log replay context.

 * The ordering of events is important to avoid deadlocks and references

 * to freed memory.  The example below illustrates the following Big Rules:

 *

 *  (1) A check must be made in each zfs thread for a mounted file system.

 *	This is done avoiding races using ZFS_ENTER(zfsvfs).

 *	A ZFS_EXIT(zfsvfs) is needed before all returns.

 *

 *  (2)	VN_RELE() should always be the last thing except for zil_commit()

 *	and ZFS_EXIT(). This is for 3 reasons:

 *	First, if it's the last reference, the vnode/znode

 *	can be freed, so the zp may point to freed memory.  Second, the last

 *	reference will call zfs_zinactive(), which may induce a lot of work --

 *	pushing cached pages (which requires z_grow_lock) and syncing out

 *	cached atime changes.  Third, zfs_zinactive() may require a new tx,

 *	which could deadlock the system if you were already holding one.

 *

 *  (3)	Always pass zfsvfs->z_assign as the second argument to dmu_tx_assign().

 *	In normal operation, this will be TXG_NOWAIT.  During ZIL replay,

 *	it will be a specific txg.  Either way, dmu_tx_assign() never blocks.

 *	This is critical because we don't want to block while holding locks.

 *	Note, in particular, that if a lock is sometimes acquired before

 *	the tx assigns, and sometimes after (e.g. z_lock), then failing to

 *	use a non-blocking assign can deadlock the system.  The scenario:

 *

 *	Thread A has grabbed a lock before calling dmu_tx_assign().

 *	Thread B is in an already-assigned tx, and blocks for this lock.

 *	Thread A calls dmu_tx_assign(TXG_WAIT) and blocks in txg_wait_open()

 *	forever, because the previous txg can't quiesce until B's tx commits.

 *

 *	If dmu_tx_assign() returns ERESTART and zfsvfs->z_assign is TXG_NOWAIT,

 *	then drop all locks, call txg_wait_open(), and try again.

 *

 *  (4)	If the operation succeeded, generate the intent log entry for it

 *	before dropping locks.  This ensures that the ordering of events

 *	in the intent log matches the order in which they actually occurred.

 *

 *  (5)	At the end of each vnode op, the DMU tx must always commit,

 *	regardless of whether there were any errors.

 *

 *  (6)	After dropping all locks, invoke zil_commit(zilog, seq, ioflag)

 *	to ensure that synchronous semantics are provided when necessary.

 *

 * In general, this is how things should be ordered in each vnode op:

 *

 *	ZFS_ENTER(zfsvfs);		// exit if unmounted

 * top:

 *	zfs_dirent_lock(&dl, ...)	// lock directory entry (may VN_HOLD())

 *	rw_enter(...);			// grab any other locks you need

 *	tx = dmu_tx_create(...);	// get DMU tx

 *	dmu_tx_hold_*();		// hold each object you might modify

 *	error = dmu_tx_assign(tx, zfsvfs->z_assign);	// try to assign

 *	if (error) {

 *		dmu_tx_abort(tx);	// abort DMU tx

 *		rw_exit(...);		// drop locks

 *		zfs_dirent_unlock(dl);	// unlock directory entry

 *		VN_RELE(...);		// release held vnodes

 *		if (error == ERESTART && zfsvfs->z_assign == TXG_NOWAIT) {

 *			txg_wait_open(dmu_objset_pool(os), 0);

 *			goto top;

 *		}

 *		ZFS_EXIT(zfsvfs);	// finished in zfs

 *		return (error);		// really out of space

 *	}

 *	error = do_real_work();		// do whatever this VOP does

 *	if (error == 0)

 *		seq = zfs_log_*(...);	// on success, make ZIL entry

 *	dmu_tx_commit(tx);		// commit DMU tx -- error or not

 *	rw_exit(...);			// drop locks

 *	zfs_dirent_unlock(dl);		// unlock directory entry

 *	VN_RELE(...);			// release held vnodes

 *	zil_commit(zilog, seq, ioflag);	// synchronous when necessary

 *	ZFS_EXIT(zfsvfs);		// finished in zfs

 *	return (error);			// done, report error

 */

/* ARGSUSED */

static int

zfs_open(vnode_t **vpp, int flag, cred_t *cr)

{

	return (0);

}

/* ARGSUSED */

static int

zfs_close(vnode_t *vp, int flag, int count, offset_t offset, cred_t *cr)

{

	/*

	 * Clean up any locks held by this process on the vp.

	 */

	cleanlocks(vp, ddi_get_pid(), 0);

	cleanshares(vp, ddi_get_pid());

	return (0);

}

/*

 * Lseek support for finding holes (cmd == _FIO_SEEK_HOLE) and

 * data (cmd == _FIO_SEEK_DATA). "off" is an in/out parameter.

 */

static int

zfs_holey(vnode_t *vp, int cmd, offset_t *off)

{

	znode_t	*zp = VTOZ(vp);

	uint64_t noff = (uint64_t)*off; /* new offset */

	uint64_t file_sz;

	int error;

	boolean_t hole;

	rw_enter(&zp->z_grow_lock, RW_READER);

	file_sz = zp->z_phys->zp_size;

	if (noff >= file_sz)  {

		rw_exit(&zp->z_grow_lock);

		return (ENXIO);

	}

	if (cmd == _FIO_SEEK_HOLE)

		hole = B_TRUE;

	else

		hole = B_FALSE;

	error = dmu_offset_next(zp->z_zfsvfs->z_os, zp->z_id, hole, &noff);

	rw_exit(&zp->z_grow_lock);

	/* end of file? */

	if ((error == ESRCH) || (noff > file_sz)) {

		/*

		 * Handle the virtual hole at the end of file.

		 */

		if (hole) {

			*off = file_sz;

			return (0);

		}

		return (ENXIO);

	}

	if (noff < *off)

		return (error);

	*off = noff;

	return (error);

}

/* ARGSUSED */

static int

zfs_ioctl(vnode_t *vp, int com, intptr_t data, int flag, cred_t *cred,

    int *rvalp)

{

	offset_t off;

	int error;

	zfsvfs_t *zfsvfs;

	switch (com) {

	    case _FIOFFS:

		return (zfs_sync(vp->v_vfsp, 0, cred));

	    case _FIO_SEEK_DATA:

	    case _FIO_SEEK_HOLE:

		if (ddi_copyin((void *)data, &off, sizeof (off), flag))

			return (EFAULT);

		zfsvfs = VTOZ(vp)->z_zfsvfs;

		ZFS_ENTER(zfsvfs);

		/* offset parameter is in/out */

		error = zfs_holey(vp, com, &off);

		ZFS_EXIT(zfsvfs);

		if (error)

			return (error);

		if (ddi_copyout(&off, (void *)data, sizeof (off), flag))

			return (EFAULT);

		return (0);

	}

	return (ENOTTY);

}

/*

 * When a file is memory mapped, we must keep the IO data synchronized

 * between the DMU cache and the memory mapped pages.  What this means:

 *

 * On Write:	If we find a memory mapped page, we write to *both*

 *		the page and the dmu buffer.

 *

 * NOTE: We will always "break up" the IO into PAGESIZE uiomoves when

 *	the file is memory mapped.

 */

static int

mappedwrite(vnode_t *vp, uint64_t woff, int nbytes, uio_t *uio, dmu_tx_t *tx)

{

	znode_t	*zp = VTOZ(vp);

	zfsvfs_t *zfsvfs = zp->z_zfsvfs;

	int64_t	start, off;

	int len = nbytes;

	int error = 0;

	start = uio->uio_loffset;

	off = start & PAGEOFFSET;

	for (start &= PAGEMASK; len > 0; start += PAGESIZE) {

		page_t *pp;

		uint64_t bytes = MIN(PAGESIZE - off, len);

		/*

		 * We don't want a new page to "appear" in the middle of

		 * the file update (because it may not get the write

		 * update data), so we grab a lock to block

		 * zfs_getpage().

		 */

		rw_enter(&zp->z_map_lock, RW_WRITER);

		if (pp = page_lookup(vp, start, SE_SHARED)) {

			caddr_t va;

			rw_exit(&zp->z_map_lock);

			va = ppmapin(pp, PROT_READ | PROT_WRITE, (caddr_t)-1L);

			error = uiomove(va+off, bytes, UIO_WRITE, uio);

			if (error == 0) {

				dmu_write(zfsvfs->z_os, zp->z_id,

				    woff, bytes, va+off, tx);

			}

			ppmapout(va);

			page_unlock(pp);

		} else {

			error = dmu_write_uio(zfsvfs->z_os, zp->z_id,

			    woff, bytes, uio, tx);

			rw_exit(&zp->z_map_lock);

		}

		len -= bytes;

		woff += bytes;

		off = 0;

		if (error)

			break;

	}

	return (error);

}

/*

 * When a file is memory mapped, we must keep the IO data synchronized

 * between the DMU cache and the memory mapped pages.  What this means:

 *

 * On Read:	We "read" preferentially from memory mapped pages,

 *		else we default from the dmu buffer.

 *

 * NOTE: We will always "break up" the IO into PAGESIZE uiomoves when

 *	the file is memory mapped.

 */

static int

mappedread(vnode_t *vp, char *addr, int nbytes, uio_t *uio)

{

	int64_t	start, off, bytes;

	int len = nbytes;

	int error = 0;

	start = uio->uio_loffset;

	off = start & PAGEOFFSET;

	for (start &= PAGEMASK; len > 0; start += PAGESIZE) {

		page_t *pp;

		bytes = MIN(PAGESIZE - off, len);

		if (pp = page_lookup(vp, start, SE_SHARED)) {

			caddr_t va;

			va = ppmapin(pp, PROT_READ | PROT_WRITE, (caddr_t)-1L);

			error = uiomove(va + off, bytes, UIO_READ, uio);

			ppmapout(va);

			page_unlock(pp);

		} else {

			/* XXX use dmu_read here? */

			error = uiomove(addr, bytes, UIO_READ, uio);

		}

		len -= bytes;

		addr += bytes;

		off = 0;

		if (error)

			break;

	}

	return (error);

}

uint_t zfs_read_chunk_size = 1024 * 1024; /* Tunable */

/*

 * Read bytes from specified file into supplied buffer.

 *

 *	IN:	vp	- vnode of file to be read from.

 *		uio	- structure supplying read location, range info,

 *			  and return buffer.

 *		ioflag	- SYNC flags; used to provide FRSYNC semantics.

 *		cr	- credentials of caller.

 *

 *	OUT:	uio	- updated offset and range, buffer filled.

 *

 *	RETURN:	0 if success

 *		error code if failure

 *

 * Side Effects:

 *	vp - atime updated if byte count > 0

 */

/* ARGSUSED */

static int

zfs_read(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cr, caller_context_t *ct)

{

	znode_t		*zp = VTOZ(vp);

	zfsvfs_t	*zfsvfs = zp->z_zfsvfs;

	uint64_t	delta;

	ssize_t		n, size, cnt, ndone;

	int		error, i, numbufs;

	dmu_buf_t	*dbp, **dbpp;

	ZFS_ENTER(zfsvfs);

	/*

	 * Validate file offset

	 */

	if (uio->uio_loffset < (offset_t)0) {

		ZFS_EXIT(zfsvfs);

		return (EINVAL);

	}

	/*

	 * Fasttrack empty reads

	 */

	if (uio->uio_resid == 0) {

		ZFS_EXIT(zfsvfs);

		return (0);

	}

	/*

	 * Check for region locks

	 */

	if (MANDMODE((mode_t)zp->z_phys->zp_mode)) {

		if (error = chklock(vp, FREAD,

		    uio->uio_loffset, uio->uio_resid, uio->uio_fmode, ct)) {

			ZFS_EXIT(zfsvfs);

			return (error);

		}

	}

	/*

	 * If we're in FRSYNC mode, sync out this znode before reading it.

	 */

	zil_commit(zfsvfs->z_log, zp->z_last_itx, ioflag & FRSYNC);

	/*

	 * Make sure nobody restructures the file (changes block size)

	 * in the middle of the read.

	 */

	rw_enter(&zp->z_grow_lock, RW_READER);

	/*

	 * If we are reading past end-of-file we can skip

	 * to the end; but we might still need to set atime.

	 */

	if (uio->uio_loffset >= zp->z_phys->zp_size) {

		cnt = 0;

		error = 0;

		goto out;

	}

	cnt = MIN(uio->uio_resid, zp->z_phys->zp_size - uio->uio_loffset);

	for (ndone = 0; ndone < cnt; ndone += zfs_read_chunk_size) {

		ASSERT(uio->uio_loffset < zp->z_phys->zp_size);

		n = MIN(zfs_read_chunk_size,

		    zp->z_phys->zp_size - uio->uio_loffset);

		n = MIN(n, cnt);

		dbpp = dmu_buf_hold_array(zfsvfs->z_os, zp->z_id,

		    uio->uio_loffset, n, &numbufs);

		if (error = dmu_buf_read_array_canfail(dbpp, numbufs)) {

			dmu_buf_rele_array(dbpp, numbufs);

			goto out;

		}

		/*

		 * Compute the adjustment to align the dmu buffers

		 * with the uio buffer.

		 */

		delta = uio->uio_loffset - dbpp[0]->db_offset;

		for (i = 0; i < numbufs; i++) {

			if (n < 0)

				break;

			dbp = dbpp[i];

			size = dbp->db_size - delta;

			/*

			 * XXX -- this is correct, but may be suboptimal.

			 * If the pages are all clean, we don't need to

			 * go through mappedread().  Maybe the VMODSORT

			 * stuff can help us here.

			 */

			if (vn_has_cached_data(vp)) {

				error = mappedread(vp, (caddr_t)dbp->db_data +

				    delta, (n < size ? n : size), uio);

			} else {

				error = uiomove((caddr_t)dbp->db_data + delta,

					(n < size ? n : size), UIO_READ, uio);

			}

			if (error) {

				dmu_buf_rele_array(dbpp, numbufs);

				goto out;

			}

			n -= dbp->db_size;

			if (delta) {

				n += delta;

				delta = 0;

			}

		}

		dmu_buf_rele_array(dbpp, numbufs);

	}

out:

	rw_exit(&zp->z_grow_lock);

	ZFS_ACCESSTIME_STAMP(zfsvfs, zp);

	ZFS_EXIT(zfsvfs);

	return (error);

}

/*

 * Fault in the pages of the first n bytes specified by the uio structure.

 * 1 byte in each page is touched and the uio struct is unmodified.

 * Any error will exit this routine as this is only a best

 * attempt to get the pages resident. This is a copy of ufs_trans_touch().

 */

static void

zfs_prefault_write(ssize_t n, struct uio *uio)

{

	struct iovec *iov;

	ulong_t cnt, incr;

	caddr_t p;

	uint8_t tmp;

	iov = uio->uio_iov;

	while (n) {

		cnt = MIN(iov->iov_len, n);

		if (cnt == 0) {

			/* empty iov entry */

			iov++;

			continue;

		}

		n -= cnt;

		/*

		 * touch each page in this segment.

		 */

		p = iov->iov_base;

		while (cnt) {

			switch (uio->uio_segflg) {

			case UIO_USERSPACE:

			case UIO_USERISPACE:

				if (fuword8(p, &tmp))

					return;

				break;

			case UIO_SYSSPACE:

				if (kcopy(p, &tmp, 1))

					return;

				break;

			}