/*

 * 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) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/

/*	  All Rights Reserved  	*/

/*

 * University Copyright- Copyright (c) 1982, 1986, 1988

 * The Regents of the University of California

 * All Rights Reserved

 *

 * University Acknowledgment- Portions of this document are derived from

 * software developed by the University of California, Berkeley, and its

 * contributors.

 */

#include <sys/types.h>

#include <sys/thread.h>

#include <sys/t_lock.h>

#include <sys/param.h>

#include <sys/systm.h>

#include <sys/bitmap.h>

#include <sys/buf.h>

#include <sys/cmn_err.h>

#include <sys/conf.h>

#include <sys/ddi.h>

#include <sys/debug.h>

#include <sys/errno.h>

#include <sys/time.h>

#include <sys/fcntl.h>

#include <sys/flock.h>

#include <sys/file.h>

#include <sys/kmem.h>

#include <sys/mman.h>

#include <sys/vmsystm.h>

#include <sys/open.h>

#include <sys/swap.h>

#include <sys/sysmacros.h>

#include <sys/uio.h>

#include <sys/vfs.h>

#include <sys/vfs_opreg.h>

#include <sys/vnode.h>

#include <sys/stat.h>

#include <sys/poll.h>

#include <sys/zmod.h>

#include <sys/fs/decomp.h>

#include <vm/hat.h>

#include <vm/as.h>

#include <vm/page.h>

#include <vm/pvn.h>

#include <vm/seg_vn.h>

#include <vm/seg_kmem.h>

#include <vm/seg_map.h>

#include <fs/fs_subr.h>

/*

 * dcfs - A filesystem for automatic decompressing of fiocompressed files

 *

 * This filesystem is a layered filesystem that sits on top of a normal

 * persistent filesystem and provides automatic decompression of files

 * that have been previously compressed and stored on the host file system.

 * This is a pseudo filesystem in that it does not persist data, rather it

 * intercepts file lookup requests on the host filesystem and provides

 * transparent decompression of those files. Currently the only supported

 * host filesystem is ufs.

 *

 * A file is compressed via a userland utility (currently cmd/boot/fiocompress)

 * and marked by fiocompress as a compressed file via a flag in the on-disk

 * inode (set via a ufs ioctl() - see `ufs_vnops.c`ufs_ioctl()`_FIO_COMPRESSED

 * ufs_lookup checks for this flag and if set, passes control to decompvp

 * a function defined in this (dcfs) filesystem. decomvp uncompresses the file

 * and returns a dcfs vnode to the VFS layer.

 *

 * dcfs is layered on top of ufs and passes requests involving persistence

 * to the underlying ufs filesystem. The compressed files currently cannot be

 * written to.

 */

/*

 * Define data structures within this file.

 */

#define	DCSHFT		5

#define	DCTABLESIZE	16

#if ((DCTABLESIZE & (DCTABLESIZE - 1)) == 0)

#define	DCHASH(vp) (((uintptr_t)(vp) >> DCSHFT) & (DCTABLESIZE - 1))

#else

#define	DCHASH(vp) (((uintptr_t)(vp) >> DCSHFT) % DTABLESIZEC)

#endif

#define	DCLRUSIZE	16

#define	DCCACHESIZE	4

#define	rounddown(x, y)	((x) & ~((y) - 1))

struct dcnode	*dctable[DCTABLESIZE];

struct dcnode	*dclru;

static int	dclru_len;

kmutex_t	dctable_lock;

dev_t		dcdev;

struct vfs	dc_vfs;

struct kmem_cache *dcnode_cache;

struct kmem_cache *dcbuf_cache[DCCACHESIZE];

kmutex_t	dccache_lock;

static int dcinit(int, char *);

static struct dcnode	*dcnode_alloc(void);

static void		dcnode_free(struct dcnode *);

static void		dcnode_recycle(struct dcnode *);

static void		dcinsert(struct dcnode *);

static void		dcdelete(struct dcnode *);

static struct dcnode	*dcfind(struct vnode *);

static void		dclru_add(struct dcnode *);

static void		dclru_sub(struct dcnode *);

/*

 * This is the loadable module wrapper.

 */

#include <sys/modctl.h>

struct vfsops *dc_vfsops;

static vfsdef_t vfw = {

	VFSDEF_VERSION,

	"dcfs",

	dcinit,

	NULL

};

/*

 * Module linkage information for the kernel.

 */

extern struct mod_ops mod_fsops;

static struct modlfs modlfs = {

	&mod_fsops, "compressed filesystem", &vfw

};

static struct modlinkage modlinkage = {

	MODREV_1, (void *)&modlfs, NULL

};

int

_init()

{

	return (mod_install(&modlinkage));

}

int

_info(struct modinfo *modinfop)

{

	return (mod_info(&modlinkage, modinfop));

}

static int dc_open(struct vnode **, int, struct cred *, caller_context_t *);

static int dc_close(struct vnode *, int, int, offset_t,

    struct cred *, caller_context_t *);

static int dc_read(struct vnode *, struct uio *, int, struct cred *,

    struct caller_context *);

static int dc_getattr(struct vnode *, struct vattr *, int,

    struct cred *, caller_context_t *);

static int dc_setattr(struct vnode *, struct vattr *, int, struct cred *,

    struct caller_context *);

static int dc_access(struct vnode *, int, int,

    struct cred *, caller_context_t *);

static int dc_fsync(struct vnode *, int, struct cred *, caller_context_t *);

static void dc_inactive(struct vnode *, struct cred *, caller_context_t *);

static int dc_fid(struct vnode *, struct fid *, caller_context_t *);

static int dc_seek(struct vnode *, offset_t, offset_t *, caller_context_t *);

static int dc_frlock(struct vnode *, int, struct flock64 *, int, offset_t,

    struct flk_callback *, struct cred *, caller_context_t *);

static int dc_getpage(struct vnode *, offset_t, size_t, uint_t *,

    struct page **, size_t, struct seg *, caddr_t, enum seg_rw,

    struct cred *, caller_context_t *);

static int dc_putpage(struct vnode *, offset_t, size_t, int,

    struct cred *, caller_context_t *);

static int dc_map(struct vnode *, offset_t, struct as *, caddr_t *, size_t,

    uchar_t, uchar_t, uint_t, struct cred *, caller_context_t *);

static int dc_addmap(struct vnode *, offset_t, struct as *, caddr_t, size_t,

    uchar_t, uchar_t, uint_t, struct cred *, caller_context_t *);

static int dc_delmap(struct vnode *, offset_t, struct as *, caddr_t, size_t,

    uint_t, uint_t, uint_t, struct cred *, caller_context_t *);

struct vnodeops *dc_vnodeops;

const fs_operation_def_t dc_vnodeops_template[] = {

	VOPNAME_OPEN,			{ .vop_open = dc_open },

	VOPNAME_CLOSE,			{ .vop_close = dc_close },

	VOPNAME_READ,			{ .vop_read = dc_read },

	VOPNAME_GETATTR,		{ .vop_getattr =  dc_getattr },

	VOPNAME_SETATTR,		{ .vop_setattr = dc_setattr },

	VOPNAME_ACCESS,			{ .vop_access = dc_access },

	VOPNAME_FSYNC,			{ .vop_fsync = dc_fsync },

	VOPNAME_INACTIVE,		{ .vop_inactive = dc_inactive },

	VOPNAME_FID,			{ .vop_fid = dc_fid },

	VOPNAME_SEEK,			{ .vop_seek = dc_seek },

	VOPNAME_FRLOCK,			{ .vop_frlock = dc_frlock },

	VOPNAME_GETPAGE,		{ .vop_getpage = dc_getpage },

	VOPNAME_PUTPAGE,		{ .vop_putpage = dc_putpage },

	VOPNAME_MAP,			{ .vop_map = dc_map },

	VOPNAME_ADDMAP,			{ .vop_addmap = dc_addmap },

	VOPNAME_DELMAP,			{ .vop_delmap = dc_delmap },

	NULL,				NULL

};

/*ARGSUSED*/

static int

dc_open(struct vnode **vpp, int flag, struct cred *cr, caller_context_t *ctp)

{

	return (0);

}

/*ARGSUSED*/

static int

dc_close(struct vnode *vp, int flag, int count, offset_t off,

    struct cred *cr, caller_context_t *ctp)

{

	(void) cleanlocks(vp, ttoproc(curthread)->p_pid, 0);

	cleanshares(vp, ttoproc(curthread)->p_pid);

	return (0);

}

/*ARGSUSED*/

static int

dc_read(struct vnode *vp, struct uio *uiop, int ioflag, struct cred *cr,

	struct caller_context *ct)

{

	struct dcnode *dp = VTODC(vp);

	size_t rdsize = MAX(MAXBSIZE, dp->dc_hdr->ch_blksize);

	size_t fsize = dp->dc_hdr->ch_fsize;

	int error;

	/*

	 * Loop through file with segmap, decompression will occur

	 * in dc_getapage

	 */

	do {

		caddr_t base;

		size_t n;

		offset_t mapon;

		/*

		 * read to end of block or file

		 */

		mapon = uiop->uio_loffset & (rdsize - 1);

		n = MIN(rdsize - mapon, uiop->uio_resid);

		n = MIN(n, fsize - uiop->uio_loffset);

		if (n == 0)

			return (0);	/* at EOF */

		base = segmap_getmapflt(segkmap, vp, uiop->uio_loffset, n, 1,

		    S_READ);

		error = uiomove(base + mapon, n, UIO_READ, uiop);

		if (!error) {

			uint_t flags;

			if (n + mapon == rdsize || uiop->uio_loffset == fsize)

				flags = SM_DONTNEED;

			else

				flags = 0;

			error = segmap_release(segkmap, base, flags);

		} else

			(void) segmap_release(segkmap, base, 0);

	} while (!error && uiop->uio_resid);

	return (error);

}

static int

dc_getattr(struct vnode *vp, struct vattr *vap, int flags,

    cred_t *cred, caller_context_t *ctp)

{

	struct dcnode *dp = VTODC(vp);

	struct vnode *subvp = dp->dc_subvp;

	int error;

	error = VOP_GETATTR(subvp, vap, flags, cred, ctp);

	/* substitute uncompressed size */

	vap->va_size = dp->dc_hdr->ch_fsize;

	return (error);

}

static int

dc_setattr(struct vnode *vp, struct vattr *vap, int flags, cred_t *cred,

    caller_context_t *ctp)

{

	struct dcnode *dp = VTODC(vp);

	struct vnode *subvp = dp->dc_subvp;

	return (VOP_SETATTR(subvp, vap, flags, cred, ctp));

}

static int

dc_access(struct vnode *vp, int mode, int flags,

    cred_t *cred, caller_context_t *ctp)

{

	struct dcnode *dp = VTODC(vp);

	struct vnode *subvp = dp->dc_subvp;

	return (VOP_ACCESS(subvp, mode, flags, cred, ctp));

}

/*ARGSUSED*/

static int

dc_fsync(vnode_t *vp, int syncflag, cred_t *cred, caller_context_t *ctp)

{

	return (0);

}

/*ARGSUSED*/

static void

dc_inactive(struct vnode *vp, cred_t *cr, caller_context_t *ctp)

{

	struct dcnode *dp = VTODC(vp);

	mutex_enter(&dctable_lock);

	mutex_enter(&vp->v_lock);

	ASSERT(vp->v_count >= 1);

	if (--vp->v_count != 0) {

		/*

		 * Somebody accessed the dcnode before we got a chance to

		 * remove it.  They will remove it when they do a vn_rele.

		 */

		mutex_exit(&vp->v_lock);

		mutex_exit(&dctable_lock);

		return;

	}

	mutex_exit(&vp->v_lock);

	dcnode_free(dp);

	mutex_exit(&dctable_lock);

}

static int

dc_fid(struct vnode *vp, struct fid *fidp, caller_context_t *ctp)

{

	struct dcnode *dp = VTODC(vp);

	struct vnode *subvp = dp->dc_subvp;

	return (VOP_FID(subvp, fidp, ctp));

}

static int

dc_seek(struct vnode *vp, offset_t oof, offset_t *noffp, caller_context_t *ctp)

{

	struct dcnode *dp = VTODC(vp);

	struct vnode *subvp = dp->dc_subvp;

	return (VOP_SEEK(subvp, oof, noffp, ctp));

}

static int

dc_frlock(struct vnode *vp, int cmd, struct flock64 *bfp, int flag,

    offset_t offset, struct flk_callback *flk_cbp,

    cred_t *cr, caller_context_t *ctp)

{

	struct dcnode *dp = VTODC(vp);

	/*

	 * If file is being mapped, disallow frlock.

	 */

	if (dp->dc_mapcnt > 0)

		return (EAGAIN);

	return (fs_frlock(vp, cmd, bfp, flag, offset, flk_cbp, cr, ctp));

}

/*ARGSUSED*/

static int

dc_getblock_miss(struct vnode *vp, offset_t off, size_t len, struct page **ppp,

    struct seg *seg, caddr_t addr, enum seg_rw rw, struct cred *cr)

{

	struct dcnode *dp = VTODC(vp);

	struct comphdr *hdr = dp->dc_hdr;

	struct page *pp;

	struct buf *bp;

	caddr_t saddr;

	off_t cblkno;

	size_t rdoff, rdsize, dsize;

	long xlen;

	int error, zerr;

	ASSERT(len == hdr->ch_blksize);

	/*

	 * Get destination pages and make them addressable

	 */

	pp = page_create_va(vp, off, len, PG_WAIT, seg, addr);

	bp = pageio_setup(pp, len, vp, B_READ);

	bp_mapin(bp);

	/*

	 * read compressed data from subordinate vnode

	 */

	saddr = kmem_cache_alloc(dp->dc_bufcache, KM_SLEEP);

	cblkno = off / len;

	rdoff = hdr->ch_blkmap[cblkno];

	rdsize = hdr->ch_blkmap[cblkno + 1] - rdoff;

	error = vn_rdwr(UIO_READ, dp->dc_subvp, saddr, rdsize, rdoff,

	    UIO_SYSSPACE, 0, 0, cr, NULL);

	if (error)

		goto cleanup;

	/*

	 * Uncompress

	 */

	dsize = len;

	zerr = z_uncompress(bp->b_un.b_addr, &dsize, saddr, dp->dc_zmax);

	if (zerr != Z_OK) {

		error = EIO;

		goto cleanup;

	}

	/*

	 * Handle EOF

	 */

	xlen = hdr->ch_fsize - off;

	if (xlen < len) {

		bzero(bp->b_un.b_addr + xlen, len - xlen);

		if (dsize != xlen)

			error = EIO;

	} else if (dsize != len)

		error = EIO;

	/*

	 * Clean up

	 */

cleanup:

	kmem_cache_free(dp->dc_bufcache, saddr);

	pageio_done(bp);

	*ppp = pp;

	return (error);

}

static int

dc_getblock(struct vnode *vp, offset_t off, size_t len, struct page **ppp,

    struct seg *seg, caddr_t addr, enum seg_rw rw, struct cred *cr)

{

	struct page *pp, *plist = NULL;

	offset_t pgoff;

	int rdblk;

	/*

	 * pvn_read_kluster() doesn't quite do what we want, since it

	 * thinks sub block reads are ok.  Here we always decompress

	 * a full block.

	 */

	/*

	 * Check page cache

	 */

	rdblk = 0;

	for (pgoff = off; pgoff < off + len; pgoff += PAGESIZE) {

		pp = page_lookup(vp, pgoff, SE_EXCL);

		if (pp == NULL) {

			rdblk = 1;

			break;

		}

		page_io_lock(pp);

		page_add(&plist, pp);

		plist = plist->p_next;

	}

	if (!rdblk) {

		*ppp = plist;

		return (0);	/* all pages in cache */

	}

	/*

	 * Undo any locks so getblock_miss has an open field

	 */

	if (plist != NULL)

		pvn_io_done(plist);

	return (dc_getblock_miss(vp, off, len, ppp, seg, addr, rw, cr));

}

/*ARGSUSED10*/

static int

dc_getpage(struct vnode *vp, offset_t off, size_t len, uint_t *protp,

    struct page *pl[], size_t plsz, struct seg *seg, caddr_t addr,

    enum seg_rw rw, struct cred *cr, caller_context_t *ctp)

{

	struct dcnode *dp = VTODC(vp);

	struct comphdr *hdr = dp->dc_hdr;

	struct page *pp, *plist = NULL;

	caddr_t vp_baddr;

	offset_t vp_boff, vp_bend;

	size_t bsize = hdr->ch_blksize;

	int nblks, error;

	/* does not support write */