| Prepared by: | (jeffpc) on 2015-May-08 18:10 -0400 EDT |
|---|---|
| Workspace: | /home/jeffpc/illumos/xhat (at d018a7c0a637) |
| Compare against: | patches/master/remove-zulu^ ( at 9ac4713a74ed) |
| Summary of changes: | 9122 lines changed: 228 ins; 8437 del; 457 mod; 197298 unchg |
| Patch of changes: | combined.patch |
| Printable review: | combined.pdf |
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/cmd/mdb/common/modules/genunix/findstack.c
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:swapout3 lines changed: 0 ins; 3 del; 0 mod; 904 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/cmd/mdb/common/modules/genunix/findstack.h
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:swapout3 lines changed: 0 ins; 1 del; 2 mod; 90 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/cmd/mdb/common/modules/genunix/findstack_subr.c
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:swapout7 lines changed: 0 ins; 7 del; 0 mod; 415 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/cmd/mdb/common/modules/genunix/kmem.c
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:swapout8 lines changed: 0 ins; 8 del; 0 mod; 4373 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/cmd/mdb/common/modules/genunix/leaky_subr.c
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:swapout13 lines changed: 1 ins; 12 del; 0 mod; 912 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/pkg/manifests/system-kernel-platform.mf
remove zulu (XVR-4000) XVR-4000 was a very expensive, very rare graphics card.2 lines changed: 0 ins; 2 del; 0 mod; 1318 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/Makefile.files
remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat1 line changed: 0 ins; 1 del; 0 mod; 2122 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/cpr/cpr_dump.c
patch lower-case-segops1 line changed: 0 ins; 0 del; 1 mod; 1195 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/disp.c
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:swapout143 lines changed: 0 ins; 141 del; 2 mod; 2558 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/fss.c
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:swapout135 lines changed: 0 ins; 134 del; 1 mod; 2856 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/fx.c
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:swapout48 lines changed: 0 ins; 48 del; 0 mod; 1798 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/rt.c
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:swapout49 lines changed: 0 ins; 49 del; 0 mod; 1083 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/sysclass.c
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:swapout14 lines changed: 0 ins; 14 del; 0 mod; 224 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/sysdc.c
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:swapout10 lines changed: 0 ins; 10 del; 0 mod; 1307 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/thread.c
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:swapout2 lines changed: 0 ins; 1 del; 1 mod; 2127 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/ts.c
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:swapout160 lines changed: 0 ins; 160 del; 0 mod; 2267 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/exec/elf/elf.c
const-ify make segment ops structures There is no reason to keep the segment ops structures writable. patch lower-case-segops5 lines changed: 0 ins; 0 del; 5 mod; 2212 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/fs/nfs/nfs3_vnops.c
patch lower-case-segops2 lines changed: 0 ins; 0 del; 2 mod; 6748 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/fs/nfs/nfs4_vnops.c
patch lower-case-segops2 lines changed: 0 ins; 0 del; 2 mod; 15993 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/fs/nfs/nfs_srv.c
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:swapout2 lines changed: 0 ins; 2 del; 0 mod; 3010 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/fs/nfs/nfs_vnops.c
patch lower-case-segops2 lines changed: 0 ins; 0 del; 2 mod; 5094 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/fs/proc/prioctl.c
patch lower-case-segops11 lines changed: 0 ins; 0 del; 11 mod; 3927 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/fs/proc/prsubr.c
const-ify make segment ops structures There is no reason to keep the segment ops structures writable. patch lower-case-segops44 lines changed: 0 ins; 0 del; 44 mod; 4286 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/fs/proc/prvnops.c
patch lower-case-segops3 lines changed: 0 ins; 0 del; 3 mod; 6052 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/io/mem.c
patch lower-case-segops1 line changed: 0 ins; 0 del; 1 mod; 1053 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/clock.c
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:swapout38 lines changed: 0 ins; 38 del; 0 mod; 2627 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/condvar.c
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:swapout6 lines changed: 0 ins; 6 del; 0 mod; 815 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/cpu.c
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:swapout21 lines changed: 0 ins; 19 del; 2 mod; 3430 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/dumpsubr.c
patch lower-case-segops2 lines changed: 0 ins; 0 del; 2 mod; 1372 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/exec.c
patch lower-case-segops1 line changed: 0 ins; 0 del; 1 mod; 2032 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/lgrp.c
lgrp: getpolicy seg op has been around long enough This special casing has been around for more than 10 years. It's time for it to go. (There are no third party segment drivers anyway.) segop_getpolicy already checks for a NULL op patch lower-case-segops18 lines changed: 0 ins; 17 del; 1 mod; 4423 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/mmapobj.c
patch lower-case-segops1 line changed: 0 ins; 0 del; 1 mod; 2448 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/panic.c
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:swapout1 line changed: 0 ins; 1 del; 0 mod; 421 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/sched.c
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:swapout849 lines changed: 0 ins; 838 del; 11 mod; 90 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/sunddi.c
const-ify make segment ops structures There is no reason to keep the segment ops structures writable. patch lower-case-segops4 lines changed: 0 ins; 0 del; 4 mod; 10020 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/timers.c
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:swapout7 lines changed: 0 ins; 7 del; 0 mod; 1487 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/urw.c
const-ify make segment ops structures There is no reason to keep the segment ops structures writable. patch lower-case-segops12 lines changed: 0 ins; 0 del; 12 mod; 314 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/vm_subr.c
patch lower-case-segops1 line changed: 0 ins; 0 del; 1 mod; 517 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/waitq.c
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:swapout5 lines changed: 0 ins; 5 del; 0 mod; 388 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/watchpoint.c
patch lower-case-segops remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat9 lines changed: 0 ins; 5 del; 4 mod; 1735 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/zone.c
patch lower-case-segops1 line changed: 0 ins; 0 del; 1 mod; 7173 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/class.h
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:swapout6 lines changed: 0 ins; 6 del; 0 mod; 225 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/disp.h
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:swapout4 lines changed: 0 ins; 4 del; 0 mod; 183 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/proc.h
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:swapout5 lines changed: 0 ins; 3 del; 2 mod; 815 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/sysinfo.h
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:swapout4 lines changed: 0 ins; 4 del; 0 mod; 287 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/systm.h
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:swapout5 lines changed: 0 ins; 5 del; 0 mod; 499 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/thread.h
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:swapout20 lines changed: 0 ins; 20 del; 0 mod; 702 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/vmsystm.h
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:swapout2 lines changed: 0 ins; 2 del; 0 mod; 166 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/watchpoint.h
patch lower-case-segops1 line changed: 0 ins; 0 del; 1 mod; 130 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/syscall/utssys.c
patch lower-case-segops1 line changed: 0 ins; 0 del; 1 mod; 953 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/anon.h
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:swapout2 lines changed: 0 ins; 2 del; 0 mod; 500 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/as.h
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 remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat6 lines changed: 0 ins; 6 del; 0 mod; 311 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/hat.h
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:swapout8 lines changed: 0 ins; 8 del; 0 mod; 619 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg.h
const-ify make segment ops structures There is no reason to keep the segment ops structures writable. seg_inherit_notsup is redundant since segop_inherit checks for NULL properly patch lower-case-segops instead using SEGOP_* macros, define full-fledged segop_* functions This will allow us to do some sanity checking or even implement stub functionality in one place instead of duplicating it wherever these wrappers are used. 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:swapout60 lines changed: 25 ins; 33 del; 2 mod; 252 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_dev.c
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 patch lower-case-segops 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:swapout60 lines changed: 0 ins; 40 del; 20 mod; 4042 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_dev.h
const-ify make segment ops structures There is no reason to keep the segment ops structures writable. patch lower-case-segops2 lines changed: 0 ins; 0 del; 2 mod; 135 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_kmem.c
const-ify make segment ops structures There is no reason to keep the segment ops structures writable. segop_getpolicy already checks for a NULL op seg_inherit_notsup is redundant since segop_inherit checks for NULL properly no need for bad-op segment op functions The segment drivers have a number of bad-op functions that simply panic. Keeping the function pointer NULL will accomplish the same thing in most cases. In other cases, keeping the function pointer NULL will result in proper error code being returned. patch lower-case-segops 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:swapout52 lines changed: 0 ins; 31 del; 21 mod; 1592 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_kp.c
const-ify make segment ops structures There is no reason to keep the segment ops structures writable. use NULL getmemid segop as a shorthand for ENODEV Instead of forcing every segment driver to implement a dummy function to return (hopefully) ENODEV, handle NULL getmemid segop function pointer as "return ENODEV" 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 no need for bad-op segment op functions The segment drivers have a number of bad-op functions that simply panic. Keeping the function pointer NULL will accomplish the same thing in most cases. In other cases, keeping the function pointer NULL will result in proper error code being returned. 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:swapout69 lines changed: 0 ins; 61 del; 8 mod; 1397 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_kpm.c
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 getmemid segop as a shorthand for ENODEV Instead of forcing every segment driver to implement a dummy function to return (hopefully) ENODEV, handle NULL getmemid segop function pointer as "return ENODEV" 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. seg_inherit_notsup is redundant since segop_inherit checks for NULL properly no need for bad-op segment op functions The segment drivers have a number of bad-op functions that simply panic. Keeping the function pointer NULL will accomplish the same thing in most cases. In other cases, keeping the function pointer NULL will result in proper error code being returned. 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:swapout72 lines changed: 7 ins; 30 del; 35 mod; 276 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_map.c
const-ify make segment ops structures There is no reason to keep the segment ops structures writable. 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 no need for bad-op segment op functions The segment drivers have a number of bad-op functions that simply panic. Keeping the function pointer NULL will accomplish the same thing in most cases. In other cases, keeping the function pointer NULL will result in proper error code being returned. 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:swapout52 lines changed: 0 ins; 39 del; 13 mod; 2303 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_spt.c
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. segspt_ops can be static There is nothing that needs access to this structure outside of the spt segment driver itself. 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. seg_inherit_notsup is redundant since segop_inherit checks for NULL properly no need for bad-op segment op functions The segment drivers have a number of bad-op functions that simply panic. Keeping the function pointer NULL will accomplish the same thing in most cases. In other cases, keeping the function pointer NULL will result in proper error code being returned. 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 remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat140 lines changed: 8 ins; 96 del; 36 mod; 2985 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_vn.c
PVN_GETPAGE_{SZ,NUM} are misnamed and unnecessarily complicated
There is really no reason to not allow 8 pages all the time. With the
current logic, we get the following:
Assuming 4kB pages (x86):
_SZ = ptob(8) /* 32kB */
_NUM = 8
Assuming 8kB pages (sparc):
_SZ = ptob(8) /* 64kB */
_NUM = 8
We'd have to deal with 16kB base pages in order for the _NUM #define to not
be 8 (it'd be 4 in that case). So, in the spirit of simplicity, let's just
always grab 8 pages as there are no interesting systems with 16kB+ base pages.
Finally, the defines are poorly named.
const-ify make segment ops structures
There is no reason to keep the segment ops structures writable.
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.
patch lower-case-segops
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
remove xhat
The xhat infrastructure was added to support hardware such as the zulu
graphics card - hardware which had on-board MMUs. The VM used the xhat code
to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user
was zulu (which is gone), we can safely remove it simplifying the whole VM
subsystem.
Assorted notes:
- AS_BUSY flag was used solely by xhat
263 lines changed: 0 ins; 226 del; 37 mod; 10051 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_vn.h
const-ify make segment ops structures There is no reason to keep the segment ops structures writable.1 line changed: 0 ins; 0 del; 1 mod; 248 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/vm_anon.c
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:swapout39 lines changed: 0 ins; 37 del; 2 mod; 3588 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/vm_as.c
const-ify make segment ops structures There is no reason to keep the segment ops structures writable. use NULL getmemid segop as a shorthand for ENODEV Instead of forcing every segment driver to implement a dummy function to return (hopefully) ENODEV, handle NULL getmemid segop function pointer as "return ENODEV" shorthand. seg_inherit_notsup is redundant since segop_inherit checks for NULL properly patch lower-case-segops 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 remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat242 lines changed: 0 ins; 162 del; 80 mod; 3450 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/vm_pvn.c
patch lower-case-segops3 lines changed: 0 ins; 0 del; 3 mod; 1216 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/vm_rm.c
remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat1 line changed: 0 ins; 0 del; 1 mod; 106 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/vm_seg.c
patch segpcache-maxwindow-is-useless 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 getmemid segop as a shorthand for ENODEV Instead of forcing every segment driver to implement a dummy function to return (hopefully) ENODEV, handle NULL getmemid segop function pointer as "return ENODEV" 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. seg_inherit_notsup is redundant since segop_inherit checks for NULL properly patch lower-case-segops instead using SEGOP_* macros, define full-fledged segop_* functions This will allow us to do some sanity checking or even implement stub functionality in one place instead of duplicating it wherever these wrappers are used.235 lines changed: 187 ins; 36 del; 12 mod; 1816 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/vm_usage.c
const-ify make segment ops structures There is no reason to keep the segment ops structures writable.2 lines changed: 0 ins; 0 del; 2 mod; 2030 unchg
------ ------ ------ ------ ------ Old --- Patch --- usr/src/uts/common/vm/xhat.c (deleted)
remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat555 lines changed: 0 ins; 555 del; 0 mod; 0 unchg
------ ------ ------ ------ ------ Old --- Patch --- usr/src/uts/common/vm/xhat.h (deleted)
remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat208 lines changed: 0 ins; 208 del; 0 mod; 0 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/i86pc/io/rootnex.c
const-ify make segment ops structures There is no reason to keep the segment ops structures writable.1 line changed: 0 ins; 0 del; 1 mod; 5171 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/i86pc/os/mlsetup.c
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:swapout1 line changed: 0 ins; 0 del; 1 mod; 497 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/i86pc/os/trap.c
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:swapout1 line changed: 0 ins; 1 del; 0 mod; 2253 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/i86pc/vm/hat_i86.c
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:swapout82 lines changed: 0 ins; 82 del; 0 mod; 4416 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/i86xpv/vm/seg_mf.c
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:swapout52 lines changed: 0 ins; 32 del; 20 mod; 733 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/intel/ia32/os/syscall.c
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:swapout3 lines changed: 0 ins; 2 del; 1 mod; 1390 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sfmmu/vm/hat_sfmmu.c
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 remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat344 lines changed: 0 ins; 333 del; 11 mod; 15509 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sfmmu/vm/hat_sfmmu.h
remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat13 lines changed: 0 ins; 12 del; 1 mod; 2575 unchg
------ ------ ------ ------ ------ Old --- Patch --- usr/src/uts/sfmmu/vm/xhat_sfmmu.c (deleted)
remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat240 lines changed: 0 ins; 240 del; 0 mod; 0 unchg
------ ------ ------ ------ ------ Old --- Patch --- usr/src/uts/sfmmu/vm/xhat_sfmmu.h (deleted)
remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat94 lines changed: 0 ins; 94 del; 0 mod; 0 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sparc/os/syscall.c
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:swapout2 lines changed: 0 ins; 2 del; 0 mod; 1231 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sparc/v9/os/v9dep.c
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:swapout9 lines changed: 0 ins; 9 del; 0 mod; 1865 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sparc/v9/vm/seg_nf.c
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 getmemid segop as a shorthand for ENODEV Instead of forcing every segment driver to implement a dummy function to return (hopefully) ENODEV, handle NULL getmemid segop function pointer as "return ENODEV" shorthand. segop_getpolicy already checks for a NULL op no need for bad-op segment op functions The segment drivers have a number of bad-op functions that simply panic. Keeping the function pointer NULL will accomplish the same thing in most cases. In other cases, keeping the function pointer NULL will result in proper error code being returned. 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:swapout78 lines changed: 0 ins; 54 del; 24 mod; 420 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sun4/io/rootnex.c
const-ify make segment ops structures There is no reason to keep the segment ops structures writable.1 line changed: 0 ins; 0 del; 1 mod; 978 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sun4/os/mlsetup.c
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:swapout1 line changed: 0 ins; 0 del; 1 mod; 544 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sun4/os/trap.c
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:swapout9 lines changed: 0 ins; 9 del; 0 mod; 1956 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sun4u/Makefile.files
remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat remove zulu (XVR-4000) XVR-4000 was a very expensive, very rare graphics card.2 lines changed: 0 ins; 2 del; 0 mod; 235 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sun4u/Makefile.sun4u
remove zulu (XVR-4000) XVR-4000 was a very expensive, very rare graphics card.1 line changed: 0 ins; 1 del; 0 mod; 475 unchg
------ ------ ------ ------ ------ Old --- Patch --- usr/src/uts/sun4u/io/zuluvm.c (deleted)
remove zulu (XVR-4000) XVR-4000 was a very expensive, very rare graphics card.1495 lines changed: 0 ins; 1495 del; 0 mod; 0 unchg
------ ------ ------ ------ ------ Old --- Patch --- usr/src/uts/sun4u/ml/zulu_asm.s (deleted)
remove zulu (XVR-4000) XVR-4000 was a very expensive, very rare graphics card.325 lines changed: 0 ins; 325 del; 0 mod; 0 unchg
------ ------ ------ ------ ------ Old --- Patch --- usr/src/uts/sun4u/ml/zulu_hat_asm.s (deleted)
remove zulu (XVR-4000) XVR-4000 was a very expensive, very rare graphics card.314 lines changed: 0 ins; 314 del; 0 mod; 0 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sun4u/serengeti/sys/sgfrutypes.h
remove zulu (XVR-4000) XVR-4000 was a very expensive, very rare graphics card.6 lines changed: 0 ins; 6 del; 0 mod; 354 unchg
------ ------ ------ ------ ------ Old --- Patch --- usr/src/uts/sun4u/sys/zulu_hat.h (deleted)
remove zulu (XVR-4000) XVR-4000 was a very expensive, very rare graphics card.214 lines changed: 0 ins; 214 del; 0 mod; 0 unchg
------ ------ ------ ------ ------ Old --- Patch --- usr/src/uts/sun4u/sys/zulumod.h (deleted)
remove zulu (XVR-4000) XVR-4000 was a very expensive, very rare graphics card.262 lines changed: 0 ins; 262 del; 0 mod; 0 unchg
------ ------ ------ ------ ------ Old --- Patch --- usr/src/uts/sun4u/sys/zuluvm.h (deleted)
remove zulu (XVR-4000) XVR-4000 was a very expensive, very rare graphics card.121 lines changed: 0 ins; 121 del; 0 mod; 0 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sun4u/vm/mach_kpm.c
remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat4 lines changed: 0 ins; 4 del; 0 mod; 2375 unchg
------ ------ ------ ------ ------ Old --- Patch --- usr/src/uts/sun4u/vm/zulu_hat.c (deleted)
remove zulu (XVR-4000) XVR-4000 was a very expensive, very rare graphics card.1469 lines changed: 0 ins; 1469 del; 0 mod; 0 unchg
------ ------ ------ ------ ------ Old --- Patch --- usr/src/uts/sun4u/zuluvm/Makefile (deleted)
remove zulu (XVR-4000) XVR-4000 was a very expensive, very rare graphics card.133 lines changed: 0 ins; 133 del; 0 mod; 0 unchg
------ ------ ------ ------ ------ Old --- Patch --- usr/src/uts/sun4u/zuluvm/zuluvm_offsets.in (deleted)
remove zulu (XVR-4000) XVR-4000 was a very expensive, very rare graphics card.77 lines changed: 0 ins; 77 del; 0 mod; 0 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sun4v/Makefile.files
remove xhat The xhat infrastructure was added to support hardware such as the zulu graphics card - hardware which had on-board MMUs. The VM used the xhat code to keep the CPU's and Zulu's page tables in-sync. Since the only xhat user was zulu (which is gone), we can safely remove it simplifying the whole VM subsystem. Assorted notes: - AS_BUSY flag was used solely by xhat1 line changed: 0 ins; 1 del; 0 mod; 228 unchg
This code review page was prepared using /opt/onbld/bin/webrev. Webrev is maintained by the illumos project. The latest version may be obtained here.