Skip site navigation (1)Skip section navigation (2)
Date:      Mon, 21 Oct 2019 00:08:35 +0000 (UTC)
From:      Kyle Evans <kevans@FreeBSD.org>
To:        src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-stable@freebsd.org, svn-src-stable-12@freebsd.org
Subject:   svn commit: r353787 - in stable/12/sys: kern vm
Message-ID:  <201910210008.x9L08ZQt027865@repo.freebsd.org>

next in thread | raw e-mail | index | archive | help
Author: kevans
Date: Mon Oct 21 00:08:34 2019
New Revision: 353787
URL: https://svnweb.freebsd.org/changeset/base/353787

Log:
  MFC r351650, r351795-r351796: writemapping accounting for posixshm
  
  r351650:
  posixshm: switch to OBJT_SWAP in advance of other changes
  
  Future changes to posixshm will start tracking writeable mappings in order
  to support file sealing. Tracking writeable mappings for an OBJT_DEFAULT
  object is complicated as it may be swapped out and converted to an
  OBJT_SWAP. One may generically add this tracking for vm_object, but this is
  difficult to do without increasing memory footprint of vm_object and blowing
  up memory usage by a significant amount.
  
  On the other hand, the swap pager can be expanded to track writeable
  mappings without increasing vm_object size. This change is currently in
  D21456. Switch over to OBJT_SWAP in advance of the other changes to the
  swap pager and posixshm.
  
  r351795:
  vm pager: writemapping accounting for OBJT_SWAP
  
  Currently writemapping accounting is only done for vnode_pager which does
  some accounting on the underlying vnode.
  
  Extend this to allow accounting to be possible for any of the pager types.
  New pageops are added to update/release writecount that need to be
  implemented for any pager wishing to do said accounting, and we implement
  these methods now for both vnode_pager (unchanged) and swap_pager.
  
  The primary motivation for this is to allow other systems with OBJT_SWAP
  objects to check if their objects have any write mappings and reject
  operations with EBUSY if so. posixshm will be the first to do so in order to
  reject adding write seals to the shmfd if any writable mappings exist.
  
  r351796:
  posixshm: start counting writeable mappings
  
  r351650 switched posixshm to using OBJT_SWAP for shm_object
  
  r351795 added support to the swap_pager for tracking writeable mappings
  
  Take advantage of this and start tracking writeable mappings; fd sealing
  will use this to reject a seal on writing with EBUSY if any such mapping
  exist.

Modified:
  stable/12/sys/kern/uipc_shm.c
  stable/12/sys/kern/vfs_vnops.c
  stable/12/sys/vm/swap_pager.c
  stable/12/sys/vm/vm_map.c
  stable/12/sys/vm/vm_map.h
  stable/12/sys/vm/vm_mmap.c
  stable/12/sys/vm/vm_object.h
  stable/12/sys/vm/vm_pager.h
  stable/12/sys/vm/vnode_pager.c
  stable/12/sys/vm/vnode_pager.h
Directory Properties:
  stable/12/   (props changed)

Modified: stable/12/sys/kern/uipc_shm.c
==============================================================================
--- stable/12/sys/kern/uipc_shm.c	Sun Oct 20 22:55:47 2019	(r353786)
+++ stable/12/sys/kern/uipc_shm.c	Mon Oct 21 00:08:34 2019	(r353787)
@@ -554,7 +554,7 @@ shm_alloc(struct ucred *ucred, mode_t mode)
 	shmfd->shm_uid = ucred->cr_uid;
 	shmfd->shm_gid = ucred->cr_gid;
 	shmfd->shm_mode = mode;
-	shmfd->shm_object = vm_pager_allocate(OBJT_DEFAULT, NULL,
+	shmfd->shm_object = vm_pager_allocate(OBJT_SWAP, NULL,
 	    shmfd->shm_size, VM_PROT_DEFAULT, 0, ucred);
 	KASSERT(shmfd->shm_object != NULL, ("shm_create: vm_pager_allocate"));
 	shmfd->shm_object->pg_color = 0;
@@ -900,6 +900,7 @@ shm_mmap(struct file *fp, vm_map_t map, vm_offset_t *a
 	struct shmfd *shmfd;
 	vm_prot_t maxprot;
 	int error;
+	bool writecnt;
 
 	shmfd = fp->f_data;
 	maxprot = VM_PROT_NONE;
@@ -910,10 +911,10 @@ shm_mmap(struct file *fp, vm_map_t map, vm_offset_t *a
 	if ((fp->f_flag & FWRITE) != 0)
 		maxprot |= VM_PROT_WRITE;
 
+	writecnt = (flags & MAP_SHARED) != 0 && (prot & VM_PROT_WRITE) != 0;
+
 	/* Don't permit shared writable mappings on read-only descriptors. */
-	if ((flags & MAP_SHARED) != 0 &&
-	    (maxprot & VM_PROT_WRITE) == 0 &&
-	    (prot & VM_PROT_WRITE) != 0)
+	if (writecnt && (maxprot & VM_PROT_WRITE) == 0)
 		return (EACCES);
 	maxprot &= cap_maxprot;
 
@@ -936,10 +937,16 @@ shm_mmap(struct file *fp, vm_map_t map, vm_offset_t *a
 	mtx_unlock(&shm_timestamp_lock);
 	vm_object_reference(shmfd->shm_object);
 
+	if (writecnt)
+		vm_pager_update_writecount(shmfd->shm_object, 0, objsize);
 	error = vm_mmap_object(map, addr, objsize, prot, maxprot, flags,
-	    shmfd->shm_object, foff, FALSE, td);
-	if (error != 0)
+	    shmfd->shm_object, foff, writecnt, td);
+	if (error != 0) {
+		if (writecnt)
+			vm_pager_release_writecount(shmfd->shm_object, 0,
+			    objsize);
 		vm_object_deallocate(shmfd->shm_object);
+	}
 	return (error);
 }
 

Modified: stable/12/sys/kern/vfs_vnops.c
==============================================================================
--- stable/12/sys/kern/vfs_vnops.c	Sun Oct 20 22:55:47 2019	(r353786)
+++ stable/12/sys/kern/vfs_vnops.c	Mon Oct 21 00:08:34 2019	(r353787)
@@ -86,7 +86,7 @@ __FBSDID("$FreeBSD$");
 #include <vm/vm_map.h>
 #include <vm/vm_object.h>
 #include <vm/vm_page.h>
-#include <vm/vnode_pager.h>
+#include <vm/vm_pager.h>
 
 #ifdef HWPMC_HOOKS
 #include <sys/pmckern.h>
@@ -2483,7 +2483,7 @@ vn_mmap(struct file *fp, vm_map_t map, vm_offset_t *ad
 		 * writecount, then undo that now.
 		 */
 		if (writecounted)
-			vnode_pager_release_writecount(object, 0, size);
+			vm_pager_release_writecount(object, 0, size);
 		vm_object_deallocate(object);
 	}
 #ifdef HWPMC_HOOKS

Modified: stable/12/sys/vm/swap_pager.c
==============================================================================
--- stable/12/sys/vm/swap_pager.c	Sun Oct 20 22:55:47 2019	(r353786)
+++ stable/12/sys/vm/swap_pager.c	Mon Oct 21 00:08:34 2019	(r353787)
@@ -375,6 +375,10 @@ static boolean_t
 static void	swap_pager_init(void);
 static void	swap_pager_unswapped(vm_page_t);
 static void	swap_pager_swapoff(struct swdevt *sp);
+static void	swap_pager_update_writecount(vm_object_t object,
+    vm_offset_t start, vm_offset_t end);
+static void	swap_pager_release_writecount(vm_object_t object,
+    vm_offset_t start, vm_offset_t end);
 
 struct pagerops swappagerops = {
 	.pgo_init =	swap_pager_init,	/* early system initialization of pager	*/
@@ -385,6 +389,8 @@ struct pagerops swappagerops = {
 	.pgo_putpages =	swap_pager_putpages,	/* pageout				*/
 	.pgo_haspage =	swap_pager_haspage,	/* get backing store status for page	*/
 	.pgo_pageunswapped = swap_pager_unswapped,	/* remove swap related to page		*/
+	.pgo_update_writecount = swap_pager_update_writecount,
+	.pgo_release_writecount = swap_pager_release_writecount,
 };
 
 /*
@@ -610,6 +616,7 @@ swap_pager_alloc_init(void *handle, struct ucred *cred
 	object = vm_object_allocate(OBJT_SWAP, OFF_TO_IDX(offset +
 	    PAGE_MASK + size));
 
+	object->un_pager.swp.writemappings = 0;
 	object->handle = handle;
 	if (cred != NULL) {
 		object->cred = cred;
@@ -1920,6 +1927,7 @@ swp_pager_meta_build(vm_object_t object, vm_pindex_t p
 		atomic_thread_fence_rel();
 
 		object->type = OBJT_SWAP;
+		object->un_pager.swp.writemappings = 0;
 		KASSERT(object->handle == NULL, ("default pager with handle"));
 	}
 
@@ -3004,4 +3012,28 @@ sysctl_swap_async_max(SYSCTL_HANDLER_ARGS)
 	mtx_unlock(&pbuf_mtx);
 
 	return (0);
+}
+
+static void
+swap_pager_update_writecount(vm_object_t object, vm_offset_t start,
+    vm_offset_t end)
+{
+
+	VM_OBJECT_WLOCK(object);
+	KASSERT((object->flags & OBJ_NOSPLIT) != 0,
+	    ("Splittable object with writecount"));
+	object->un_pager.swp.writemappings += (vm_ooffset_t)end - start;
+	VM_OBJECT_WUNLOCK(object);
+}
+
+static void
+swap_pager_release_writecount(vm_object_t object, vm_offset_t start,
+    vm_offset_t end)
+{
+
+	VM_OBJECT_WLOCK(object);
+	KASSERT((object->flags & OBJ_NOSPLIT) != 0,
+	    ("Splittable object with writecount"));
+	object->un_pager.swp.writemappings -= (vm_ooffset_t)end - start;
+	VM_OBJECT_WUNLOCK(object);
 }

Modified: stable/12/sys/vm/vm_map.c
==============================================================================
--- stable/12/sys/vm/vm_map.c	Sun Oct 20 22:55:47 2019	(r353786)
+++ stable/12/sys/vm/vm_map.c	Mon Oct 21 00:08:34 2019	(r353787)
@@ -574,10 +574,10 @@ vm_map_process_deferred(void)
 	td->td_map_def_user = NULL;
 	while (entry != NULL) {
 		next = entry->next;
-		MPASS((entry->eflags & (MAP_ENTRY_VN_WRITECNT |
-		    MAP_ENTRY_VN_EXEC)) != (MAP_ENTRY_VN_WRITECNT |
+		MPASS((entry->eflags & (MAP_ENTRY_WRITECNT |
+		    MAP_ENTRY_VN_EXEC)) != (MAP_ENTRY_WRITECNT |
 		    MAP_ENTRY_VN_EXEC));
-		if ((entry->eflags & MAP_ENTRY_VN_WRITECNT) != 0) {
+		if ((entry->eflags & MAP_ENTRY_WRITECNT) != 0) {
 			/*
 			 * Decrement the object's writemappings and
 			 * possibly the vnode's v_writecount.
@@ -586,7 +586,7 @@ vm_map_process_deferred(void)
 			    ("Submap with writecount"));
 			object = entry->object.vm_object;
 			KASSERT(object != NULL, ("No object for writecount"));
-			vnode_pager_release_writecount(object, entry->start,
+			vm_pager_release_writecount(object, entry->start,
 			    entry->end);
 		}
 		vm_map_entry_set_vnode_text(entry, false);
@@ -1484,8 +1484,8 @@ vm_map_insert(vm_map_t map, vm_object_t object, vm_oof
 		protoeflags |= MAP_ENTRY_GROWS_DOWN;
 	if (cow & MAP_STACK_GROWS_UP)
 		protoeflags |= MAP_ENTRY_GROWS_UP;
-	if (cow & MAP_VN_WRITECOUNT)
-		protoeflags |= MAP_ENTRY_VN_WRITECNT;
+	if (cow & MAP_WRITECOUNT)
+		protoeflags |= MAP_ENTRY_WRITECNT;
 	if (cow & MAP_VN_EXEC)
 		protoeflags |= MAP_ENTRY_VN_EXEC;
 	if ((cow & MAP_CREATE_GUARD) != 0)
@@ -2196,7 +2196,7 @@ _vm_map_clip_start(vm_map_t map, vm_map_entry_t entry,
 		vm_map_entry_set_vnode_text(new_entry, true);
 		/*
 		 * The object->un_pager.vnp.writemappings for the
-		 * object of MAP_ENTRY_VN_WRITECNT type entry shall be
+		 * object of MAP_ENTRY_WRITECNT type entry shall be
 		 * kept as is here.  The virtual pages are
 		 * re-distributed among the clipped entries, so the sum is
 		 * left the same.
@@ -3758,20 +3758,20 @@ vm_map_copy_entry(
 			dst_entry->eflags |= MAP_ENTRY_COW |
 			    MAP_ENTRY_NEEDS_COPY;
 			dst_entry->offset = src_entry->offset;
-			if (src_entry->eflags & MAP_ENTRY_VN_WRITECNT) {
+			if (src_entry->eflags & MAP_ENTRY_WRITECNT) {
 				/*
-				 * MAP_ENTRY_VN_WRITECNT cannot
+				 * MAP_ENTRY_WRITECNT cannot
 				 * indicate write reference from
 				 * src_entry, since the entry is
 				 * marked as needs copy.  Allocate a
 				 * fake entry that is used to
-				 * decrement object->un_pager.vnp.writecount
+				 * decrement object->un_pager writecount
 				 * at the appropriate time.  Attach
 				 * fake_entry to the deferred list.
 				 */
 				fake_entry = vm_map_entry_create(dst_map);
-				fake_entry->eflags = MAP_ENTRY_VN_WRITECNT;
-				src_entry->eflags &= ~MAP_ENTRY_VN_WRITECNT;
+				fake_entry->eflags = MAP_ENTRY_WRITECNT;
+				src_entry->eflags &= ~MAP_ENTRY_WRITECNT;
 				vm_object_reference(src_object);
 				fake_entry->object.vm_object = src_object;
 				fake_entry->start = src_entry->start;
@@ -3954,7 +3954,7 @@ vmspace_fork(struct vmspace *vm1, vm_ooffset_t *fork_c
 			 * not relock it later for the assertion
 			 * correctness.
 			 */
-			if (old_entry->eflags & MAP_ENTRY_VN_WRITECNT &&
+			if (old_entry->eflags & MAP_ENTRY_WRITECNT &&
 			    object->type == OBJT_VNODE) {
 				KASSERT(((struct vnode *)object->handle)->
 				    v_writecount > 0,
@@ -3974,8 +3974,8 @@ vmspace_fork(struct vmspace *vm1, vm_ooffset_t *fork_c
 			    MAP_ENTRY_IN_TRANSITION);
 			new_entry->wiring_thread = NULL;
 			new_entry->wired_count = 0;
-			if (new_entry->eflags & MAP_ENTRY_VN_WRITECNT) {
-				vnode_pager_update_writecount(object,
+			if (new_entry->eflags & MAP_ENTRY_WRITECNT) {
+				vm_pager_update_writecount(object,
 				    new_entry->start, new_entry->end);
 			}
 			vm_map_entry_set_vnode_text(new_entry, true);
@@ -4006,7 +4006,7 @@ vmspace_fork(struct vmspace *vm1, vm_ooffset_t *fork_c
 			 * Copied entry is COW over the old object.
 			 */
 			new_entry->eflags &= ~(MAP_ENTRY_USER_WIRED |
-			    MAP_ENTRY_IN_TRANSITION | MAP_ENTRY_VN_WRITECNT);
+			    MAP_ENTRY_IN_TRANSITION | MAP_ENTRY_WRITECNT);
 			new_entry->wiring_thread = NULL;
 			new_entry->wired_count = 0;
 			new_entry->object.vm_object = NULL;
@@ -4030,7 +4030,7 @@ vmspace_fork(struct vmspace *vm1, vm_ooffset_t *fork_c
 			new_entry->end = old_entry->end;
 			new_entry->eflags = old_entry->eflags &
 			    ~(MAP_ENTRY_USER_WIRED | MAP_ENTRY_IN_TRANSITION |
-			    MAP_ENTRY_VN_WRITECNT | MAP_ENTRY_VN_EXEC);
+			    MAP_ENTRY_WRITECNT | MAP_ENTRY_VN_EXEC);
 			new_entry->protection = old_entry->protection;
 			new_entry->max_protection = old_entry->max_protection;
 			new_entry->inheritance = VM_INHERIT_ZERO;

Modified: stable/12/sys/vm/vm_map.h
==============================================================================
--- stable/12/sys/vm/vm_map.h	Sun Oct 20 22:55:47 2019	(r353786)
+++ stable/12/sys/vm/vm_map.h	Mon Oct 21 00:08:34 2019	(r353787)
@@ -145,7 +145,7 @@ struct vm_map_entry {
 #define	MAP_ENTRY_GROWS_UP		0x00002000	/* bottom-up stacks */
 
 #define	MAP_ENTRY_WIRE_SKIPPED		0x00004000
-#define	MAP_ENTRY_VN_WRITECNT		0x00008000	/* writeable vnode
+#define	MAP_ENTRY_WRITECNT		0x00008000	/* tracked writeable
 							   mapping */
 #define	MAP_ENTRY_GUARD			0x00010000
 #define	MAP_ENTRY_STACK_GAP_DN		0x00020000
@@ -349,7 +349,7 @@ long vmspace_resident_count(struct vmspace *vmspace);
 #define	MAP_CREATE_GUARD	0x00000080
 #define	MAP_DISABLE_COREDUMP	0x00000100
 #define	MAP_PREFAULT_MADVISE	0x00000200    /* from (user) madvise request */
-#define	MAP_VN_WRITECOUNT	0x00000400
+#define	MAP_WRITECOUNT		0x00000400
 #define	MAP_REMAP		0x00000800
 #define	MAP_STACK_GROWS_DOWN	0x00001000
 #define	MAP_STACK_GROWS_UP	0x00002000

Modified: stable/12/sys/vm/vm_mmap.c
==============================================================================
--- stable/12/sys/vm/vm_mmap.c	Sun Oct 20 22:55:47 2019	(r353786)
+++ stable/12/sys/vm/vm_mmap.c	Mon Oct 21 00:08:34 2019	(r353787)
@@ -1242,7 +1242,7 @@ vm_mmap_vnode(struct thread *td, vm_size_t objsize,
 		}
 		if (writex) {
 			*writecounted = TRUE;
-			vnode_pager_update_writecount(obj, 0, objsize);
+			vm_pager_update_writecount(obj, 0, objsize);
 		}
 	} else {
 		error = EINVAL;
@@ -1298,7 +1298,7 @@ vm_mmap_vnode(struct thread *td, vm_size_t objsize,
 done:
 	if (error != 0 && *writecounted) {
 		*writecounted = FALSE;
-		vnode_pager_update_writecount(obj, objsize, 0);
+		vm_pager_update_writecount(obj, objsize, 0);
 	}
 	vput(vp);
 	return (error);
@@ -1433,7 +1433,7 @@ vm_mmap(vm_map_t map, vm_offset_t *addr, vm_size_t siz
 		 * writecount, then undo that now.
 		 */
 		if (writecounted)
-			vnode_pager_release_writecount(object, 0, size);
+			vm_pager_release_writecount(object, 0, size);
 		vm_object_deallocate(object);
 	}
 	return (error);
@@ -1522,7 +1522,7 @@ vm_mmap_object(vm_map_t map, vm_offset_t *addr, vm_siz
 	if (flags & MAP_SHARED)
 		docow |= MAP_INHERIT_SHARE;
 	if (writecounted)
-		docow |= MAP_VN_WRITECOUNT;
+		docow |= MAP_WRITECOUNT;
 	if (flags & MAP_STACK) {
 		if (object != NULL)
 			return (EINVAL);

Modified: stable/12/sys/vm/vm_object.h
==============================================================================
--- stable/12/sys/vm/vm_object.h	Sun Oct 20 22:55:47 2019	(r353786)
+++ stable/12/sys/vm/vm_object.h	Mon Oct 21 00:08:34 2019	(r353787)
@@ -167,6 +167,7 @@ struct vm_object {
 		struct {
 			void *swp_tmpfs;
 			struct pctrie swp_blks;
+			vm_ooffset_t writemappings;
 		} swp;
 	} un_pager;
 	struct ucred *cred;

Modified: stable/12/sys/vm/vm_pager.h
==============================================================================
--- stable/12/sys/vm/vm_pager.h	Sun Oct 20 22:55:47 2019	(r353786)
+++ stable/12/sys/vm/vm_pager.h	Mon Oct 21 00:08:34 2019	(r353787)
@@ -61,6 +61,7 @@ typedef boolean_t pgo_haspage_t(vm_object_t, vm_pindex
 typedef int pgo_populate_t(vm_object_t, vm_pindex_t, int, vm_prot_t,
     vm_pindex_t *, vm_pindex_t *);
 typedef void pgo_pageunswapped_t(vm_page_t);
+typedef void pgo_writecount_t(vm_object_t, vm_offset_t, vm_offset_t);
 
 struct pagerops {
 	pgo_init_t		*pgo_init;		/* Initialize pager. */
@@ -72,6 +73,9 @@ struct pagerops {
 	pgo_haspage_t		*pgo_haspage;		/* Query page. */
 	pgo_populate_t		*pgo_populate;		/* Bulk spec pagein. */
 	pgo_pageunswapped_t	*pgo_pageunswapped;
+	/* Operations for specialized writecount handling */
+	pgo_writecount_t	*pgo_update_writecount;
+	pgo_writecount_t	*pgo_release_writecount;
 };
 
 extern struct pagerops defaultpagerops;
@@ -190,6 +194,26 @@ vm_pager_page_unswapped(vm_page_t m)
 	VM_OBJECT_ASSERT_LOCKED(m->object);
 	if (pagertab[m->object->type]->pgo_pageunswapped)
 		(*pagertab[m->object->type]->pgo_pageunswapped)(m);
+}
+
+static __inline void
+vm_pager_update_writecount(vm_object_t object, vm_offset_t start,
+    vm_offset_t end)
+{
+
+	if (pagertab[object->type]->pgo_update_writecount)
+		pagertab[object->type]->pgo_update_writecount(object, start,
+		    end);
+}
+
+static __inline void
+vm_pager_release_writecount(vm_object_t object, vm_offset_t start,
+    vm_offset_t end)
+{
+
+	if (pagertab[object->type]->pgo_release_writecount)
+		pagertab[object->type]->pgo_release_writecount(object, start,
+		    end);
 }
 
 struct cdev_pager_ops {

Modified: stable/12/sys/vm/vnode_pager.c
==============================================================================
--- stable/12/sys/vm/vnode_pager.c	Sun Oct 20 22:55:47 2019	(r353786)
+++ stable/12/sys/vm/vnode_pager.c	Mon Oct 21 00:08:34 2019	(r353787)
@@ -97,6 +97,10 @@ static vm_object_t vnode_pager_alloc(void *, vm_ooffse
     vm_ooffset_t, struct ucred *cred);
 static int vnode_pager_generic_getpages_done(struct buf *);
 static void vnode_pager_generic_getpages_done_async(struct buf *);
+static void vnode_pager_update_writecount(vm_object_t, vm_offset_t,
+    vm_offset_t);
+static void vnode_pager_release_writecount(vm_object_t, vm_offset_t,
+    vm_offset_t);
 
 struct pagerops vnodepagerops = {
 	.pgo_alloc =	vnode_pager_alloc,
@@ -105,6 +109,8 @@ struct pagerops vnodepagerops = {
 	.pgo_getpages_async = vnode_pager_getpages_async,
 	.pgo_putpages =	vnode_pager_putpages,
 	.pgo_haspage =	vnode_pager_haspage,
+	.pgo_update_writecount = vnode_pager_update_writecount,
+	.pgo_release_writecount = vnode_pager_release_writecount,
 };
 
 int vnode_pbuf_freecnt;
@@ -1499,7 +1505,7 @@ done:
 	VM_OBJECT_WUNLOCK(obj);
 }
 
-void
+static void
 vnode_pager_update_writecount(vm_object_t object, vm_offset_t start,
     vm_offset_t end)
 {
@@ -1528,7 +1534,7 @@ vnode_pager_update_writecount(vm_object_t object, vm_o
 	VM_OBJECT_WUNLOCK(object);
 }
 
-void
+static void
 vnode_pager_release_writecount(vm_object_t object, vm_offset_t start,
     vm_offset_t end)
 {

Modified: stable/12/sys/vm/vnode_pager.h
==============================================================================
--- stable/12/sys/vm/vnode_pager.h	Sun Oct 20 22:55:47 2019	(r353786)
+++ stable/12/sys/vm/vnode_pager.h	Mon Oct 21 00:08:34 2019	(r353787)
@@ -50,12 +50,8 @@ int vnode_pager_generic_putpages(struct vnode *vp, vm_
 int vnode_pager_local_getpages(struct vop_getpages_args *ap);
 int vnode_pager_local_getpages_async(struct vop_getpages_async_args *ap);
 int vnode_pager_putpages_ioflags(int pager_flags);
-void vnode_pager_release_writecount(vm_object_t object, vm_offset_t start,
-    vm_offset_t end);
 void vnode_pager_undirty_pages(vm_page_t *ma, int *rtvals, int written,
     off_t eof, int lpos);
-void vnode_pager_update_writecount(vm_object_t object, vm_offset_t start,
-    vm_offset_t end);
 
 #endif				/* _KERNEL */
 #endif				/* _VNODE_PAGER_ */



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201910210008.x9L08ZQt027865>