Attachment #187384 for bug #223015




		uobj = node->tn_reg.tn_aobj;
		if (uobj != NULL) {
			if (uobj->size != 0)
				atomic_subtract_long(&tmp->tm_pages_used, uobj->resident_page_count);
			KASSERT((uobj->flags & OBJ_TMPFS) == 0,
			    ("leaked OBJ_TMPFS node %p vm_obj %p", node, uobj));
			vm_object_deallocate(uobj);

	struct tmpfs_node *node;
	vm_object_t uobj;
	vm_page_t m;
	vm_pindex_t idx, newpages, oldpages, oldresident, newresident;
	off_t oldsize;
	int base, rv;


	 * its own.
	 */
	oldsize = node->tn_size;
	oldresident = uobj->resident_page_count;
	oldpages = OFF_TO_IDX(oldsize + PAGE_MASK);
	MPASS(oldpages == uobj->size);
	newpages = OFF_TO_IDX(newsize + PAGE_MASK);

		return (0);
	}

	if (newpages > oldpages &&
	    tmpfs_pages_check_avail(tmp, newpages - oldpages) == 0)
		return (ENOSPC);

	VM_OBJECT_WLOCK(uobj);
	if (newsize < oldsize) {
		/*

		}
	}
	uobj->size = newpages;
	newresident = uobj->resident_page_count;

	VM_OBJECT_WUNLOCK(uobj);

	atomic_add_long(&tmp->tm_pages_used, newresident - oldresident);

	node->tn_size = newsize;
	return (0);




	struct tmpfs_node *node;
	off_t oldsize;
	int error, ioflag;
	vm_pindex_t oldresident, newresident;
	struct tmpfs_mount *tmp;

	vp = v->a_vp;
	uio = v->a_uio;

	ioflag = v->a_ioflag;
	error = 0;
	node = VP_TO_TMPFS_NODE(vp);
	oldresident = node->tn_reg.tn_aobj->resident_page_count;
	oldsize = node->tn_size;
	tmp = VFS_TO_TMPFS(vp->v_mount);

	if (uio->uio_offset < 0 || vp->v_type != VREG)
		return (EINVAL);

		return (0);
	if (ioflag & IO_APPEND)
		uio->uio_offset = node->tn_size;
	if (uio->uio_offset + uio->uio_resid > tmp->tm_maxfilesize)
	  VFS_TO_TMPFS(vp->v_mount)->tm_maxfilesize)
		return (EFBIG);
	if (vn_rlimit_fsize(vp, uio, uio->uio_td))
		return (EFBIG);
/* XXX need to check for vm_object with holes, this test is simplistic XXX */
	if (tmp->tm_pages_used + howmany(uio->uio_resid, PAGE_SIZE) >= tmp->tm_pages_max)
		return(ENOSPC);
	if (uio->uio_offset + uio->uio_resid > node->tn_size) {
		error = tmpfs_reg_resize(vp, uio->uio_offset + uio->uio_resid,
		    FALSE);

	if (error != 0)
		(void)tmpfs_reg_resize(vp, oldsize, TRUE);

	newresident = node->tn_reg.tn_aobj->resident_page_count;
	if (newresident != oldresident)
		atomic_add_long(&tmp->tm_pages_used, newresident - oldresident);
out:
	MPASS(IMPLIES(error == 0, uio->uio_resid == 0));
	MPASS(IMPLIES(error != 0, oldsize == node->tn_size));

Return to bug 223015

Lines 351-357 Link Here

(-)/usr/src/sys/fs/tmpfs/tmpfs_subr.c (-7 / +6 lines)
351	uobj = node->tn_reg.tn_aobj;	351	uobj = node->tn_reg.tn_aobj;
352	if (uobj != NULL) {	352	if (uobj != NULL) {
353	if (uobj->size != 0)	353	if (uobj->size != 0)
354	atomic_subtract_long(&tmp->tm_pages_used, uobj->size);	354	atomic_subtract_long(&tmp->tm_pages_used, uobj->resident_page_count);
355	KASSERT((uobj->flags & OBJ_TMPFS) == 0,	355	KASSERT((uobj->flags & OBJ_TMPFS) == 0,
356	("leaked OBJ_TMPFS node %p vm_obj %p", node, uobj));	356	("leaked OBJ_TMPFS node %p vm_obj %p", node, uobj));
357	vm_object_deallocate(uobj);	357	vm_object_deallocate(uobj);
Lines 1361-1367 Link Here
1361	struct tmpfs_node *node;	1361	struct tmpfs_node *node;
1362	vm_object_t uobj;	1362	vm_object_t uobj;
1363	vm_page_t m;	1363	vm_page_t m;
1364	vm_pindex_t idx, newpages, oldpages;	1364	vm_pindex_t idx, newpages, oldpages, oldresident, newresident;
1365	off_t oldsize;	1365	off_t oldsize;
1366	int base, rv;	1366	int base, rv;
1367		1367
Lines 1379-1384 Link Here
1379	* its own.	1379	* its own.
1380	*/	1380	*/
1381	oldsize = node->tn_size;	1381	oldsize = node->tn_size;
		1382	oldresident = uobj->resident_page_count;
1382	oldpages = OFF_TO_IDX(oldsize + PAGE_MASK);	1383	oldpages = OFF_TO_IDX(oldsize + PAGE_MASK);
1383	MPASS(oldpages == uobj->size);	1384	MPASS(oldpages == uobj->size);
1384	newpages = OFF_TO_IDX(newsize + PAGE_MASK);	1385	newpages = OFF_TO_IDX(newsize + PAGE_MASK);
Lines 1388-1397 Link Here
1388	return (0);	1389	return (0);
1389	}	1390	}
1390		1391
1391	if (newpages > oldpages &&
1392	tmpfs_pages_check_avail(tmp, newpages - oldpages) == 0)
1393	return (ENOSPC);
1394
1395	VM_OBJECT_WLOCK(uobj);	1392	VM_OBJECT_WLOCK(uobj);
1396	if (newsize < oldsize) {	1393	if (newsize < oldsize) {
1397	/*	1394	/*
Lines 1457-1465 Link Here
1457	}	1454	}
1458	}	1455	}
1459	uobj->size = newpages;	1456	uobj->size = newpages;
		1457	newresident = uobj->resident_page_count;
		1458
1460	VM_OBJECT_WUNLOCK(uobj);	1459	VM_OBJECT_WUNLOCK(uobj);
1461		1460
1462	atomic_add_long(&tmp->tm_pages_used, newpages - oldpages);	1461	atomic_add_long(&tmp->tm_pages_used, newresident - oldresident);
1463		1462
1464	node->tn_size = newsize;	1463	node->tn_size = newsize;
1465	return (0);	1464	return (0);

Lines 488-493 Link Here

(-)/usr/src/sys/fs/tmpfs/tmpfs_vnops.c (-2 / +11 lines)
488	struct tmpfs_node *node;	488	struct tmpfs_node *node;
489	off_t oldsize;	489	off_t oldsize;
490	int error, ioflag;	490	int error, ioflag;
		491	vm_pindex_t oldresident, newresident;
		492	struct tmpfs_mount *tmp;
491		493
492	vp = v->a_vp;	494	vp = v->a_vp;
493	uio = v->a_uio;	495	uio = v->a_uio;
Lines 494-500 Link Here
494	ioflag = v->a_ioflag;	496	ioflag = v->a_ioflag;
495	error = 0;	497	error = 0;
496	node = VP_TO_TMPFS_NODE(vp);	498	node = VP_TO_TMPFS_NODE(vp);
		499	oldresident = node->tn_reg.tn_aobj->resident_page_count;
497	oldsize = node->tn_size;	500	oldsize = node->tn_size;
		501	tmp = VFS_TO_TMPFS(vp->v_mount);
498		502
499	if (uio->uio_offset < 0 \|\| vp->v_type != VREG)	503	if (uio->uio_offset < 0 \|\| vp->v_type != VREG)
500	return (EINVAL);	504	return (EINVAL);
Lines 502-512 Link Here
502	return (0);	506	return (0);
503	if (ioflag & IO_APPEND)	507	if (ioflag & IO_APPEND)
504	uio->uio_offset = node->tn_size;	508	uio->uio_offset = node->tn_size;
505	if (uio->uio_offset + uio->uio_resid >	509	if (uio->uio_offset + uio->uio_resid > tmp->tm_maxfilesize)
506	VFS_TO_TMPFS(vp->v_mount)->tm_maxfilesize)
507	return (EFBIG);	510	return (EFBIG);
508	if (vn_rlimit_fsize(vp, uio, uio->uio_td))	511	if (vn_rlimit_fsize(vp, uio, uio->uio_td))
509	return (EFBIG);	512	return (EFBIG);
		513	/* XXX need to check for vm_object with holes, this test is simplistic XXX */
		514	if (tmp->tm_pages_used + howmany(uio->uio_resid, PAGE_SIZE) >= tmp->tm_pages_max)
		515	return(ENOSPC);
510	if (uio->uio_offset + uio->uio_resid > node->tn_size) {	516	if (uio->uio_offset + uio->uio_resid > node->tn_size) {
511	error = tmpfs_reg_resize(vp, uio->uio_offset + uio->uio_resid,	517	error = tmpfs_reg_resize(vp, uio->uio_offset + uio->uio_resid,
512	FALSE);	518	FALSE);
Lines 524-529 Link Here
524	if (error != 0)	530	if (error != 0)
525	(void)tmpfs_reg_resize(vp, oldsize, TRUE);	531	(void)tmpfs_reg_resize(vp, oldsize, TRUE);
526		532
		533	newresident = node->tn_reg.tn_aobj->resident_page_count;
		534	if (newresident != oldresident)
		535	atomic_add_long(&tmp->tm_pages_used, newresident - oldresident);
527	out:	536	out:
528	MPASS(IMPLIES(error == 0, uio->uio_resid == 0));	537	MPASS(IMPLIES(error == 0, uio->uio_resid == 0));
529	MPASS(IMPLIES(error != 0, oldsize == node->tn_size));	538	MPASS(IMPLIES(error != 0, oldsize == node->tn_size));