Author: trasz
Date: Thu Dec 2 17:37:16 2010
New Revision: 216128
URL: http://svn.freebsd.org/changeset/base/216128
Log:
Replace pointer to "struct uidinfo" with pointer to "struct ucred"
in "struct vm_object". This is required to make it possible to account
for per-jail swap usage.
Reviewed by: kib@
Tested by: pho@
Sponsored by: FreeBSD Foundation
Modified:
head/sys/fs/procfs/procfs_map.c
head/sys/kern/uipc_shm.c
head/sys/vm/default_pager.c
head/sys/vm/swap_pager.c
head/sys/vm/vm.h
head/sys/vm/vm_fault.c
head/sys/vm/vm_map.c
head/sys/vm/vm_map.h
head/sys/vm/vm_object.c
head/sys/vm/vm_object.h
Modified: head/sys/fs/procfs/procfs_map.c
==============================================================================
--- head/sys/fs/procfs/procfs_map.c Thu Dec 2 17:36:47 2010
(r216127)
+++ head/sys/fs/procfs/procfs_map.c Thu Dec 2 17:37:16 2010
(r216128)
@@ -83,7 +83,7 @@ procfs_doprocmap(PFS_FILL_ARGS)
vm_map_entry_t entry, tmp_entry;
struct vnode *vp;
char *fullpath, *freepath;
- struct uidinfo *uip;
+ struct ucred *cred;
int error, vfslocked;
unsigned int last_timestamp;
#ifdef COMPAT_FREEBSD32
@@ -136,7 +136,7 @@ procfs_doprocmap(PFS_FILL_ARGS)
if (obj->shadow_count == 1)
privateresident = obj->resident_page_count;
}
- uip = (entry->uip) ? entry->uip : (obj ? obj->uip : NULL);
+ cred = (entry->cred) ? entry->cred : (obj ? obj->cred : NULL);
resident = 0;
addr = entry->start;
@@ -221,7 +221,7 @@ procfs_doprocmap(PFS_FILL_ARGS)
(e_eflags & MAP_ENTRY_COW)?"COW":"NCOW",
(e_eflags & MAP_ENTRY_NEEDS_COPY)?"NC":"NNC",
type, fullpath,
- uip ? "CH":"NCH", uip ? uip->ui_uid : -1);
+ cred ? "CH":"NCH", cred ? cred->cr_ruid : -1);
if (freepath != NULL)
free(freepath, M_TEMP);
Modified: head/sys/kern/uipc_shm.c
==============================================================================
--- head/sys/kern/uipc_shm.c Thu Dec 2 17:36:47 2010 (r216127)
+++ head/sys/kern/uipc_shm.c Thu Dec 2 17:37:16 2010 (r216128)
@@ -271,7 +271,7 @@ shm_dotruncate(struct shmfd *shmfd, off_
swap_pager_freespace(object, nobjsize, delta);
/* Free the swap accounted for shm */
- swap_release_by_uid(delta, object->uip);
+ swap_release_by_cred(delta, object->cred);
object->charge -= delta;
/*
@@ -314,7 +314,7 @@ shm_dotruncate(struct shmfd *shmfd, off_
/* Attempt to reserve the swap */
delta = ptoa(nobjsize - object->size);
- if (!swap_reserve_by_uid(delta, object->uip)) {
+ if (!swap_reserve_by_cred(delta, object->cred)) {
VM_OBJECT_UNLOCK(object);
return (ENOMEM);
}
Modified: head/sys/vm/default_pager.c
==============================================================================
--- head/sys/vm/default_pager.c Thu Dec 2 17:36:47 2010 (r216127)
+++ head/sys/vm/default_pager.c Thu Dec 2 17:37:16 2010 (r216128)
@@ -80,21 +80,19 @@ default_pager_alloc(void *handle, vm_oof
vm_ooffset_t offset, struct ucred *cred)
{
vm_object_t object;
- struct uidinfo *uip;
if (handle != NULL)
panic("default_pager_alloc: handle specified");
if (cred != NULL) {
- uip = cred->cr_ruidinfo;
- if (!swap_reserve_by_uid(size, uip))
+ if (!swap_reserve_by_cred(size, cred))
return (NULL);
- uihold(uip);
+ crhold(cred);
}
object = vm_object_allocate(OBJT_DEFAULT,
OFF_TO_IDX(round_page(offset + size)));
if (cred != NULL) {
VM_OBJECT_LOCK(object);
- object->uip = uip;
+ object->cred = cred;
object->charge = size;
VM_OBJECT_UNLOCK(object);
}
Modified: head/sys/vm/swap_pager.c
==============================================================================
--- head/sys/vm/swap_pager.c Thu Dec 2 17:36:47 2010 (r216127)
+++ head/sys/vm/swap_pager.c Thu Dec 2 17:37:16 2010 (r216128)
@@ -174,16 +174,19 @@ int
swap_reserve(vm_ooffset_t incr)
{
- return (swap_reserve_by_uid(incr, curthread->td_ucred->cr_ruidinfo));
+ return (swap_reserve_by_cred(incr, curthread->td_ucred));
}
int
-swap_reserve_by_uid(vm_ooffset_t incr, struct uidinfo *uip)
+swap_reserve_by_cred(vm_ooffset_t incr, struct ucred *cred)
{
vm_ooffset_t r, s;
int res, error;
static int curfail;
static struct timeval lastfail;
+ struct uidinfo *uip;
+
+ uip = cred->cr_ruidinfo;
if (incr & PAGE_MASK)
panic("swap_reserve: & PAGE_MASK");
@@ -249,17 +252,20 @@ swap_reserve_force(vm_ooffset_t incr)
void
swap_release(vm_ooffset_t decr)
{
- struct uidinfo *uip;
+ struct ucred *cred;
PROC_LOCK(curproc);
- uip = curthread->td_ucred->cr_ruidinfo;
- swap_release_by_uid(decr, uip);
+ cred = curthread->td_ucred;
+ swap_release_by_cred(decr, cred);
PROC_UNLOCK(curproc);
}
void
-swap_release_by_uid(vm_ooffset_t decr, struct uidinfo *uip)
+swap_release_by_cred(vm_ooffset_t decr, struct ucred *cred)
{
+ struct uidinfo *uip;
+
+ uip = cred->cr_ruidinfo;
if (decr & PAGE_MASK)
panic("swap_release: & PAGE_MASK");
@@ -579,9 +585,7 @@ swap_pager_alloc(void *handle, vm_ooffse
{
vm_object_t object;
vm_pindex_t pindex;
- struct uidinfo *uip;
- uip = NULL;
pindex = OFF_TO_IDX(offset + PAGE_MASK + size);
if (handle) {
mtx_lock(&Giant);
@@ -595,19 +599,18 @@ swap_pager_alloc(void *handle, vm_ooffse
object = vm_pager_object_lookup(NOBJLIST(handle), handle);
if (object == NULL) {
if (cred != NULL) {
- uip = cred->cr_ruidinfo;
- if (!swap_reserve_by_uid(size, uip)) {
+ if (!swap_reserve_by_cred(size, cred)) {
sx_xunlock(&sw_alloc_sx);
mtx_unlock(&Giant);
return (NULL);
}
- uihold(uip);
+ crhold(cred);
}
object = vm_object_allocate(OBJT_DEFAULT, pindex);
VM_OBJECT_LOCK(object);
object->handle = handle;
if (cred != NULL) {
- object->uip = uip;
+ object->cred = cred;
object->charge = size;
}
swp_pager_meta_build(object, 0, SWAPBLK_NONE);
@@ -617,15 +620,14 @@ swap_pager_alloc(void *handle, vm_ooffse
mtx_unlock(&Giant);
} else {
if (cred != NULL) {
- uip = cred->cr_ruidinfo;
- if (!swap_reserve_by_uid(size, uip))
+ if (!swap_reserve_by_cred(size, cred))
return (NULL);
- uihold(uip);
+ crhold(cred);
}
object = vm_object_allocate(OBJT_DEFAULT, pindex);
VM_OBJECT_LOCK(object);
if (cred != NULL) {
- object->uip = uip;
+ object->cred = cred;
object->charge = size;
}
swp_pager_meta_build(object, 0, SWAPBLK_NONE);
Modified: head/sys/vm/vm.h
==============================================================================
--- head/sys/vm/vm.h Thu Dec 2 17:36:47 2010 (r216127)
+++ head/sys/vm/vm.h Thu Dec 2 17:37:16 2010 (r216128)
@@ -141,12 +141,12 @@ struct kva_md_info {
extern struct kva_md_info kmi;
extern void vm_ksubmap_init(struct kva_md_info *);
-struct uidinfo;
+struct ucred;
int swap_reserve(vm_ooffset_t incr);
-int swap_reserve_by_uid(vm_ooffset_t incr, struct uidinfo *uip);
+int swap_reserve_by_cred(vm_ooffset_t incr, struct ucred *cred);
void swap_reserve_force(vm_ooffset_t incr);
void swap_release(vm_ooffset_t decr);
-void swap_release_by_uid(vm_ooffset_t decr, struct uidinfo *uip);
+void swap_release_by_cred(vm_ooffset_t decr, struct ucred *cred);
#endif /* VM_H */
Modified: head/sys/vm/vm_fault.c
==============================================================================
--- head/sys/vm/vm_fault.c Thu Dec 2 17:36:47 2010 (r216127)
+++ head/sys/vm/vm_fault.c Thu Dec 2 17:37:16 2010 (r216128)
@@ -1166,14 +1166,14 @@ vm_fault_copy_entry(vm_map_t dst_map, vm
dst_entry->offset = 0;
dst_object->charge = dst_entry->end - dst_entry->start;
if (fork_charge != NULL) {
- KASSERT(dst_entry->uip == NULL,
+ KASSERT(dst_entry->cred == NULL,
("vm_fault_copy_entry: leaked swp charge"));
- dst_object->uip = curthread->td_ucred->cr_ruidinfo;
- uihold(dst_object->uip);
+ dst_object->cred = curthread->td_ucred;
+ crhold(dst_object->cred);
*fork_charge += dst_object->charge;
} else {
- dst_object->uip = dst_entry->uip;
- dst_entry->uip = NULL;
+ dst_object->cred = dst_entry->cred;
+ dst_entry->cred = NULL;
}
access = prot = dst_entry->protection;
/*
Modified: head/sys/vm/vm_map.c
==============================================================================
--- head/sys/vm/vm_map.c Thu Dec 2 17:36:47 2010 (r216127)
+++ head/sys/vm/vm_map.c Thu Dec 2 17:37:16 2010 (r216128)
@@ -137,8 +137,8 @@ static void vm_map_zdtor(void *mem, int
static void vmspace_zdtor(void *mem, int size, void *arg);
#endif
-#define ENTRY_CHARGED(e) ((e)->uip != NULL || \
- ((e)->object.vm_object != NULL && (e)->object.vm_object->uip != NULL && \
+#define ENTRY_CHARGED(e) ((e)->cred != NULL || \
+ ((e)->object.vm_object != NULL && (e)->object.vm_object->cred != NULL && \
!((e)->eflags & MAP_ENTRY_NEEDS_COPY)))
/*
@@ -1095,7 +1095,7 @@ vm_map_insert(vm_map_t map, vm_object_t
vm_map_entry_t prev_entry;
vm_map_entry_t temp_entry;
vm_eflags_t protoeflags;
- struct uidinfo *uip;
+ struct ucred *cred;
boolean_t charge_prev_obj;
VM_MAP_ASSERT_LOCKED(map);
@@ -1140,7 +1140,7 @@ vm_map_insert(vm_map_t map, vm_object_t
if (cow & MAP_DISABLE_COREDUMP)
protoeflags |= MAP_ENTRY_NOCOREDUMP;
- uip = NULL;
+ cred = NULL;
KASSERT((object != kmem_object && object != kernel_object) ||
((object == kmem_object || object == kernel_object) &&
!(protoeflags & MAP_ENTRY_NEEDS_COPY)),
@@ -1152,10 +1152,10 @@ vm_map_insert(vm_map_t map, vm_object_t
if (!(cow & MAP_ACC_CHARGED) && !swap_reserve(end - start))
return (KERN_RESOURCE_SHORTAGE);
KASSERT(object == NULL || (protoeflags & MAP_ENTRY_NEEDS_COPY)
||
- object->uip == NULL,
+ object->cred == NULL,
("OVERCOMMIT: vm_map_insert o %p", object));
- uip = curthread->td_ucred->cr_ruidinfo;
- uihold(uip);
+ cred = curthread->td_ucred;
+ crhold(cred);
if (object == NULL && !(protoeflags & MAP_ENTRY_NEEDS_COPY))
charge_prev_obj = TRUE;
}
@@ -1181,9 +1181,9 @@ charged:
(prev_entry->eflags == protoeflags) &&
(prev_entry->end == start) &&
(prev_entry->wired_count == 0) &&
- (prev_entry->uip == uip ||
+ (prev_entry->cred == cred ||
(prev_entry->object.vm_object != NULL &&
- (prev_entry->object.vm_object->uip == uip))) &&
+ (prev_entry->object.vm_object->cred == cred))) &&
vm_object_coalesce(prev_entry->object.vm_object,
prev_entry->offset,
(vm_size_t)(prev_entry->end - prev_entry->start),
@@ -1200,8 +1200,8 @@ charged:
prev_entry->end = end;
vm_map_entry_resize_free(map, prev_entry);
vm_map_simplify_entry(map, prev_entry);
- if (uip != NULL)
- uifree(uip);
+ if (cred != NULL)
+ crfree(cred);
return (KERN_SUCCESS);
}
@@ -1215,11 +1215,11 @@ charged:
offset = prev_entry->offset +
(prev_entry->end - prev_entry->start);
vm_object_reference(object);
- if (uip != NULL && object != NULL && object->uip != NULL &&
+ if (cred != NULL && object != NULL && object->cred != NULL &&
!(prev_entry->eflags & MAP_ENTRY_NEEDS_COPY)) {
/* Object already accounts for this uid. */
- uifree(uip);
- uip = NULL;
+ crfree(cred);
+ cred = NULL;
}
}
@@ -1235,7 +1235,7 @@ charged:
new_entry = vm_map_entry_create(map);
new_entry->start = start;
new_entry->end = end;
- new_entry->uip = NULL;
+ new_entry->cred = NULL;
new_entry->eflags = protoeflags;
new_entry->object.vm_object = object;
@@ -1247,9 +1247,9 @@ charged:
new_entry->max_protection = max;
new_entry->wired_count = 0;
- KASSERT(uip == NULL || !ENTRY_CHARGED(new_entry),
+ KASSERT(cred == NULL || !ENTRY_CHARGED(new_entry),
("OVERCOMMIT: vm_map_insert leaks vm_map %p", new_entry));
- new_entry->uip = uip;
+ new_entry->cred = cred;
/*
* Insert the new entry into the list
@@ -1466,7 +1466,7 @@ vm_map_simplify_entry(vm_map_t map, vm_m
(prev->max_protection == entry->max_protection) &&
(prev->inheritance == entry->inheritance) &&
(prev->wired_count == entry->wired_count) &&
- (prev->uip == entry->uip)) {
+ (prev->cred == entry->cred)) {
vm_map_entry_unlink(map, prev);
entry->start = prev->start;
entry->offset = prev->offset;
@@ -1484,8 +1484,8 @@ vm_map_simplify_entry(vm_map_t map, vm_m
*/
if (prev->object.vm_object)
vm_object_deallocate(prev->object.vm_object);
- if (prev->uip != NULL)
- uifree(prev->uip);
+ if (prev->cred != NULL)
+ crfree(prev->cred);
vm_map_entry_dispose(map, prev);
}
}
@@ -1502,7 +1502,7 @@ vm_map_simplify_entry(vm_map_t map, vm_m
(next->max_protection == entry->max_protection) &&
(next->inheritance == entry->inheritance) &&
(next->wired_count == entry->wired_count) &&
- (next->uip == entry->uip)) {
+ (next->cred == entry->cred)) {
vm_map_entry_unlink(map, next);
entry->end = next->end;
vm_map_entry_resize_free(map, entry);
@@ -1512,8 +1512,8 @@ vm_map_simplify_entry(vm_map_t map, vm_m
*/
if (next->object.vm_object)
vm_object_deallocate(next->object.vm_object);
- if (next->uip != NULL)
- uifree(next->uip);
+ if (next->cred != NULL)
+ crfree(next->cred);
vm_map_entry_dispose(map, next);
}
}
@@ -1562,21 +1562,21 @@ _vm_map_clip_start(vm_map_t map, vm_map_
atop(entry->end - entry->start));
entry->object.vm_object = object;
entry->offset = 0;
- if (entry->uip != NULL) {
- object->uip = entry->uip;
+ if (entry->cred != NULL) {
+ object->cred = entry->cred;
object->charge = entry->end - entry->start;
- entry->uip = NULL;
+ entry->cred = NULL;
}
} else if (entry->object.vm_object != NULL &&
((entry->eflags & MAP_ENTRY_NEEDS_COPY) == 0) &&
- entry->uip != NULL) {
+ entry->cred != NULL) {
VM_OBJECT_LOCK(entry->object.vm_object);
- KASSERT(entry->object.vm_object->uip == NULL,
- ("OVERCOMMIT: vm_entry_clip_start: both uip e %p", entry));
- entry->object.vm_object->uip = entry->uip;
+ KASSERT(entry->object.vm_object->cred == NULL,
+ ("OVERCOMMIT: vm_entry_clip_start: both cred e %p", entry));
+ entry->object.vm_object->cred = entry->cred;
entry->object.vm_object->charge = entry->end - entry->start;
VM_OBJECT_UNLOCK(entry->object.vm_object);
- entry->uip = NULL;
+ entry->cred = NULL;
}
new_entry = vm_map_entry_create(map);
@@ -1585,8 +1585,8 @@ _vm_map_clip_start(vm_map_t map, vm_map_
new_entry->end = start;
entry->offset += (start - entry->start);
entry->start = start;
- if (new_entry->uip != NULL)
- uihold(entry->uip);
+ if (new_entry->cred != NULL)
+ crhold(entry->cred);
vm_map_entry_link(map, entry->prev, new_entry);
@@ -1632,21 +1632,21 @@ _vm_map_clip_end(vm_map_t map, vm_map_en
atop(entry->end - entry->start));
entry->object.vm_object = object;
entry->offset = 0;
- if (entry->uip != NULL) {
- object->uip = entry->uip;
+ if (entry->cred != NULL) {
+ object->cred = entry->cred;
object->charge = entry->end - entry->start;
- entry->uip = NULL;
+ entry->cred = NULL;
}
} else if (entry->object.vm_object != NULL &&
((entry->eflags & MAP_ENTRY_NEEDS_COPY) == 0) &&
- entry->uip != NULL) {
+ entry->cred != NULL) {
VM_OBJECT_LOCK(entry->object.vm_object);
- KASSERT(entry->object.vm_object->uip == NULL,
- ("OVERCOMMIT: vm_entry_clip_end: both uip e %p", entry));
- entry->object.vm_object->uip = entry->uip;
+ KASSERT(entry->object.vm_object->cred == NULL,
+ ("OVERCOMMIT: vm_entry_clip_end: both cred e %p", entry));
+ entry->object.vm_object->cred = entry->cred;
entry->object.vm_object->charge = entry->end - entry->start;
VM_OBJECT_UNLOCK(entry->object.vm_object);
- entry->uip = NULL;
+ entry->cred = NULL;
}
/*
@@ -1657,8 +1657,8 @@ _vm_map_clip_end(vm_map_t map, vm_map_en
new_entry->start = entry->end = end;
new_entry->offset += (end - entry->start);
- if (new_entry->uip != NULL)
- uihold(entry->uip);
+ if (new_entry->cred != NULL)
+ crhold(entry->cred);
vm_map_entry_link(map, entry, new_entry);
@@ -1812,7 +1812,7 @@ vm_map_protect(vm_map_t map, vm_offset_t
{
vm_map_entry_t current, entry;
vm_object_t obj;
- struct uidinfo *uip;
+ struct ucred *cred;
vm_prot_t old_prot;
vm_map_lock(map);
@@ -1858,7 +1858,7 @@ vm_map_protect(vm_map_t map, vm_offset_t
continue;
}
- uip = curthread->td_ucred->cr_ruidinfo;
+ cred = curthread->td_ucred;
obj = current->object.vm_object;
if (obj == NULL || (current->eflags & MAP_ENTRY_NEEDS_COPY)) {
@@ -1866,8 +1866,8 @@ vm_map_protect(vm_map_t map, vm_offset_t
vm_map_unlock(map);
return (KERN_RESOURCE_SHORTAGE);
}
- uihold(uip);
- current->uip = uip;
+ crhold(cred);
+ current->cred = cred;
continue;
}
@@ -1890,8 +1890,8 @@ vm_map_protect(vm_map_t map, vm_offset_t
return (KERN_RESOURCE_SHORTAGE);
}
- uihold(uip);
- obj->uip = uip;
+ crhold(cred);
+ obj->cred = cred;
obj->charge = ptoa(obj->size);
VM_OBJECT_UNLOCK(obj);
}
@@ -2640,16 +2640,16 @@ vm_map_entry_delete(vm_map_t map, vm_map
size = entry->end - entry->start;
map->size -= size;
- if (entry->uip != NULL) {
- swap_release_by_uid(size, entry->uip);
- uifree(entry->uip);
+ if (entry->cred != NULL) {
+ swap_release_by_cred(size, entry->cred);
+ crfree(entry->cred);
}
if ((entry->eflags & MAP_ENTRY_IS_SUB_MAP) == 0 &&
(object != NULL)) {
- KASSERT(entry->uip == NULL || object->uip == NULL ||
+ KASSERT(entry->cred == NULL || object->cred == NULL ||
(entry->eflags & MAP_ENTRY_NEEDS_COPY),
- ("OVERCOMMIT vm_map_entry_delete: both uip %p", entry));
+ ("OVERCOMMIT vm_map_entry_delete: both cred %p", entry));
count = OFF_TO_IDX(size);
offidxstart = OFF_TO_IDX(entry->offset);
offidxend = offidxstart + count;
@@ -2665,11 +2665,11 @@ vm_map_entry_delete(vm_map_t map, vm_map
offidxstart < object->size) {
size1 = object->size;
object->size = offidxstart;
- if (object->uip != NULL) {
+ if (object->cred != NULL) {
size1 -= object->size;
KASSERT(object->charge >= ptoa(size1),
("vm_map_entry_delete:
object->charge < 0"));
- swap_release_by_uid(ptoa(size1),
object->uip);
+ swap_release_by_cred(ptoa(size1),
object->cred);
object->charge -= ptoa(size1);
}
}
@@ -2855,7 +2855,7 @@ vm_map_copy_entry(
{
vm_object_t src_object;
vm_offset_t size;
- struct uidinfo *uip;
+ struct ucred *cred;
int charged;
VM_MAP_ASSERT_LOCKED(dst_map);
@@ -2894,25 +2894,25 @@ vm_map_copy_entry(
}
vm_object_reference_locked(src_object);
vm_object_clear_flag(src_object, OBJ_ONEMAPPING);
- if (src_entry->uip != NULL &&
+ if (src_entry->cred != NULL &&
!(src_entry->eflags & MAP_ENTRY_NEEDS_COPY)) {
- KASSERT(src_object->uip == NULL,
- ("OVERCOMMIT: vm_map_copy_entry: uip %p",
+ KASSERT(src_object->cred == NULL,
+ ("OVERCOMMIT: vm_map_copy_entry: cred %p",
src_object));
- src_object->uip = src_entry->uip;
+ src_object->cred = src_entry->cred;
src_object->charge = size;
}
VM_OBJECT_UNLOCK(src_object);
dst_entry->object.vm_object = src_object;
if (charged) {
- uip = curthread->td_ucred->cr_ruidinfo;
- uihold(uip);
- dst_entry->uip = uip;
+ cred = curthread->td_ucred;
+ crhold(cred);
+ dst_entry->cred = cred;
*fork_charge += size;
if (!(src_entry->eflags &
MAP_ENTRY_NEEDS_COPY)) {
- uihold(uip);
- src_entry->uip = uip;
+ crhold(cred);
+ src_entry->cred = cred;
*fork_charge += size;
}
}
@@ -2922,9 +2922,9 @@ vm_map_copy_entry(
} else {
dst_entry->object.vm_object = NULL;
dst_entry->offset = 0;
- if (src_entry->uip != NULL) {
- dst_entry->uip =
curthread->td_ucred->cr_ruidinfo;
- uihold(dst_entry->uip);
+ if (src_entry->cred != NULL) {
+ dst_entry->cred = curthread->td_ucred;
+ crhold(dst_entry->cred);
*fork_charge += size;
}
}
@@ -3026,11 +3026,11 @@ vmspace_fork(struct vmspace *vm1, vm_oof
atop(old_entry->end -
old_entry->start));
old_entry->object.vm_object = object;
old_entry->offset = 0;
- if (old_entry->uip != NULL) {
- object->uip = old_entry->uip;
+ if (old_entry->cred != NULL) {
+ object->cred = old_entry->cred;
object->charge = old_entry->end -
old_entry->start;
- old_entry->uip = NULL;
+ old_entry->cred = NULL;
}
}
@@ -3058,11 +3058,11 @@ vmspace_fork(struct vmspace *vm1, vm_oof
}
VM_OBJECT_LOCK(object);
vm_object_clear_flag(object, OBJ_ONEMAPPING);
- if (old_entry->uip != NULL) {
- KASSERT(object->uip == NULL, ("vmspace_fork
both uip"));
- object->uip = old_entry->uip;
+ if (old_entry->cred != NULL) {
+ KASSERT(object->cred == NULL, ("vmspace_fork
both cred"));
+ object->cred = old_entry->cred;
object->charge = old_entry->end -
old_entry->start;
- old_entry->uip = NULL;
+ old_entry->cred = NULL;
}
VM_OBJECT_UNLOCK(object);
@@ -3102,7 +3102,7 @@ vmspace_fork(struct vmspace *vm1, vm_oof
MAP_ENTRY_IN_TRANSITION);
new_entry->wired_count = 0;
new_entry->object.vm_object = NULL;
- new_entry->uip = NULL;
+ new_entry->cred = NULL;
vm_map_entry_link(new_map, new_map->header.prev,
new_entry);
vmspace_map_entry_forked(vm1, vm2, new_entry);
@@ -3241,7 +3241,7 @@ vm_map_growstack(struct proc *p, vm_offs
size_t grow_amount, max_grow;
rlim_t stacklim, vmemlim;
int is_procstack, rv;
- struct uidinfo *uip;
+ struct ucred *cred;
Retry:
PROC_LOCK(p);
@@ -3412,17 +3412,17 @@ Retry:
}
grow_amount = addr - stack_entry->end;
- uip = stack_entry->uip;
- if (uip == NULL && stack_entry->object.vm_object != NULL)
- uip = stack_entry->object.vm_object->uip;
- if (uip != NULL && !swap_reserve_by_uid(grow_amount, uip))
+ cred = stack_entry->cred;
+ if (cred == NULL && stack_entry->object.vm_object != NULL)
+ cred = stack_entry->object.vm_object->cred;
+ if (cred != NULL && !swap_reserve_by_cred(grow_amount, cred))
rv = KERN_NO_SPACE;
/* Grow the underlying object if applicable. */
else if (stack_entry->object.vm_object == NULL ||
vm_object_coalesce(stack_entry->object.vm_object,
stack_entry->offset,
(vm_size_t)(stack_entry->end - stack_entry->start),
- (vm_size_t)grow_amount, uip != NULL)) {
+ (vm_size_t)grow_amount, cred != NULL)) {
map->size += (addr - stack_entry->end);
/* Update the current entry. */
stack_entry->end = addr;
@@ -3503,7 +3503,7 @@ vmspace_unshare(struct proc *p)
newvmspace = vmspace_fork(oldvmspace, &fork_charge);
if (newvmspace == NULL)
return (ENOMEM);
- if (!swap_reserve_by_uid(fork_charge, p->p_ucred->cr_ruidinfo)) {
+ if (!swap_reserve_by_cred(fork_charge, p->p_ucred)) {
vmspace_free(newvmspace);
return (ENOMEM);
}
@@ -3553,7 +3553,7 @@ vm_map_lookup(vm_map_t *var_map, /* IN/
vm_prot_t prot;
vm_prot_t fault_type = fault_typea;
vm_object_t eobject;
- struct uidinfo *uip;
+ struct ucred *cred;
vm_ooffset_t size;
RetryLookup:;
@@ -3627,19 +3627,19 @@ RetryLookup:;
if (vm_map_lock_upgrade(map))
goto RetryLookup;
- if (entry->uip == NULL) {
+ if (entry->cred == NULL) {
/*
* The debugger owner is charged for
* the memory.
*/
- uip = curthread->td_ucred->cr_ruidinfo;
- uihold(uip);
- if (!swap_reserve_by_uid(size, uip)) {
- uifree(uip);
+ cred = curthread->td_ucred;
+ crhold(cred);
+ if (!swap_reserve_by_cred(size, cred)) {
+ crfree(cred);
vm_map_unlock(map);
return (KERN_RESOURCE_SHORTAGE);
}
- entry->uip = uip;
+ entry->cred = cred;
}
vm_object_shadow(
&entry->object.vm_object,
@@ -3647,19 +3647,19 @@ RetryLookup:;
atop(size));
entry->eflags &= ~MAP_ENTRY_NEEDS_COPY;
eobject = entry->object.vm_object;
- if (eobject->uip != NULL) {
+ if (eobject->cred != NULL) {
/*
* The object was not shadowed.
*/
- swap_release_by_uid(size, entry->uip);
- uifree(entry->uip);
- entry->uip = NULL;
- } else if (entry->uip != NULL) {
+ swap_release_by_cred(size, entry->cred);
+ crfree(entry->cred);
+ entry->cred = NULL;
+ } else if (entry->cred != NULL) {
VM_OBJECT_LOCK(eobject);
- eobject->uip = entry->uip;
+ eobject->cred = entry->cred;
eobject->charge = size;
VM_OBJECT_UNLOCK(eobject);
- entry->uip = NULL;
+ entry->cred = NULL;
}
vm_map_lock_downgrade(map);
@@ -3682,12 +3682,12 @@ RetryLookup:;
entry->object.vm_object = vm_object_allocate(OBJT_DEFAULT,
atop(size));
entry->offset = 0;
- if (entry->uip != NULL) {
+ if (entry->cred != NULL) {
VM_OBJECT_LOCK(entry->object.vm_object);
- entry->object.vm_object->uip = entry->uip;
+ entry->object.vm_object->cred = entry->cred;
entry->object.vm_object->charge = size;
VM_OBJECT_UNLOCK(entry->object.vm_object);
- entry->uip = NULL;
+ entry->cred = NULL;
}
vm_map_lock_downgrade(map);
}
@@ -3861,14 +3861,14 @@ DB_SHOW_COMMAND(map, vm_map_print)
db_indent -= 2;
}
} else {
- if (entry->uip != NULL)
- db_printf(", uip %d", entry->uip->ui_uid);
+ if (entry->cred != NULL)
+ db_printf(", ruid %d", entry->cred->cr_ruid);
db_printf(", object=%p, offset=0x%jx",
(void *)entry->object.vm_object,
(uintmax_t)entry->offset);
- if (entry->object.vm_object &&
entry->object.vm_object->uip)
- db_printf(", obj uip %d charge %jx",
- entry->object.vm_object->uip->ui_uid,
+ if (entry->object.vm_object &&
entry->object.vm_object->cred)
+ db_printf(", obj ruid %d charge %jx",
+ entry->object.vm_object->cred->cr_ruid,
(uintmax_t)entry->object.vm_object->charge);
if (entry->eflags & MAP_ENTRY_COW)
db_printf(", copy (%s)",
Modified: head/sys/vm/vm_map.h
==============================================================================
--- head/sys/vm/vm_map.h Thu Dec 2 17:36:47 2010 (r216127)
+++ head/sys/vm/vm_map.h Thu Dec 2 17:37:16 2010 (r216128)
@@ -114,7 +114,7 @@ struct vm_map_entry {
vm_inherit_t inheritance; /* inheritance */
int wired_count; /* can be paged if = 0 */
vm_pindex_t lastr; /* last read */
- struct uidinfo *uip; /* tmp storage for creator ref */
+ struct ucred *cred; /* tmp storage for creator ref */
};
#define MAP_ENTRY_NOSYNC 0x0001
Modified: head/sys/vm/vm_object.c
==============================================================================
--- head/sys/vm/vm_object.c Thu Dec 2 17:36:47 2010 (r216127)
+++ head/sys/vm/vm_object.c Thu Dec 2 17:37:16 2010 (r216128)
@@ -213,7 +213,7 @@ _vm_object_allocate(objtype_t type, vm_p
object->ref_count = 1;
object->memattr = VM_MEMATTR_DEFAULT;
object->flags = 0;
- object->uip = NULL;
+ object->cred = NULL;
object->charge = 0;
if ((object->type == OBJT_DEFAULT) || (object->type == OBJT_SWAP))
object->flags = OBJ_ONEMAPPING;
@@ -634,15 +634,15 @@ vm_object_destroy(vm_object_t object)
/*
* Release the allocation charge.
*/
- if (object->uip != NULL) {
+ if (object->cred != NULL) {
KASSERT(object->type == OBJT_DEFAULT ||
object->type == OBJT_SWAP,
- ("vm_object_terminate: non-swap obj %p has uip",
+ ("vm_object_terminate: non-swap obj %p has cred",
object));
- swap_release_by_uid(object->charge, object->uip);
+ swap_release_by_cred(object->charge, object->cred);
object->charge = 0;
- uifree(object->uip);
- object->uip = NULL;
+ crfree(object->cred);
+ object->cred = NULL;
}
/*
@@ -1247,9 +1247,9 @@ vm_object_split(vm_map_entry_t entry)
orig_object->backing_object_offset + entry->offset;
new_object->backing_object = source;
}
- if (orig_object->uip != NULL) {
- new_object->uip = orig_object->uip;
- uihold(orig_object->uip);
+ if (orig_object->cred != NULL) {
+ new_object->cred = orig_object->cred;
+ crhold(orig_object->cred);
new_object->charge = ptoa(size);
KASSERT(orig_object->charge >= ptoa(size),
("orig_object->charge < 0"));
@@ -1928,20 +1928,20 @@ vm_object_coalesce(vm_object_t prev_obje
/*
* Account for the charge.
*/
- if (prev_object->uip != NULL) {
+ if (prev_object->cred != NULL) {
/*
* If prev_object was charged, then this mapping,
* althought not charged now, may become writable
- * later. Non-NULL uip in the object would prevent
+ * later. Non-NULL cred in the object would prevent
* swap reservation during enabling of the write
* access, so reserve swap now. Failed reservation
* cause allocation of the separate object for the map
* entry, and swap reservation for this entry is
* managed in appropriate time.
*/
- if (!reserved && !swap_reserve_by_uid(ptoa(next_size),
- prev_object->uip)) {
+ if (!reserved && !swap_reserve_by_cred(ptoa(next_size),
+ prev_object->cred)) {
return (FALSE);
}
prev_object->charge += ptoa(next_size);
@@ -1959,7 +1959,7 @@ vm_object_coalesce(vm_object_t prev_obje
swap_pager_freespace(prev_object,
next_pindex, next_size);
#if 0
- if (prev_object->uip != NULL) {
+ if (prev_object->cred != NULL) {
KASSERT(prev_object->charge >=
ptoa(prev_object->size - next_pindex),
("object %p overcharged 1 %jx %jx", prev_object,
@@ -2111,10 +2111,10 @@ DB_SHOW_COMMAND(object, vm_object_print_
return;
db_iprintf(
- "Object %p: type=%d, size=0x%jx, res=%d, ref=%d, flags=0x%x uip %d
charge %jx\n",
+ "Object %p: type=%d, size=0x%jx, res=%d, ref=%d, flags=0x%x ruid %d
charge %jx\n",
object, (int)object->type, (uintmax_t)object->size,
object->resident_page_count, object->ref_count, object->flags,
- object->uip ? object->uip->ui_uid : -1, (uintmax_t)object->charge);
+ object->cred ? object->cred->cr_ruid : -1,
(uintmax_t)object->charge);
db_iprintf(" sref=%d, backing_object(%d)=(%p)+0x%jx\n",
object->shadow_count,
object->backing_object ? object->backing_object->ref_count : 0,
Modified: head/sys/vm/vm_object.h
==============================================================================
--- head/sys/vm/vm_object.h Thu Dec 2 17:36:47 2010 (r216127)
+++ head/sys/vm/vm_object.h Thu Dec 2 17:37:16 2010 (r216128)
@@ -143,7 +143,7 @@ struct vm_object {
int swp_bcount;
} swp;
} un_pager;
- struct uidinfo *uip;
+ struct ucred *cred;
vm_ooffset_t charge;
};
_______________________________________________
svn-src-head@freebsd.org mailing list
http://lists.freebsd.org/mailman/listinfo/svn-src-head
To unsubscribe, send any mail to "svn-src-head-unsubscr...@freebsd.org"
