Attachment #173037 for bug #204764




    CTLFLAG_MPSAFE, NULL, 0, sysctl_vm_loadavg, "S,loadavg",
    "Machine loadaverage history");

/*
 * This function aims to determine if the object is mapped,
 * specifically, if it is referenced by a vm_map_entry.  Because
 * objects occasionally acquire transient references that do not
 * represent a mapping, the method used here is inexact.  However, it
 * has very low overhead and is good enough for the advisory
 * vm.vmtotal sysctl.
 */
static bool
is_object_active(vm_object_t obj)
{

	return (obj->ref_count > obj->shadow_count);
}

static int
vmtotal(SYSCTL_HANDLER_ARGS)
{
	struct proc *p;
	struct vmtotal total;
	vm_map_entry_t entry;
	vm_object_t object;
	struct proc *p;
	int paging;
	struct thread *td;
	struct vmspace *vm;

	bzero(&total, sizeof(total));

	 * Mark all objects as inactive.
	 */
	mtx_lock(&vm_object_list_mtx);
	TAILQ_FOREACH(object, &vm_object_list, object_list) {
		VM_OBJECT_WLOCK(object);
		vm_object_clear_flag(object, OBJ_ACTIVE);
		VM_OBJECT_WUNLOCK(object);
	}
	mtx_unlock(&vm_object_list_mtx);
	/*
	 * Calculate process statistics.
	 */

				case TDS_INHIBITED:
					if (TD_IS_SWAPPED(td))
						total.t_sw++;
					else if (TD_IS_SLEEPING(td)) {
						if (td->td_priority <= PZERO)
							total.t_dw++;
						else
							total.t_sl++;
						if (td->td_wchan ==
						    &cnt.v_free_count)
							total.t_pw++;
					}
					break;

				case TDS_CAN_RUN:

			}
		}
		PROC_UNLOCK(p);
		/*
		 * Note active objects.
		 */
		paging = 0;
		vm = vmspace_acquire_ref(p);
		if (vm == NULL)
			continue;
		map = &vm->vm_map;
		vm_map_lock_read(map);
		for (entry = map->header.next;
		    entry != &map->header; entry = entry->next) {
			if ((entry->eflags & MAP_ENTRY_IS_SUB_MAP) ||
			    (object = entry->object.vm_object) == NULL)
				continue;
			VM_OBJECT_WLOCK(object);
			vm_object_set_flag(object, OBJ_ACTIVE);
			paging |= object->paging_in_progress;
			VM_OBJECT_WUNLOCK(object);
		}
		vm_map_unlock_read(map);
		vmspace_free(vm);
		if (paging)
			total.t_pw++;
	}
	sx_sunlock(&allproc_lock);
	/*

			 */
			continue;
		}
		if (object->ref_count == 1 &&
		    (object->flags & OBJ_NOSPLIT) != 0) {
			/*
			 * Also skip otherwise unreferenced swap
			 * objects backing tmpfs vnodes, and POSIX or
			 * SysV shared memory.
			 */
			continue;
		}
		total.t_vm += object->size;
		total.t_rm += object->resident_page_count;
		if (is_object_active(object)) {
			total.t_avm += object->size;
			total.t_arm += object->resident_page_count;
		}

			/* shared object */
			total.t_vmshr += object->size;
			total.t_rmshr += object->resident_page_count;
			if (is_object_active(object)) {
				total.t_avmshr += object->size;
				total.t_armshr += object->resident_page_count;
			}

Lines 181-187 Link Here

(-)sys/vm-neu/vm_object.h (-1 lines)
181	*/	181	*/
182	#define OBJ_FICTITIOUS 0x0001 /* (c) contains fictitious pages */	182	#define OBJ_FICTITIOUS 0x0001 /* (c) contains fictitious pages */
183	#define OBJ_UNMANAGED 0x0002 /* (c) contains unmanaged pages */	183	#define OBJ_UNMANAGED 0x0002 /* (c) contains unmanaged pages */
184	#define OBJ_ACTIVE 0x0004 /* active objects */
185	#define OBJ_DEAD 0x0008 /* dead objects (during rundown) */	184	#define OBJ_DEAD 0x0008 /* dead objects (during rundown) */
186	#define OBJ_NOSPLIT 0x0010 /* dont split this object */	185	#define OBJ_NOSPLIT 0x0010 /* dont split this object */
187	#define OBJ_PIPWNT 0x0040 /* paging in progress wanted */	186	#define OBJ_PIPWNT 0x0040 /* paging in progress wanted */

Return to bug 204764

Lines 93-121 Link Here

(-)sys/vm-neu/vm_meter.c (-45 / +37 lines)
93	CTLFLAG_MPSAFE, NULL, 0, sysctl_vm_loadavg, "S,loadavg",	89	CTLFLAG_MPSAFE, NULL, 0, sysctl_vm_loadavg, "S,loadavg",
94	"Machine loadaverage history");	90	"Machine loadaverage history");
95		91
		92	/*
		93	* This function aims to determine if the object is mapped,
		94	* specifically, if it is referenced by a vm_map_entry. Because
		95	* objects occasionally acquire transient references that do not
		96	* represent a mapping, the method used here is inexact. However, it
		97	* has very low overhead and is good enough for the advisory
		98	* vm.vmtotal sysctl.
		99	*/
		100	static bool
		101	is_object_active(vm_object_t obj)
		102	{
		103
		104	return (obj->ref_count > obj->shadow_count);
		105	}
		106
96	static int	107	static int
97	vmtotal(SYSCTL_HANDLER_ARGS)	108	vmtotal(SYSCTL_HANDLER_ARGS)
98	{	109	{
99	struct proc *p;
100	struct vmtotal total;	110	struct vmtotal total;
101	vm_map_entry_t entry;
102	vm_object_t object;	111	vm_object_t object;
103	vm_map_t map;	112	struct proc *p;
104	int paging;
105	struct thread *td;	113	struct thread *td;
106	struct vmspace *vm;
107		114
108	bzero(&total, sizeof(total));	115	bzero(&total, sizeof(total));
109	/*	116
110	* Mark all objects as inactive.
111	*/
112	mtx_lock(&vm_object_list_mtx);
113	TAILQ_FOREACH(object, &vm_object_list, object_list) {
114	VM_OBJECT_WLOCK(object);
115	vm_object_clear_flag(object, OBJ_ACTIVE);
116	VM_OBJECT_WUNLOCK(object);
117	}
118	mtx_unlock(&vm_object_list_mtx);
119	/*	117	/*
120	* Calculate process statistics.	118	* Calculate process statistics.
121	*/	119	*/
Lines 136-146 Link Here
136	case TDS_INHIBITED:	134	case TDS_INHIBITED:
137	if (TD_IS_SWAPPED(td))	135	if (TD_IS_SWAPPED(td))
138	total.t_sw++;	136	total.t_sw++;
139	else if (TD_IS_SLEEPING(td) &&	137	else if (TD_IS_SLEEPING(td)) {
140	td->td_priority <= PZERO)	138	if (td->td_priority <= PZERO)
141	total.t_dw++;	139	total.t_dw++;
142	else	140	else
143	total.t_sl++;	141	total.t_sl++;
		142	if (td->td_wchan ==
		143	&cnt.v_free_count)
		144	total.t_pw++;
		145	}
144	break;	146	break;
145		147
146	case TDS_CAN_RUN:	148	case TDS_CAN_RUN:
Lines 158-186 Link Here
158	}	160	}
159	}	161	}
160	PROC_UNLOCK(p);	162	PROC_UNLOCK(p);
161	/*
162	* Note active objects.
163	*/
164	paging = 0;
165	vm = vmspace_acquire_ref(p);
166	if (vm == NULL)
167	continue;
168	map = &vm->vm_map;
169	vm_map_lock_read(map);
170	for (entry = map->header.next;
171	entry != &map->header; entry = entry->next) {
172	if ((entry->eflags & MAP_ENTRY_IS_SUB_MAP) \|\|
173	(object = entry->object.vm_object) == NULL)
174	continue;
175	VM_OBJECT_WLOCK(object);
176	vm_object_set_flag(object, OBJ_ACTIVE);
177	paging \|= object->paging_in_progress;
178	VM_OBJECT_WUNLOCK(object);
179	}
180	vm_map_unlock_read(map);
181	vmspace_free(vm);
182	if (paging)
183	total.t_pw++;
184	}	163	}
185	sx_sunlock(&allproc_lock);	164	sx_sunlock(&allproc_lock);
186	/*	165	/*
Lines 206-214 Link Here
206	*/	185	*/
207	continue;	186	continue;
208	}	187	}
		188	if (object->ref_count == 1 &&
		189	(object->flags & OBJ_NOSPLIT) != 0) {
		190	/*
		191	* Also skip otherwise unreferenced swap
		192	* objects backing tmpfs vnodes, and POSIX or
		193	* SysV shared memory.
		194	*/
		195	continue;
		196	}
209	total.t_vm += object->size;	197	total.t_vm += object->size;
210	total.t_rm += object->resident_page_count;	198	total.t_rm += object->resident_page_count;
211	if (object->flags & OBJ_ACTIVE) {	199	if (is_object_active(object)) {
212	total.t_avm += object->size;	200	total.t_avm += object->size;
213	total.t_arm += object->resident_page_count;	201	total.t_arm += object->resident_page_count;
214	}	202	}
Lines 216-222 Link Here
216	/* shared object */	204	/* shared object */
217	total.t_vmshr += object->size;	205	total.t_vmshr += object->size;
218	total.t_rmshr += object->resident_page_count;	206	total.t_rmshr += object->resident_page_count;
219	if (object->flags & OBJ_ACTIVE) {	207	if (is_object_active(object)) {
220	total.t_avmshr += object->size;	208	total.t_avmshr += object->size;
221	total.t_armshr += object->resident_page_count;	209	total.t_armshr += object->resident_page_count;
222	}	210	}