use NULL dump segop as a shorthand for no-op
Instead of forcing every segment driver to implement a dummy function that
does nothing, handle NULL dump segop function pointer as a no-op shorthand.
const-ify make segment ops structures
There is no reason to keep the segment ops structures writable.
use NULL setpagesize segop as a shorthand for ENOTSUP
Instead of forcing every segment driver to implement a dummp function to
return (hopefully) ENOTSUP, handle NULL setpagesize segop function pointer
as "return ENOTSUP" shorthand.
use NULL capable segop as a shorthand for no-capabilities
Instead of forcing every segment driver to implement a dummy "return 0"
function, handle NULL capable segop function pointer as "no copabilities
supported" shorthand.
segop_getpolicy already checks for a NULL op
seg_inherit_notsup is redundant since segop_inherit checks for NULL properly
use C99 initializers in segment ops structures
remove whole-process swapping
Long before Unix supported paging, it used process swapping to reclaim
memory.  The code is there and in theory it runs when we get *extremely* low
on memory.  In practice, it never runs since the definition of low-on-memory
is antiquated. (XXX: define what antiquated means)
You can check the number of swapout/swapin events with kstats:
$ kstat -p ::vm:swapin ::vm:swapout

@@ -97,11 +97,11 @@
         size_t          softlockcnt;
         domid_t         domid;
         segmf_map_t     *map;
 };
 
-static struct seg_ops segmf_ops;
+static const struct seg_ops segmf_ops;
 
 static int segmf_fault_gref_range(struct seg *seg, caddr_t addr, size_t len);
 
 static struct segmf_data *
 segmf_data_zalloc(struct seg *seg)

@@ -468,53 +468,27 @@
 {
         return (0);
 }
 
 /*ARGSUSED*/
-static void
-segmf_dump(struct seg *seg)
-{}
-
-/*ARGSUSED*/
 static int
 segmf_pagelock(struct seg *seg, caddr_t addr, size_t len,
     struct page ***ppp, enum lock_type type, enum seg_rw rw)
 {
         return (ENOTSUP);
 }
 
-/*ARGSUSED*/
-static int
-segmf_setpagesize(struct seg *seg, caddr_t addr, size_t len, uint_t szc)
-{
-        return (ENOTSUP);
-}
-
 static int
 segmf_getmemid(struct seg *seg, caddr_t addr, memid_t *memid)
 {
         struct segmf_data *data = seg->s_data;
 
         memid->val[0] = (uintptr_t)VTOCVP(data->vp);
         memid->val[1] = (uintptr_t)seg_page(seg, addr);
         return (0);
 }
 
-/*ARGSUSED*/
-static lgrp_mem_policy_info_t *
-segmf_getpolicy(struct seg *seg, caddr_t addr)
-{
-        return (NULL);
-}
-
-/*ARGSUSED*/
-static int
-segmf_capable(struct seg *seg, segcapability_t capability)
-{
-        return (0);
-}
-
 /*
  * Add a set of contiguous foreign MFNs to the segment. soft-locking them.  The
  * pre-faulting is necessary due to live migration; in particular we must
  * return an error in response to IOCTL_PRIVCMD_MMAPBATCH rather than faulting
  * later on a bad MFN.  Whilst this isn't necessary for the other MMAP

@@ -755,31 +729,25 @@
         }
 
         return (0);
 }
 
-static struct seg_ops segmf_ops = {
-        segmf_dup,
-        segmf_unmap,
-        segmf_free,
-        segmf_fault,
-        segmf_faulta,
-        segmf_setprot,
-        segmf_checkprot,
-        (int (*)())segmf_kluster,
-        (size_t (*)(struct seg *))NULL, /* swapout */
-        segmf_sync,
-        segmf_incore,
-        segmf_lockop,
-        segmf_getprot,
-        segmf_getoffset,
-        segmf_gettype,
-        segmf_getvp,
-        segmf_advise,
-        segmf_dump,
-        segmf_pagelock,
-        segmf_setpagesize,
-        segmf_getmemid,
-        segmf_getpolicy,
-        segmf_capable,
-        seg_inherit_notsup
+static const struct seg_ops segmf_ops = {
+        .dup            = segmf_dup,
+        .unmap          = segmf_unmap,
+        .free           = segmf_free,
+        .fault          = segmf_fault,
+        .faulta         = segmf_faulta,
+        .setprot        = segmf_setprot,
+        .checkprot      = segmf_checkprot,
+        .kluster        = segmf_kluster,
+        .sync           = segmf_sync,
+        .incore         = segmf_incore,
+        .lockop         = segmf_lockop,
+        .getprot        = segmf_getprot,
+        .getoffset      = segmf_getoffset,
+        .gettype        = segmf_gettype,
+        .getvp          = segmf_getvp,
+        .advise         = segmf_advise,
+        .pagelock       = segmf_pagelock,
+        .getmemid       = segmf_getmemid,
 };