/*

 * 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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.

 */

/* Portions Copyright 2007 Jeremy Teo */

/* Portions Copyright 2010 Robert Milkowski */

#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/vfs_opreg.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 <sys/vm.h>

#include <vm/seg_vn.h>

#include <vm/pvn.h>

#include <vm/as.h>

#include <vm/kpm.h>

#include <vm/seg_kpm.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_dir.h>

#include <sys/zfs_acl.h>

#include <sys/zfs_ioctl.h>

#include <sys/fs/zfs.h>

#include <sys/dmu.h>

#include <sys/dmu_objset.h>

#include <sys/spa.h>

#include <sys/txg.h>

#include <sys/dbuf.h>

#include <sys/zap.h>

#include <sys/sa.h>

#include <sys/dirent.h>

#include <sys/policy.h>

#include <sys/sunddi.h>

#include <sys/filio.h>

#include <sys/sid.h>

#include "fs/fs_subr.h"

#include <sys/zfs_ctldir.h>

#include <sys/zfs_fuid.h>

#include <sys/zfs_sa.h>

#include <sys/dnlc.h>

#include <sys/zfs_rlock.h>

#include <sys/extdirent.h>

#include <sys/kidmap.h>

#include <sys/cred.h>

#include <sys/attr.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 for the intent log to commit if it is a synchronous operation.

 * Moreover, 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.  Any znodes

 *      must be checked with ZFS_VERIFY_ZP(zp).  Both of these macros

 *      can return EIO from the calling function.

 *

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

 *	(if necessary) 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 acquires range locks) 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.

 *	If you must call VN_RELE() within a tx then use VN_RELE_ASYNC().

 *

 *  (3)	All range locks must be grabbed before calling dmu_tx_assign(),

 *	as they can span dmu_tx_assign() calls.

 *

 *  (4)	Always pass TXG_NOWAIT as the second argument to dmu_tx_assign().

 *	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 dmu_tx_wait(), and try again.

 *

 *  (5)	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.

 *      During ZIL replay the zfs_log_* functions will update the sequence

 *	number to indicate the zil transaction has replayed.

 *

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

 *	regardless of whether there were any errors.

 *

 *  (7)	After dropping all locks, invoke zil_commit(zilog, seq, foid)

 *	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, TXG_NOWAIT);	// try to assign

 *	if (error) {

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

 *		zfs_dirent_unlock(dl);	// unlock directory entry

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

 *		if (error == ERESTART) {

 *			dmu_tx_wait(tx);

 *			dmu_tx_abort(tx);

 *			goto top;

 *		}

 *		dmu_tx_abort(tx);	// abort DMU tx

 *		ZFS_EXIT(zfsvfs);	// finished in zfs

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

 *	}

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

 *	if (error == 0)

 *		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, foid);	// 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, caller_context_t *ct)

{

	znode_t	*zp = VTOZ(*vpp);

	zfsvfs_t *zfsvfs = zp->z_zfsvfs;

	ZFS_ENTER(zfsvfs);

	ZFS_VERIFY_ZP(zp);

	if ((flag & FWRITE) && (zp->z_pflags & ZFS_APPENDONLY) &&

	    ((flag & FAPPEND) == 0)) {

		ZFS_EXIT(zfsvfs);

		return (EPERM);

	}

	if (!zfs_has_ctldir(zp) && zp->z_zfsvfs->z_vscan &&

	    ZTOV(zp)->v_type == VREG &&

	    !(zp->z_pflags & ZFS_AV_QUARANTINED) && zp->z_size > 0) {

		if (fs_vscan(*vpp, cr, 0) != 0) {

			ZFS_EXIT(zfsvfs);

			return (EACCES);

		}

	}

	/* Keep a count of the synchronous opens in the znode */

	if (flag & (FSYNC | FDSYNC))

		atomic_inc_32(&zp->z_sync_cnt);

	ZFS_EXIT(zfsvfs);

	return (0);

}

/* ARGSUSED */

static int

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

    caller_context_t *ct)

{

	znode_t	*zp = VTOZ(vp);

	zfsvfs_t *zfsvfs = zp->z_zfsvfs;

	/*

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

	 */

	cleanlocks(vp, ddi_get_pid(), 0);

	cleanshares(vp, ddi_get_pid());

	ZFS_ENTER(zfsvfs);

	ZFS_VERIFY_ZP(zp);

	/* Decrement the synchronous opens in the znode */

	if ((flag & (FSYNC | FDSYNC)) && (count == 1))

		atomic_dec_32(&zp->z_sync_cnt);

	if (!zfs_has_ctldir(zp) && zp->z_zfsvfs->z_vscan &&

	    ZTOV(zp)->v_type == VREG &&

	    !(zp->z_pflags & ZFS_AV_QUARANTINED) && zp->z_size > 0)

		VERIFY(fs_vscan(vp, cr, 1) == 0);

	ZFS_EXIT(zfsvfs);

	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;

	file_sz = zp->z_size;

	if (noff >= file_sz)  {

		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);

	/* 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, caller_context_t *ct)

{

	offset_t off;

	int error;

	zfsvfs_t *zfsvfs;

	znode_t *zp;

	switch (com) {

	case _FIOFFS:

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

		/*

		 * The following two ioctls are used by bfu.  Faking out,

		 * necessary to avoid bfu errors.

		 */

	case _FIOGDIO:

	case _FIOSDIO:

		return (0);

	case _FIO_SEEK_DATA:

	case _FIO_SEEK_HOLE:

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

			return (EFAULT);

		zp = VTOZ(vp);

		zfsvfs = zp->z_zfsvfs;

		ZFS_ENTER(zfsvfs);

		ZFS_VERIFY_ZP(zp);

		/* 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);

}

/*

 * Utility functions to map and unmap a single physical page.  These

 * are used to manage the mappable copies of ZFS file data, and therefore

 * do not update ref/mod bits.

 */

caddr_t

zfs_map_page(page_t *pp, enum seg_rw rw)

{

	if (kpm_enable)

		return (hat_kpm_mapin(pp, 0));

	ASSERT(rw == S_READ || rw == S_WRITE);

	return (ppmapin(pp, PROT_READ | ((rw == S_WRITE) ? PROT_WRITE : 0),

	    (caddr_t)-1));

}

void

zfs_unmap_page(page_t *pp, caddr_t addr)

{

	if (kpm_enable) {

		hat_kpm_mapout(pp, 0, addr);

	} else {

		ppmapout(addr);

	}

}

/*

 * 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.

 */

static void

update_pages(vnode_t *vp, int64_t start, int len, objset_t *os, uint64_t oid)

{

	int64_t	off;

	off = start & PAGEOFFSET;

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

		page_t *pp;

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

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

			caddr_t va;

			va = zfs_map_page(pp, S_WRITE);

			(void) dmu_read(os, oid, start+off, nbytes, va+off,

			    DMU_READ_PREFETCH);

			zfs_unmap_page(pp, va);

			page_unlock(pp);

		}

		len -= nbytes;

		off = 0;

	}

}

/*

 * 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, int nbytes, uio_t *uio)

{

	znode_t *zp = VTOZ(vp);

	objset_t *os = zp->z_zfsvfs->z_os;

	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);

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

			caddr_t va;

			va = zfs_map_page(pp, S_READ);

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

			zfs_unmap_page(pp, va);

			page_unlock(pp);

		} else {

			error = dmu_read_uio(os, zp->z_id, uio, bytes);

		}

		len -= bytes;

		off = 0;

		if (error)

			break;

	}

	return (error);

}

offset_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.

 *		ct	- caller context

 *

 *	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;

	objset_t	*os;

	ssize_t		n, nbytes;

	int		error;

	rl_t		*rl;

	xuio_t		*xuio = NULL;

	ZFS_ENTER(zfsvfs);

	ZFS_VERIFY_ZP(zp);

	os = zfsvfs->z_os;

	if (zp->z_pflags & ZFS_AV_QUARANTINED) {

		ZFS_EXIT(zfsvfs);

		return (EACCES);

	}

	/*

	 * 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 mandatory locks

	 */

	if (MANDMODE(zp->z_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.

	 */

	if (ioflag & FRSYNC || zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)

		zil_commit(zfsvfs->z_log, zp->z_last_itx, zp->z_id);

	/*

	 * Lock the range against changes.

	 */

	rl = zfs_range_lock(zp, uio->uio_loffset, uio->uio_resid, RL_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_size) {

		error = 0;