Isn't it a good moment to introduce a VM KPI to wrap this op into something like vm_page_disown() ? (I do not insist on the name).

Linuxkpi put_page() is yet another place.

In the review description I suggested doing this in a future diff, but I can try it here. Why not handle it in vm_page_unwire_noq(), instead of introducing a new KPI? Note that vm_page_unwire() already checks whether m->object == NULL.

But how would you detect that it is fine to free the page ? Checking VPO_UNMANAGED == 0 and object == NULL ? I am not sure that this would not break any caller.

Yes, in that case I think it should be safe to free the page. Typically, upon the last unwire it is also the caller's responsibility to enqueue the unwired page. But this must not be done if m->object == NULL, as the page daemon does not handle it.

Some auditing is required, but I think it is the right direction. I would like struct vm_page to have a general-purpose reference count with KPIs that implicitly handle freeing the page. Moreover, such a change would help avoid bugs like that fixed by r329216.

I think this is dead code. Remove it as pre-cleanup ?

Pass VM_ALLOC_WIRE ?

The this wiring is not needed, but unwire in error case is due.

May be kill this function ? It is quite confusing to leave it IMO. It is around dozen users of it, all in sys/vm.

It would seem more consistent to rename these functions as well now.

I concur on killing it and/or renaming it to 'vm_page_wired'

I think the whole routine is effectively dead code. It does not declare a return value. It certainly does not compile after the 4/4 split. Do you think it is worth preserving at all? If so I will remove the dead code, fix style and compilation issues.

I was being dismissive here, and the question requires more thought. I will explain why I chose to add the object == NULL checks.

Suppose we unhold a page with hold_count == 1. If PG_UNHOLDFREE is set, we must have m->object == NULL. The inverse statement is almost always true as well. Looking through the vm_page_remove() callers:

• SGX and TTM drivers, cdev_pager_free_page(). The pages are fictitious and their lifetime must be managed by the driver.
• We temporarily remove the page in the "optimized" CoW fault handler. This case represents a bug in my diff.
• vm_object_collapse_scan(). A wired page is removed from the object; the unwiring thread is responsible for freeing it. Same semantics as PG_UNHOLDFREE.
• vm_page_remove(). The page is moved between two objects with the page lock held, so the update to m->object is atomic with respect to the page lock.
• vm_page_reclaim_run(). We require that m->wire_count == 0 and m->hold_count == 0 in order for reclamation to proceed.
• vm_page_free_prep(). Sets PG_UNHOLDFREE if m->hold_count > 0.

Except for the CoW case mentioned above, I believe it is also true that if m->object == NULL in vm_page_unhold(), then PG_UNHOLDFREE must be set, so we will free the page. I will think about how to solve that one case.

The reordering is to preserve 32-bit alignment of aflags.

I renamed it to vm_page_wired(). IMO it is helpful to have the routine; might be that we want to use a few bits of wire_count for other purposes. There are many places where we still check m->wire_count inline. I will update them in a separate diff to avoid making this one too big and hard to read.

Yes, exactly, I mean pmap_pid_dump() as a whole. It is covered by PMAP_DEBUG which does not appear anywhere else.

So why not keep PG_UNHOLDFREE around, perhaps renamed ? This would fix the CoW case and removes very obscure detail of the wiring.

Ah, I thought you were referring only to the VM_MIN_KERNEL_ADDRESS fragment. I will simply remove this function, then.

Currently vm_page_free_prep() panics if the page is wired. Are you suggesting we change that semantic?

FWIW, I think PG_UNHOLDFREE is kind of hacky and complicates locking. Following this diff I wish to begin manipulating wire_count using atomics when the page is managed, as part of an effort to reduce the scope of the page lock.

If you merge hold and wire, then the semantic should be mostly a superposition of both. We allow freeing held pages, which means that it is reasonable to allow free wired pages after the merge.

Well, my desired semantic is to permit vm_page_unwire() to free the page if there are no more references, similar to PG_UNHOLDFREE. However, my plan is to count the object reference in wire_count and have vm_page_unwire() free the page when the last reference is released, since this simplifies synchronization.

I will post some more patches following this direction, to make discussion easier.

See D20486. It is a large diff and still needs a bit of work, but it is stable for me. I will try to continue splitting off pieces into separate reviews; D20485 can be committed separately, for instance.

Basically, with that change, vm_page_wire() will free the page upon the last reference. In particular, it has essentially the same semantics as PG_UNHOLDFREE.