/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2018 Joyent, Inc.
 */


#include <sys/types.h>
#include <sys/param.h>
#include <sys/errno.h>
#include <sys/cred.h>
#include <sys/kmem.h>
#include <sys/lgrp.h>
#include <sys/mman.h>

#include <vm/hat.h>
#include <vm/as.h>
#include <vm/seg.h>
#include <vm/seg_hole.h>


static int seghole_dup(struct seg *, struct seg *);
static int seghole_unmap(struct seg *, caddr_t, size_t);
static void seghole_free(struct seg *);
static faultcode_t seghole_fault(struct hat *, struct seg *, caddr_t, size_t,
    enum fault_type, enum seg_rw);
static faultcode_t seghole_faulta(struct seg *, caddr_t);
static int seghole_setprot(struct seg *, caddr_t, size_t, uint_t);
static int seghole_checkprot(struct seg *, caddr_t, size_t, uint_t);
static int seghole_sync(struct seg *, caddr_t, size_t, int, uint_t);
static size_t seghole_incore(struct seg *, caddr_t, size_t, char *);
static int seghole_lockop(struct seg *, caddr_t, size_t, int, int, ulong_t *,
    size_t);
static int seghole_getprot(struct seg *, caddr_t, size_t, uint_t *);
static u_offset_t seghole_getoffset(struct seg *, caddr_t);
static int seghole_gettype(struct seg *, caddr_t);
static int seghole_getvp(struct seg *, caddr_t, struct vnode **);
static int seghole_advise(struct seg *, caddr_t, size_t, uint_t);
static void seghole_dump(struct seg *);
static int seghole_pagelock(struct seg *, caddr_t, size_t, struct page ***,
    enum lock_type, enum seg_rw);
static int seghole_setpagesize(struct seg *, caddr_t, size_t, uint_t);
static int seghole_capable(struct seg *, segcapability_t);

static struct seg_ops seghole_ops = {
	seghole_dup,
	seghole_unmap,
	seghole_free,
	seghole_fault,
	seghole_faulta,
	seghole_setprot,
	seghole_checkprot,
	NULL,			/* kluster: disabled */
	NULL,			/* swapout: disabled */
	seghole_sync,
	seghole_incore,
	seghole_lockop,
	seghole_getprot,
	seghole_getoffset,
	seghole_gettype,
	seghole_getvp,
	seghole_advise,
	seghole_dump,
	seghole_pagelock,
	seghole_setpagesize,
	NULL,			/* getmemid: disabled */
	NULL,			/* getpolicy: disabled */
	seghole_capable,
	seg_inherit_notsup
};

/*
 * Create a hole in the AS.
 */
int
seghole_create(struct seg **segpp, void *argsp)
{
	struct seg *seg = *segpp;
	seghole_crargs_t *crargs = argsp;
	seghole_data_t *data;

	data = kmem_alloc(sizeof (seghole_data_t), KM_SLEEP);
	data->shd_name = crargs->name;

	seg->s_ops = &seghole_ops;
	seg->s_data = data;
	seg->s_flags = S_HOLE;

	return (0);
}

static int
seghole_dup(struct seg *seg, struct seg *newseg)
{
	seghole_data_t *shd = (seghole_data_t *)seg->s_data;
	seghole_data_t *newshd;

	ASSERT(seg->s_as && AS_WRITE_HELD(seg->s_as));

	newshd = kmem_zalloc(sizeof (seghole_data_t), KM_SLEEP);
	newshd->shd_name = shd->shd_name;

	newseg->s_ops = seg->s_ops;
	newseg->s_data = newshd;
	newseg->s_flags = S_HOLE;

	return (0);
}

static int
seghole_unmap(struct seg *seg, caddr_t addr, size_t len)
{
	ASSERT(seg->s_as && AS_WRITE_HELD(seg->s_as));

	/* Entire segment is being unmapped */
	if (addr == seg->s_base && len == seg->s_size) {
		seg_free(seg);
		return (0);
	}

	/* Shrinking from low address side */
	if (addr == seg->s_base) {
		seg->s_base += len;
		seg->s_size -= len;
		return (0);
	}

	/* Shrinking from high address side */
	if ((addr + len) == (seg->s_base + seg->s_size)) {
		seg->s_size -= len;
		return (0);
	}

	/* Do not tolerate splitting the segment */
	return (EINVAL);
}

static void
seghole_free(struct seg *seg)
{
	seghole_data_t *data = (seghole_data_t *)seg->s_data;

	ASSERT(data != NULL);

	kmem_free(data, sizeof (*data));
	seg->s_data = NULL;
}

/* ARGSUSED */
static faultcode_t
seghole_fault(struct hat *hat, struct seg *seg, caddr_t addr, size_t len,
    enum fault_type type, enum seg_rw tw)
{
	ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as));

	return (FC_NOMAP);
}

/* ARGSUSED */
static faultcode_t
seghole_faulta(struct seg *seg, caddr_t addr)
{
	return (FC_NOMAP);
}

/* ARGSUSED */
static int
seghole_setprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
{
	ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as));

	return (ENOMEM);
}

/* ARGSUSED */
static int
seghole_checkprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
{
	ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as));

	return (ENOMEM);
}

/* ARGSUSED */
static int
seghole_sync(struct seg *seg, caddr_t addr, size_t len, int attr, uint_t flags)
{
	/* Always succeed since there are no backing store to sync */
	return (0);
}

/* ARGSUSED */
static size_t
seghole_incore(struct seg *seg, caddr_t addr, size_t len, char *vec)
{
	ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as));

	return (0);
}

/* ARGSUSED */
static int
seghole_lockop(struct seg *seg, caddr_t addr, size_t len, int attr, int op,
    ulong_t *lockmap, size_t pos)
{
	/*
	 * Emit an error consistent with there being no segment in this hole in
	 * the AS.  The MC_LOCKAS and MC_UNLOCKAS commands will explicitly skip
	 * hole segments, allowing such operations to proceed as expected.
	 */
	return (ENOMEM);
}

static int
seghole_getprot(struct seg *seg, caddr_t addr, size_t len, uint_t *protv)
{
	size_t pgno;

	ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as));

	/*
	 * Few SEGOP_GETPROT callers actually check for an error, so it's
	 * necessary to report zeroed protection for the length of the request.
	 */
	pgno = seg_page(seg, addr + len) - seg_page(seg, addr) + 1;
	while (pgno > 0) {
		protv[--pgno] = 0;
	}

	return (ENOMEM);
}

/* ARGSUSED */
static u_offset_t
seghole_getoffset(struct seg *seg, caddr_t addr)
{
	/*
	 * To avoid leaking information about the layout of the kernel address
	 * space, always report '0' as the offset.
	 */
	return (0);
}

/* ARGSUSED */
static int
seghole_gettype(struct seg *seg, caddr_t addr)
{
	return (MAP_PRIVATE);
}

/* ARGSUSED */
static int
seghole_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp)
{
	ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as));

	return (ENOMEM);
}

/* ARGSUSED */
static int
seghole_advise(struct seg *seg, caddr_t addr, size_t len, uint_t behav)
{
	return (ENOMEM);
}

/* ARGSUSED */
static void
seghole_dump(struct seg *seg)
{
	/* There's nothing to dump from a hole in the AS */
}

/* ARGSUSED */
static int
seghole_pagelock(struct seg *seg, caddr_t addr, size_t len, struct page ***ppp,
    enum lock_type type, enum seg_rw rw)
{
	return (EFAULT);
}

/* ARGSUSED */
static int
seghole_setpagesize(struct seg *seg, caddr_t addr, size_t len, uint_t szc)
{
	return (ENOMEM);
}

/* ARGSUSED */
static int
seghole_capable(struct seg *seg, segcapability_t capability)
{
	/* no special capablities */
	return (0);
}