default pager using legacy interfaces

[Marcus Brinkmann]

Hi,

the default pager in serverboot (also used by mach-defpager) is still using
the legacy interfaces memory_object_set_attributes() and
memory_object_data_write() to set the ready attribute and receive data from
the kernel.  The newer documentation suggests that memory_object_ready()
and memory_object_data_return() should be used.

I propose the following patch which updates it.  If there is no objection I
am going to check this in.

Thanks,
Marcus

2001-09-27  Marcus Brinkmann  <marcus@gnu.org>

        * default_pager.c (seqnos_memory_object_init): Call
        memory_object_change_attributes rather than
        memory_object_set_attributes.
        (seqnos_memory_object_data_write): Rename to
        seqnos_memory_object_data_return, fix arguments, change all
        occurences of the function name in the output to the new name.
        (seqnos_memory_object_data_return): Rename to
        seqnos_memory_object_data_write, fix arguments, change function
        name in the output to new name.

--- /mnt/marcus/gnu/cvs/hurd/serverboot/default_pager.c Mon Apr  2 02:52:38 2001
+++ serverboot/default_pager.c  Thu Sep 27 20:27:18 2001
@@ -2317,10 +2317,10 @@
         *      until we unlock the object.
         */
 
-       kr = memory_object_set_attributes(pager_request,
-                                         TRUE,
-                                         FALSE,        /* do not cache */
-                                         default_pager_copy_strategy);
+       kr = memory_object_change_attributes(pager_request,
+                                            FALSE,     /* do not cache */
+                                            default_pager_copy_strategy,
+                                            MACH_PORT_NULL);
        if (kr != KERN_SUCCESS)
            panic(here, my_name);
 
@@ -2646,33 +2646,34 @@
 }
 
 /*
- * memory_object_data_write: split up the stuff coming in from
- * a memory_object_data_write call
+ * memory_object_data_return: split up the stuff coming in from
+ * a memory_object_data_return call
  * into individual pages and pass them off to default_write.
  */
 kern_return_t
-seqnos_memory_object_data_write(pager, seqno, pager_request,
-                               offset, addr, data_cnt)
+seqnos_memory_object_data_return(pager, seqno, pager_request,
+                                offset, addr, data_cnt,
+                                dirty, kernel_copy)
        memory_object_t pager;
        mach_port_seqno_t seqno;
        mach_port_t     pager_request;
-       register
        vm_offset_t     offset;
-       register
        pointer_t       addr;
        vm_size_t       data_cnt;
+       boolean_t       dirty;
+       boolean_t       kernel_copy;
 {
        register
        vm_size_t       amount_sent;
        default_pager_t ds;
-       static char     here[] = "%sdata_write";
+       static char     here[] = "%sdata_return";
        int err;
 
 #ifdef lint
        pager_request++;
 #endif  /* lint */
 
-ddprintf ("seqnos_memory_object_data_write <%p>: 1\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: 1\n", &err);
        if ((data_cnt % vm_page_size) != 0)
          {
            ddprintf ("fail 1: %d %d\n", data_cnt, vm_page_size);
@@ -2680,43 +2681,43 @@
          }
 
 
-ddprintf ("seqnos_memory_object_data_write <%p>: 2\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: 2\n", &err);
        ds = pager_port_lookup(pager);
-ddprintf ("seqnos_memory_object_data_write <%p>: 3\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: 3\n", &err);
        if (ds == DEFAULT_PAGER_NULL)
          {
            ddprintf ("fail 2: %d %d\n", pager, ds);
            panic(here,my_name);
          }
 
-ddprintf ("seqnos_memory_object_data_write <%p>: 4\n", &err);
-ddprintf ("seqnos_memory_object_data_write <%p>: pager_port_lock: 
<%p>[s:%d,r:%d,w:%d,l:%d], %d\n",
+ddprintf ("seqnos_memory_object_data_return <%p>: 4\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: pager_port_lock: 
<%p>[s:%d,r:%d,w:%d,l:%d], %d\n",
        &err, ds, ds->seqno, ds->readers, ds->writers, ds->lock.held, seqno);
        pager_port_lock(ds, seqno);
-ddprintf ("seqnos_memory_object_data_write <%p>: 5\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: 5\n", &err);
        pager_port_check_request(ds, pager_request);
-ddprintf ("seqnos_memory_object_data_write <%p>: 6\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: 6\n", &err);
        pager_port_start_write(ds);
-ddprintf ("seqnos_memory_object_data_write <%p>: 7\n", &err);
-ddprintf ("seqnos_memory_object_data_write <%p>: pager_port_unlock: 
<%p>[s:%d,r:%d,w:%d,l:%d]\n",
+ddprintf ("seqnos_memory_object_data_return <%p>: 7\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: pager_port_unlock: 
<%p>[s:%d,r:%d,w:%d,l:%d]\n",
        &err, ds, ds->seqno, ds->readers, ds->writers, ds->lock.held);
        pager_port_unlock(ds);
 
-ddprintf ("seqnos_memory_object_data_write <%p>: 8\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: 8\n", &err);
        for (amount_sent = 0;
             amount_sent < data_cnt;
             amount_sent += vm_page_size) {
 
            register int result;
 
-ddprintf ("seqnos_memory_object_data_write <%p>: 9\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: 9\n", &err);
            result = default_write(&ds->dpager,
                              addr + amount_sent,
                              vm_page_size,
                              offset + amount_sent);
-ddprintf ("seqnos_memory_object_data_write <%p>: 10\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: 10\n", &err);
            if (result != KERN_SUCCESS) {
-ddprintf ("seqnos_memory_object_data_write <%p>: 11\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: 11\n", &err);
 #if debug
                dprintf("%s WRITE ERROR on default_pageout:", my_name);
                dprintf(" pager=%x, offset=0x%x, length=0x%x, result=%d\n",
@@ -2729,11 +2730,11 @@
            default_pager_pageout_count++;
        }
 
-ddprintf ("seqnos_memory_object_data_write <%p>: 12\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: 12\n", &err);
        pager_port_finish_write(ds);
-ddprintf ("seqnos_memory_object_data_write <%p>: 13\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: 13\n", &err);
        err = vm_deallocate(default_pager_self, addr, data_cnt);
-ddprintf ("seqnos_memory_object_data_write <%p>: 14\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: 14\n", &err);
        if (err != KERN_SUCCESS)
          {
            ddprintf ("fail 3: %s %s %s %s\n", default_pager_self, addr, 
data_cnt, &err);
@@ -2742,7 +2743,7 @@
          }
 
 
-ddprintf ("seqnos_memory_object_data_write <%p>: 15\n", &err);
+ddprintf ("seqnos_memory_object_data_return <%p>: 15\n", &err);
        return(KERN_SUCCESS);
 }
 
@@ -2810,19 +2811,18 @@
 }
 
 kern_return_t
-seqnos_memory_object_data_return(pager, seqno, pager_request,
-                                offset, addr, data_cnt,
-                                dirty, kernel_copy)
+seqnos_memory_object_data_write(pager, seqno, pager_request,
+                               offset, addr, data_cnt)
        memory_object_t pager;
        mach_port_seqno_t seqno;
        mach_port_t     pager_request;
+       register
        vm_offset_t     offset;
+       register
        pointer_t       addr;
        vm_size_t       data_cnt;
-       boolean_t       dirty;
-       boolean_t       kernel_copy;
 {
-       panic("%sdata_return",my_name);
+       panic("%sdata_write",my_name);
        return(KERN_FAILURE);
 }
 


-- 
`Rhubarb is no Egyptian god.' Debian http://www.debian.org brinkmd@debian.org
Marcus Brinkmann              GNU    http://www.gnu.org    marcus@gnu.org
Marcus.Brinkmann@ruhr-uni-bochum.de
http://www.marcus-brinkmann.de