/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2017 Joyent, Inc.
 */

/*      Copyright (c) 1984, 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.
 */

#ifndef _VM_SEG_H
#define _VM_SEG_H

#include <sys/vnode.h>
#include <sys/avl.h>
#include <vm/seg_enum.h>
#include <vm/faultcode.h>
#include <vm/hat.h>

#ifdef  __cplusplus
extern "C" {
#endif

/*
 * VM - Segments.
 */

struct anon_map;

/*
 * kstat statistics for segment advise
 */
typedef struct {
        kstat_named_t MADV_FREE_hit;
        kstat_named_t MADV_FREE_miss;
} segadvstat_t;

/*
 * memory object ids
 */
typedef struct memid { u_longlong_t val[2]; } memid_t;

/*
 * An address space contains a set of segments, managed by drivers.
 * Drivers support mapped devices, sharing, copy-on-write, etc.
 *
 * The seg structure contains a lock to prevent races, the base virtual
 * address and size of the segment, a back pointer to the containing
 * address space, pointers to maintain an AVL tree of segments in the
 * same address space, and procedure and data hooks for the driver.
 * The AVL tree of segments for the address space is sorted by
 * ascending base addresses and overlapping segments are not allowed.
 *
 * After a segment is created, faults may occur on pages of the segment.
 * When a fault occurs, the fault handling code must get the desired
 * object and set up the hardware translation to the object.  For some
 * objects, the fault handling code also implements copy-on-write.
 *
 * When the hat wants to unload a translation, it can call the unload
 * routine which is responsible for processing reference and modify bits.
 *
 * Each segment is protected by it's containing address space lock.  To
 * access any field in the segment structure, the "as" must be locked.
 * If a segment field is to be modified, the address space lock must be
 * write locked.
 */

typedef struct pcache_link {
        struct pcache_link      *p_lnext;
        struct pcache_link      *p_lprev;
} pcache_link_t;

typedef struct seg {
        caddr_t s_base;                 /* base virtual address */
        size_t  s_size;                 /* size in bytes */
        uint_t  s_szc;                  /* max page size code */
        uint_t  s_flags;                /* flags for segment, see below */
        struct  as *s_as;               /* containing address space */
        avl_node_t s_tree;              /* AVL tree links to segs in this as */
        struct  seg_ops *s_ops;         /* ops vector: see below */
        void *s_data;                   /* private data for instance */
        kmutex_t s_pmtx;                /* protects seg's pcache list */
        pcache_link_t s_phead;          /* head of seg's pcache list */
} seg_t;

#define S_PURGE         (0x01)          /* seg should be purged in as_gap() */
#define S_HOLE          (0x02)          /* seg represents hole in AS */

struct  seg_ops {
        int     (*dup)(struct seg *, struct seg *);
        int     (*unmap)(struct seg *, caddr_t, size_t);
        void    (*free)(struct seg *);
        faultcode_t (*fault)(struct hat *, struct seg *, caddr_t, size_t,
            enum fault_type, enum seg_rw);
        faultcode_t (*faulta)(struct seg *, caddr_t);
        int     (*setprot)(struct seg *, caddr_t, size_t, uint_t);
        int     (*checkprot)(struct seg *, caddr_t, size_t, uint_t);
        int     (*kluster)(struct seg *, caddr_t, ssize_t);
        size_t  (*swapout)(struct seg *);
        int     (*sync)(struct seg *, caddr_t, size_t, int, uint_t);
        size_t  (*incore)(struct seg *, caddr_t, size_t, char *);
        int     (*lockop)(struct seg *, caddr_t, size_t, int, int, ulong_t *,
                        size_t);
        int     (*getprot)(struct seg *, caddr_t, size_t, uint_t *);
        u_offset_t      (*getoffset)(struct seg *, caddr_t);
        int     (*gettype)(struct seg *, caddr_t);
        int     (*getvp)(struct seg *, caddr_t, struct vnode **);
        int     (*advise)(struct seg *, caddr_t, size_t, uint_t);
        void    (*dump)(struct seg *);
        int     (*pagelock)(struct seg *, caddr_t, size_t, struct page ***,
                        enum lock_type, enum seg_rw);
        int     (*setpagesize)(struct seg *, caddr_t, size_t, uint_t);
        int     (*getmemid)(struct seg *, caddr_t, memid_t *);
        struct lgrp_mem_policy_info     *(*getpolicy)(struct seg *, caddr_t);
        int     (*capable)(struct seg *, segcapability_t);
        int     (*inherit)(struct seg *, caddr_t, size_t, uint_t);
};

#ifdef _KERNEL

/*
 * Generic segment operations
 */
extern  void    seg_init(void);
extern  struct  seg *seg_alloc(struct as *as, caddr_t base, size_t size);
extern  int     seg_attach(struct as *as, caddr_t base, size_t size,
                        struct seg *seg);
extern  void    seg_unmap(struct seg *seg);
extern  void    seg_free(struct seg *seg);

/*
 * functions for pagelock cache support
 */
typedef int (*seg_preclaim_cbfunc_t)(void *, caddr_t, size_t,
    struct page **, enum seg_rw, int);

extern  struct  page **seg_plookup(struct seg *seg, struct anon_map *amp,
    caddr_t addr, size_t len, enum seg_rw rw, uint_t flags);
extern  void    seg_pinactive(struct seg *seg, struct anon_map *amp,
    caddr_t addr, size_t len, struct page **pp, enum seg_rw rw,
    uint_t flags, seg_preclaim_cbfunc_t callback);

extern  void    seg_ppurge(struct seg *seg, struct anon_map *amp,
    uint_t flags);
extern  void    seg_ppurge_wiredpp(struct page **pp);

extern  int     seg_pinsert_check(struct seg *seg, struct anon_map *amp,
    caddr_t addr, size_t len, uint_t flags);
extern  int     seg_pinsert(struct seg *seg, struct anon_map *amp,
    caddr_t addr, size_t len, size_t wlen, struct page **pp, enum seg_rw rw,
    uint_t flags, seg_preclaim_cbfunc_t callback);

extern  void    seg_pasync_thread(void);
extern  void    seg_preap(void);
extern  int     seg_p_disable(void);
extern  void    seg_p_enable(void);

extern  segadvstat_t    segadvstat;

/*
 * Flags for pagelock cache support.
 * Flags argument is passed as uint_t to pcache routines.  upper 16 bits of
 * the flags argument are reserved for alignment page shift when SEGP_PSHIFT
 * is set.
 */
#define SEGP_FORCE_WIRED        0x1     /* skip check against seg_pwindow */
#define SEGP_AMP                0x2     /* anon map's pcache entry */
#define SEGP_PSHIFT             0x4     /* addr pgsz shift for hash function */

/*
 * Return values for seg_pinsert and seg_pinsert_check functions.
 */
#define SEGP_SUCCESS            0       /* seg_pinsert() succeeded */
#define SEGP_FAIL               1       /* seg_pinsert() failed */

/* Page status bits for segop_incore */
#define SEG_PAGE_INCORE         0x01    /* VA has a page backing it */
#define SEG_PAGE_LOCKED         0x02    /* VA has a page that is locked */
#define SEG_PAGE_HASCOW         0x04    /* VA has a page with a copy-on-write */
#define SEG_PAGE_SOFTLOCK       0x08    /* VA has a page with softlock held */
#define SEG_PAGE_VNODEBACKED    0x10    /* Segment is backed by a vnode */
#define SEG_PAGE_ANON           0x20    /* VA has an anonymous page */
#define SEG_PAGE_VNODE          0x40    /* VA has a vnode page backing it */

#define SEGOP_DUP(s, n)             (*(s)->s_ops->dup)((s), (n))
#define SEGOP_UNMAP(s, a, l)        (*(s)->s_ops->unmap)((s), (a), (l))
#define SEGOP_FREE(s)               (*(s)->s_ops->free)((s))
#define SEGOP_FAULT(h, s, a, l, t, rw) \
                (*(s)->s_ops->fault)((h), (s), (a), (l), (t), (rw))
#define SEGOP_FAULTA(s, a)          (*(s)->s_ops->faulta)((s), (a))
#define SEGOP_SETPROT(s, a, l, p)   (*(s)->s_ops->setprot)((s), (a), (l), (p))
#define SEGOP_CHECKPROT(s, a, l, p) (*(s)->s_ops->checkprot)((s), (a), (l), (p))
#define SEGOP_KLUSTER(s, a, d)      (*(s)->s_ops->kluster)((s), (a), (d))
#define SEGOP_SWAPOUT(s)            (*(s)->s_ops->swapout)((s))
#define SEGOP_SYNC(s, a, l, atr, f) \
                (*(s)->s_ops->sync)((s), (a), (l), (atr), (f))
#define SEGOP_INCORE(s, a, l, v)    (*(s)->s_ops->incore)((s), (a), (l), (v))
#define SEGOP_LOCKOP(s, a, l, atr, op, b, p) \
                (*(s)->s_ops->lockop)((s), (a), (l), (atr), (op), (b), (p))
#define SEGOP_GETPROT(s, a, l, p)   (*(s)->s_ops->getprot)((s), (a), (l), (p))
#define SEGOP_GETOFFSET(s, a)       (*(s)->s_ops->getoffset)((s), (a))
#define SEGOP_GETTYPE(s, a)         (*(s)->s_ops->gettype)((s), (a))
#define SEGOP_GETVP(s, a, vpp)      (*(s)->s_ops->getvp)((s), (a), (vpp))
#define SEGOP_ADVISE(s, a, l, b)    (*(s)->s_ops->advise)((s), (a), (l), (b))
#define SEGOP_DUMP(s)               (*(s)->s_ops->dump)((s))
#define SEGOP_PAGELOCK(s, a, l, p, t, rw) \
                (*(s)->s_ops->pagelock)((s), (a), (l), (p), (t), (rw))
#define SEGOP_SETPAGESIZE(s, a, l, szc) \
                (*(s)->s_ops->setpagesize)((s), (a), (l), (szc))
#define SEGOP_GETMEMID(s, a, mp)    (*(s)->s_ops->getmemid)((s), (a), (mp))
#define SEGOP_GETPOLICY(s, a)       (*(s)->s_ops->getpolicy)((s), (a))
#define SEGOP_CAPABLE(s, c)         (*(s)->s_ops->capable)((s), (c))
#define SEGOP_INHERIT(s, a, l, b)   (*(s)->s_ops->inherit)((s), (a), (l), (b))

#define seg_page(seg, addr) \
        (((uintptr_t)((addr) - (seg)->s_base)) >> PAGESHIFT)

#define seg_pages(seg) \
        (((uintptr_t)((seg)->s_size + PAGEOFFSET)) >> PAGESHIFT)

#define IE_NOMEM        -1      /* internal to seg layer */
#define IE_RETRY        -2      /* internal to seg layer */
#define IE_REATTACH     -3      /* internal to seg layer */

/* Values for SEGOP_INHERIT */
#define SEGP_INH_ZERO   0x01

int seg_inherit_notsup(struct seg *, caddr_t, size_t, uint_t);

/* Delay/retry factors for seg_p_mem_config_pre_del */
#define SEGP_PREDEL_DELAY_FACTOR        4
/*
 * As a workaround to being unable to purge the pagelock
 * cache during a DR delete memory operation, we use
 * a stall threshold that is twice the maximum seen
 * during testing.  This workaround will be removed
 * when a suitable fix is found.
 */
#define SEGP_STALL_SECONDS      25
#define SEGP_STALL_THRESHOLD \
        (SEGP_STALL_SECONDS * SEGP_PREDEL_DELAY_FACTOR)

#ifdef VMDEBUG

uint_t  seg_page(struct seg *, caddr_t);
uint_t  seg_pages(struct seg *);

#endif  /* VMDEBUG */

boolean_t       seg_can_change_zones(struct seg *);
size_t          seg_swresv(struct seg *);

#endif  /* _KERNEL */

#ifdef  __cplusplus
}
#endif

#endif  /* _VM_SEG_H */