Path: utzoo!attcan!uunet!samsung!munnari.oz.au!sirius.ucs.adelaide.edu.au!francis
From: francis@sirius.ucs.adelaide.edu.au (Francis Vaughan)
Newsgroups: comp.os.mach
Subject: External Pager Questions
Message-ID: <821@sirius.ucs.adelaide.edu.au>
Date: 17 Mar 90 14:03:00 GMT
Sender: francis@ucs.adelaide.edu.au
Organization: Computing Services, Uni of Adelaide, Australia
Lines: 61


A few people have recently requested info,or better, examples of external
pagers. I would second that request. I didn't see any replys on the net,
but if there has been some email conversations on the subject I would be
most grateful if I could get a summary.

Next a few questions on some finer points.

The Kernel Interface Manual refers to the external pager as a task. Is
there any inherent reason why it cannot be a thread within the same task as
the client for the externally paged memory object? (Sure, one would need to
be careful not to touch the memory object from within the pager to avoid a
potential infinite recursion.)

The memory_object_lock_request call allows one to lock a section of a
memory object. A few questions about it.

The manual says that the kernel will not page align the offset parameter.
Can this really be true? (or rather, make sense)

A memory_object_lock is applied to the cached memory (ie the physical
memory) and the memory is locked for access from all clients. How does this
relate to the use of vm_protect? Can I lock access to a section of an
externally paged memory object with vm_protect from a particular set of
tasks whilst leaving it at a different level of protection from others? Is
memory_object_lock_request (when used to protect memory) just shorthand for
vm_protect applied to all client tasks?

If I use vm_protect to deny access to part of a memory object from a
particular task, when that task touched the protected area will a
memory_object_data_unlock call be made on the external pager? (I can see
that this could be a problem at present as there is no parameter that
conveys the identity of the faulting task to the external pager.)

-------

And the reasons for my questions?

I need to catch accesses to pages of memory to build a coherent distributed
persistent data space. The catching mechanism (the external pager) needs to
be able to write onto the memory object it is serving, however it needs to
catch (when appropriate) read and writes to the page. Hence we deny access
to the page and wait for a memory_object_data_unlock call. However it
cannot write to the page (it is still locked) and it cannot unlock the
memory without violating the timing of the coherency logic (it must finish
updating the page before allowing the faulting task access to the page, and
there may be more than one thread running in the faulting task. So far the
external pager interface seems to just, but not quite have enough
functionality.

PS. A while ago I posted some questions about the use of the inode pager
and its relative merits. To date I have not seen a word in reply. Surely
someone has got something to say, I'll repost the questions if anyone
wants.



						Regards,
Dept of Computer Science                        Francis Vaughan
University of Adelaide                          francis@cs.ua.oz.au
South Australia