diff options
Diffstat (limited to 'debian')
| -rw-r--r-- | debian/patches/mach-defpager-protected-payload.patch | 710 | ||||
| -rw-r--r-- | debian/patches/series | 1 |
2 files changed, 711 insertions, 0 deletions
diff --git a/debian/patches/mach-defpager-protected-payload.patch b/debian/patches/mach-defpager-protected-payload.patch new file mode 100644 index 00000000..36d4de45 --- /dev/null +++ b/debian/patches/mach-defpager-protected-payload.patch @@ -0,0 +1,710 @@ +diff --git a/mach-defpager/Makefile b/mach-defpager/Makefile +index 09debed..ed115bd 100644 +--- a/mach-defpager/Makefile ++++ b/mach-defpager/Makefile +@@ -27,7 +27,7 @@ SRCS := default_pager.c kalloc.c wiring.c main.c setup.c + OBJS := $(SRCS:.c=.o) \ + $(addsuffix Server.o,\ + memory_object default_pager memory_object_default exc) \ +- default_pager_replyUser.o ++ default_pager_replyUser.o mach_portUser.o + + HURDLIBS:= ihash + OTHERLIBS:= -lpthread +diff --git a/mach-defpager/default_pager.c b/mach-defpager/default_pager.c +index 77caa4a..4681669 100644 +--- a/mach-defpager/default_pager.c ++++ b/mach-defpager/default_pager.c +@@ -1803,6 +1803,12 @@ void pager_port_list_insert(port, ds) + (hurd_ihash_key_t) port, + (hurd_ihash_value_t) ds); + pthread_mutex_unlock(&all_pagers.lock); ++ ++ /* Try to set a protected payload. This is an optimization, ++ if it fails we degrade gracefully. */ ++ mach_port_set_protected_payload (mach_task_self (), ++ port, ++ (unsigned long) ds); + } + + void pager_port_list_delete(ds) +@@ -1812,6 +1818,9 @@ void pager_port_list_delete(ds) + hurd_ihash_locp_remove (&all_pagers.htable, + ds->htable_locp); + pthread_mutex_unlock(&all_pagers.lock); ++ ++ mach_port_clear_protected_payload (mach_task_self (), ++ ds->pager); + } + + /* +diff --git a/mach-defpager/mach/mach_types.defs b/mach-defpager/mach/mach_types.defs +new file mode 100644 +index 0000000..85ad653 +--- /dev/null ++++ b/mach-defpager/mach/mach_types.defs +@@ -0,0 +1,261 @@ ++/* ++ * Mach Operating System ++ * Copyright (c) 1994-1988 Carnegie Mellon University. ++ * Copyright (c) 1993,1994 The University of Utah and ++ * the Computer Systems Laboratory (CSL). ++ * All rights reserved. ++ * ++ * Permission to use, copy, modify and distribute this software and its ++ * documentation is hereby granted, provided that both the copyright ++ * notice and this permission notice appear in all copies of the ++ * software, derivative works or modified versions, and any portions ++ * thereof, and that both notices appear in supporting documentation. ++ * ++ * CARNEGIE MELLON, THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF ++ * THIS SOFTWARE IN ITS "AS IS" CONDITION, AND DISCLAIM ANY LIABILITY ++ * OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF ++ * THIS SOFTWARE. ++ * ++ * Carnegie Mellon requests users of this software to return to ++ * ++ * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU ++ * School of Computer Science ++ * Carnegie Mellon University ++ * Pittsburgh PA 15213-3890 ++ * ++ * any improvements or extensions that they make and grant Carnegie Mellon ++ * the rights to redistribute these changes. ++ */ ++/* ++ * Mach kernel interface type declarations ++ */ ++ ++#ifndef _MACH_MACH_TYPES_DEFS_ ++#define _MACH_MACH_TYPES_DEFS_ ++ ++/* ++ * For KernelServer and KernelUser interfaces, Mig will ++ * automagically use ipc_port_t instead of mach_port_t ++ * on the kernel side of the interface. For example, ++ * convert_task_to_port really returns ipc_port_t. ++ * Doing this in Mig saves many explicit conditional ++ * cusertype/cservertype declarations. ++ * ++ * Mig doesn't translate the components of an array. ++ * For example, Mig won't use the thread_t translations ++ * to translate a thread_array_t argument. ++ */ ++ ++#include <mach/std_types.defs> ++#if KERNEL_SERVER ++#endif /* KERNEL_SERVER */ ++ ++#ifdef USERPREFIX ++userprefix USERPREFIX; ++#endif ++ ++#ifdef SERVERPREFIX ++serverprefix SERVERPREFIX; ++#endif ++ ++type mach_port_status_t = struct[9] of integer_t; ++ ++type old_mach_port_status_t = struct[8] of integer_t; /* compatibility */ ++ ++type task_t = mach_port_t ++ ctype: mach_port_t ++#if KERNEL_SERVER ++ intran: task_t convert_port_to_task(mach_port_t) ++ outtran: mach_port_t convert_task_to_port(task_t) ++ destructor: task_deallocate(task_t) ++#endif /* KERNEL_SERVER */ ++ ; ++ ++#ifdef MIGRATING_THREADS ++#if KERNEL ++/* What the conventional external Mach interfaces see as a thread_t ++ is really an act_t within the kernel. */ ++#define thread_t act_t ++#define convert_port_to_thread convert_port_to_act ++#define convert_thread_to_port convert_act_to_port ++#define thread_deallocate act_deallocate ++#endif /* KERNEL */ ++#endif /* MIGRATING_THREADS */ ++ ++type thread_t = mach_port_t ++ ctype: mach_port_t ++#if KERNEL_SERVER ++ intran: thread_t convert_port_to_thread(mach_port_t) ++ outtran: mach_port_t convert_thread_to_port(thread_t) ++ destructor: thread_deallocate(thread_t) ++#endif /* KERNEL_SERVER */ ++ ; ++ ++type thread_state_t = array[*:1024] of natural_t; ++ ++type task_array_t = ^array[] of task_t; ++type thread_array_t = ^array[] of thread_t; ++ ++type vm_task_t = mach_port_t ++ ctype: mach_port_t ++#if KERNEL_SERVER ++ intran: vm_map_t convert_port_to_map(mach_port_t) ++ destructor: vm_map_deallocate(vm_map_t) ++#endif /* KERNEL_SERVER */ ++ ; ++ ++type ipc_space_t = mach_port_t ++ ctype: mach_port_t ++#if KERNEL_SERVER ++ intran: ipc_space_t convert_port_to_space(mach_port_t) ++ destructor: space_deallocate(ipc_space_t) ++#endif /* KERNEL_SERVER */ ++ ; ++ ++type vm_address_t = natural_t; ++type vm_offset_t = natural_t; ++type vm_size_t = natural_t; ++type vm_prot_t = int; ++type vm_inherit_t = int; ++type vm_statistics_data_t = struct[13] of integer_t; ++type vm_machine_attribute_t = int; ++type vm_machine_attribute_val_t = int; ++ ++type thread_info_t = array[*:1024] of integer_t; ++type thread_basic_info_data_t = struct[11] of integer_t; ++type thread_sched_info_data_t = struct[7] of integer_t; ++ ++type task_info_t = array[*:1024] of integer_t; ++type task_basic_info_data_t = struct[8] of integer_t; ++type task_events_info = struct[7] of natural_t; ++type task_thread_times_info_data_t = struct[4] of integer_t; ++ ++ ++type memory_object_t = mach_port_t ++ ctype: mach_port_t ++#if KERNEL_SERVER ++ intran: ipc_port_t null_conversion(mach_port_t) ++#else /* KERNEL_SERVER */ ++#ifdef MEMORY_OBJECT_INTRAN ++ intran: MEMORY_OBJECT_INTRAN ++#endif ++#ifdef MEMORY_OBJECT_INTRAN_PAYLOAD ++ intranpayload: MEMORY_OBJECT_INTRAN_PAYLOAD ++#endif ++#ifdef MEMORY_OBJECT_OUTTRAN ++ outtran: MEMORY_OBJECT_OUTTRAN ++#endif ++#ifdef MEMORY_OBJECT_DESTRUCTOR ++ destructor: MEMORY_OBJECT_DESTRUCTOR ++#endif ++#endif /* KERNEL_SERVER */ ++ ; ++ ++type memory_object_control_t = mach_port_t ++ ctype: mach_port_t ++#if KERNEL_SERVER ++ intran: vm_object_t vm_object_lookup(mach_port_t) ++#endif /* KERNEL_SERVER */ ++ ; ++ ++type memory_object_name_t = mach_port_t ++ ctype: mach_port_t ++#if KERNEL_SERVER ++ intran: vm_object_t vm_object_lookup_name(mach_port_t) ++ destructor: vm_object_deallocate(vm_object_t) ++#endif /* KERNEL_SERVER */ ++ ; ++ ++type memory_object_copy_strategy_t = int; ++type memory_object_return_t = int; ++ ++type machine_info_data_t = struct[5] of integer_t; ++type machine_slot_data_t = struct[8] of integer_t; ++ ++type host_t = mach_port_t ++ ctype: mach_port_t ++#if KERNEL_SERVER ++ intran: host_t convert_port_to_host(mach_port_t) ++ outtran: mach_port_t convert_host_to_port(host_t) ++#endif /* KERNEL_SERVER */ ++ ; ++ ++type host_priv_t = mach_port_t ++ ctype: mach_port_t ++#if KERNEL_SERVER ++ intran: host_t convert_port_to_host_priv(mach_port_t) ++#endif /* KERNEL_SERVER */ ++ ; ++ ++type host_info_t = array[*:1024] of integer_t; ++type host_basic_info_data_t = struct[5] of integer_t; ++type host_sched_info_data_t = struct[2] of integer_t; ++type host_load_info_data_t = struct[6] of integer_t; ++ ++ ++type processor_t = mach_port_t ++ ctype: mach_port_t ++#if KERNEL_SERVER ++ intran: processor_t convert_port_to_processor(mach_port_t) ++ outtran: mach_port_t convert_processor_to_port(processor_t) ++#endif /* KERNEL_SERVER */ ++ ; ++ ++type processor_array_t = ^array[] of processor_t; ++type processor_info_t = array[*:1024] of integer_t; ++type processor_basic_info_data_t = struct[5] of integer_t; ++ ++ ++type processor_set_t = mach_port_t ++ ctype: mach_port_t ++#if KERNEL_SERVER ++ intran: processor_set_t convert_port_to_pset(mach_port_t) ++ outtran: mach_port_t convert_pset_to_port(processor_set_t) ++ destructor: pset_deallocate(processor_set_t) ++#endif /* KERNEL_SERVER */ ++ ; ++ ++type processor_set_array_t = ^array[] of processor_set_t; ++ ++type processor_set_name_t = mach_port_t ++ ctype: mach_port_t ++#if KERNEL_SERVER ++ intran: processor_set_t convert_port_to_pset_name(mach_port_t) ++ outtran: mach_port_t convert_pset_name_to_port(processor_set_t) ++ destructor: pset_deallocate(processor_set_t) ++#endif /* KERNEL_SERVER */ ++ ; ++ ++type processor_set_name_array_t = ^array[] of processor_set_name_t; ++ ++type processor_set_info_t = array[*:1024] of integer_t; ++type processor_set_basic_info_data_t = struct[5] of integer_t; ++type processor_set_sched_info_data_t = struct[2] of integer_t; ++ ++ ++type kernel_version_t = (MACH_MSG_TYPE_STRING, 512*8); ++ ++type kernel_boot_info_t = (MACH_MSG_TYPE_STRING, 4096*8); ++ ++type time_value_t = struct[2] of integer_t; ++ ++type emulation_vector_t = ^array[] of vm_offset_t; ++ ++type rpc_signature_info_t = array[*:1024] of int; ++ ++#if KERNEL_SERVER ++simport <kern/ipc_kobject.h>; /* for null conversion */ ++simport <kern/ipc_tt.h>; /* for task/thread conversion */ ++simport <kern/ipc_host.h>; /* for host/processor/pset conversions */ ++simport <kern/task.h>; /* for task_t */ ++simport <kern/thread.h>; /* for thread_t */ ++simport <kern/host.h>; /* for host_t */ ++simport <kern/processor.h>; /* for processor_t, processor_set_t */ ++simport <vm/vm_object.h>; /* for vm_object_t */ ++simport <vm/vm_map.h>; /* for vm_map_t */ ++simport <ipc/ipc_space.h>; /* for ipc_space_t */ ++#endif /* KERNEL_SERVER */ ++ ++import <mach/mach_types.h>; ++ ++#endif /* _MACH_MACH_TYPES_DEFS_ */ +diff --git a/mach-defpager/mach_port.defs b/mach-defpager/mach_port.defs +new file mode 100644 +index 0000000..c7e8526 +--- /dev/null ++++ b/mach-defpager/mach_port.defs +@@ -0,0 +1,369 @@ ++/* ++ * Mach Operating System ++ * Copyright (c) 1991,1990,1989 Carnegie Mellon University. ++ * Copyright (c) 1993,1994 The University of Utah and ++ * the Computer Systems Laboratory (CSL). ++ * All rights reserved. ++ * ++ * Permission to use, copy, modify and distribute this software and its ++ * documentation is hereby granted, provided that both the copyright ++ * notice and this permission notice appear in all copies of the ++ * software, derivative works or modified versions, and any portions ++ * thereof, and that both notices appear in supporting documentation. ++ * ++ * CARNEGIE MELLON, THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF ++ * THIS SOFTWARE IN ITS "AS IS" CONDITION, AND DISCLAIM ANY LIABILITY ++ * OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF ++ * THIS SOFTWARE. ++ * ++ * Carnegie Mellon requests users of this software to return to ++ * ++ * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU ++ * School of Computer Science ++ * Carnegie Mellon University ++ * Pittsburgh PA 15213-3890 ++ * ++ * any improvements or extensions that they make and grant Carnegie Mellon ++ * the rights to redistribute these changes. ++ */ ++/* ++ * File: mach/mach_port.defs ++ * Author: Rich Draves ++ * ++ * Copyright (c) 1989 Richard P. Draves, Jr. ++ * ++ * Exported kernel calls. ++ */ ++ ++subsystem ++#if KERNEL_SERVER ++ KernelServer ++#endif ++ mach_port 3200; ++ ++#include <mach/std_types.defs> ++#include <mach/mach_types.defs> ++ ++/* ++ * Returns the set of port and port set names ++ * to which the target task has access, along with ++ * the type (set or port) for each name. ++ */ ++ ++routine mach_port_names( ++ task : ipc_space_t; ++ out names : mach_port_name_array_t = ++ ^array[] of mach_port_name_t ++ ctype: mach_port_array_t; ++ out types : mach_port_type_array_t = ++ ^array[] of mach_port_type_t); ++ ++/* ++ * Returns the type (set or port) for the port name ++ * within the target task. Also indicates whether ++ * there is a dead-name request for the name. ++ */ ++ ++routine mach_port_type( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ out ptype : mach_port_type_t); ++ ++/* ++ * Changes the name by which a port (or port set) is known to ++ * the target task. The new name can't be in use. The ++ * old name becomes available for recycling. ++ */ ++ ++routine mach_port_rename( ++ task : ipc_space_t; ++ old_name : mach_port_name_t; ++ new_name : mach_port_name_t); ++ ++/* ++ * Allocates the specified kind of object, with the given name. ++ * The right must be one of ++ * MACH_PORT_RIGHT_RECEIVE ++ * MACH_PORT_RIGHT_PORT_SET ++ * MACH_PORT_RIGHT_DEAD_NAME ++ * New port sets are empty. New ports don't have any ++ * send/send-once rights or queued messages. The make-send ++ * count is zero and their queue limit is MACH_PORT_QLIMIT_DEFAULT. ++ * New sets, ports, and dead names have one user reference. ++ */ ++ ++routine mach_port_allocate_name( ++ task : ipc_space_t; ++ right : mach_port_right_t; ++ name : mach_port_name_t); ++ ++/* ++ * Allocates the specified kind of object. ++ * The right must be one of ++ * MACH_PORT_RIGHT_RECEIVE ++ * MACH_PORT_RIGHT_PORT_SET ++ * MACH_PORT_RIGHT_DEAD_NAME ++ * Like port_allocate_name, but the kernel picks a name. ++ * It can use any name not associated with a right. ++ */ ++ ++routine mach_port_allocate( ++ task : ipc_space_t; ++ right : mach_port_right_t; ++ out name : mach_port_name_t); ++ ++/* ++ * Destroys all rights associated with the name and makes it ++ * available for recycling immediately. The name can be a ++ * port (possibly with multiple user refs), a port set, or ++ * a dead name (again, with multiple user refs). ++ */ ++ ++routine mach_port_destroy( ++ task : ipc_space_t; ++ name : mach_port_name_t); ++ ++/* ++ * Releases one send/send-once/dead-name user ref. ++ * Just like mach_port_mod_refs -1, but deduces the ++ * correct type of right. This allows a user task ++ * to release a ref for a port without worrying ++ * about whether the port has died or not. ++ */ ++ ++routine mach_port_deallocate( ++ task : ipc_space_t; ++ name : mach_port_name_t); ++ ++/* ++ * A port set always has one user ref. ++ * A send-once right always has one user ref. ++ * A dead name always has one or more user refs. ++ * A send right always has one or more user refs. ++ * A receive right always has one user ref. ++ * The right must be one of ++ * MACH_PORT_RIGHT_RECEIVE ++ * MACH_PORT_RIGHT_PORT_SET ++ * MACH_PORT_RIGHT_DEAD_NAME ++ * MACH_PORT_RIGHT_SEND ++ * MACH_PORT_RIGHT_SEND_ONCE ++ */ ++ ++routine mach_port_get_refs( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ right : mach_port_right_t; ++ out refs : mach_port_urefs_t); ++ ++/* ++ * The delta is a signed change to the task's ++ * user ref count for the right. Only dead names ++ * and send rights can have a positive delta. ++ * The resulting user ref count can't be negative. ++ * If it is zero, the right is deallocated. ++ * If the name isn't a composite right, it becomes ++ * available for recycling. The right must be one of ++ * MACH_PORT_RIGHT_RECEIVE ++ * MACH_PORT_RIGHT_PORT_SET ++ * MACH_PORT_RIGHT_DEAD_NAME ++ * MACH_PORT_RIGHT_SEND ++ * MACH_PORT_RIGHT_SEND_ONCE ++ */ ++ ++routine mach_port_mod_refs( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ right : mach_port_right_t; ++ delta : mach_port_delta_t); ++ ++/* ++ * Temporary compatibility call. ++ */ ++ ++routine old_mach_port_get_receive_status( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ out status : old_mach_port_status_t); ++ ++/* ++ * Only valid for receive rights. ++ * Sets the queue-limit for the port. ++ * The limit must be ++ * 1 <= qlimit <= MACH_PORT_QLIMIT_MAX ++ */ ++ ++routine mach_port_set_qlimit( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ qlimit : mach_port_msgcount_t); ++ ++/* ++ * Only valid for receive rights. ++ * Sets the make-send count for the port. ++ */ ++ ++routine mach_port_set_mscount( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ mscount : mach_port_mscount_t); ++ ++/* ++ * Only valid for port sets. Returns a list of ++ * the members. ++ */ ++ ++routine mach_port_get_set_status( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ out members : mach_port_name_array_t = ++ ^array[] of mach_port_name_t ++ ctype: mach_port_array_t); ++ ++/* ++ * Puts the member port (the task must have receive rights) ++ * into the after port set. (Or removes it from any port set ++ * if after is MACH_PORT_NULL.) If the port is already in ++ * a set, does an atomic move. ++ */ ++ ++routine mach_port_move_member( ++ task : ipc_space_t; ++ member : mach_port_name_t; ++ after : mach_port_name_t); ++ ++/* ++ * Requests a notification from the kernel. The request ++ * must supply the send-once right which is used for ++ * the notification. If a send-once right was previously ++ * registered, it is returned. The msg_id must be one of ++ * MACH_NOTIFY_PORT_DESTROYED (receive rights) ++ * MACH_NOTIFY_DEAD_NAME (send/receive/send-once rights) ++ * MACH_NOTIFY_NO_SENDERS (receive rights) ++ * ++ * The sync value specifies whether a notification should ++ * get sent immediately, if appropriate. The exact meaning ++ * depends on the notification: ++ * MACH_NOTIFY_PORT_DESTROYED: must be zero. ++ * MACH_NOTIFY_DEAD_NAME: if non-zero, then name can be dead, ++ * and the notification gets sent immediately. ++ * If zero, then name can't be dead. ++ * MACH_NOTIFY_NO_SENDERS: the notification gets sent ++ * immediately if the current mscount is greater ++ * than or equal to the sync value and there are no ++ * extant send rights. ++ */ ++ ++routine mach_port_request_notification( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ id : mach_msg_id_t; ++ sync : mach_port_mscount_t; ++ notify : mach_port_send_once_t; ++ out previous : mach_port_send_once_t); ++ ++/* ++ * Inserts the specified rights into the target task, ++ * using the specified name. If inserting send/receive ++ * rights and the task already has send/receive rights ++ * for the port, then the names must agree. In any case, ++ * the task gains a user ref for the port. ++ */ ++ ++routine mach_port_insert_right( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ poly : mach_port_poly_t); ++ ++/* ++ * Returns the specified right for the named port ++ * in the target task, extracting that right from ++ * the target task. The target task loses a user ++ * ref and the name may be available for recycling. ++ * msgt_name must be one of ++ * MACH_MSG_TYPE_MOVE_RECEIVE ++ * MACH_MSG_TYPE_COPY_SEND ++ * MACH_MSG_TYPE_MAKE_SEND ++ * MACH_MSG_TYPE_MOVE_SEND ++ * MACH_MSG_TYPE_MAKE_SEND_ONCE ++ * MACH_MSG_TYPE_MOVE_SEND_ONCE ++ */ ++ ++routine mach_port_extract_right( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ msgt_name : mach_msg_type_name_t; ++ out poly : mach_port_poly_t); ++ ++/* ++ * The task must have receive rights for the named port. ++ * Returns a status structure (see mach/port.h). ++ */ ++ ++routine mach_port_get_receive_status( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ out status : mach_port_status_t); ++ ++/* ++ * Only valid for receive rights. ++ * Sets the sequence number for the port. ++ */ ++ ++routine mach_port_set_seqno( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ seqno : mach_port_seqno_t); ++ ++#ifdef MIGRATING_THREADS ++/* ++ * Only valid for receive rights. ++ * Set the user-mode entry info for RPCs coming through this port. ++ * Do this BEFORE attaching an ActPool to this port, ++ * unless you can be sure no RPCs will be coming through it yet. ++ */ ++ ++routine mach_port_set_rpcinfo( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ rpc_info : thread_info_t); /* XXX */ ++ ++/* ++ * Only valid for receive rights. ++ * Create a new activation for migrating RPC, and attach it to the port's ActPool. ++ * Create an ActPool for the port if it doesn't already have one. ++ * Supply a stack and receive memory buffer. ++ */ ++ ++routine mach_port_create_act( ++ task : task_t; ++ name : mach_port_name_t; ++ user_stack : vm_offset_t; ++ user_rbuf : vm_offset_t; ++ user_rbuf_size : vm_size_t; ++ out new_act : thread_t); ++ ++#else /* MIGRATING_THREADS */ ++ ++skip; /* mach_port_set_rpcinfo */ ++skip; /* mach_port_create_act */ ++ ++#endif /* MIGRATING_THREADS */ ++ ++/* ++ * Only valid for receive rights. ++ * Set the protected payload for this right to the given value. ++ */ ++ ++routine mach_port_set_protected_payload( ++ task : ipc_space_t; ++ name : mach_port_name_t; ++ payload : natural_t); ++ ++/* ++ * Only valid for receive rights. ++ * Clear the protected payload for this right. ++ */ ++ ++routine mach_port_clear_protected_payload( ++ task : ipc_space_t; ++ name : mach_port_name_t); +diff --git a/mach-defpager/mig-decls.h b/mach-defpager/mig-decls.h +index 8118d61..3357aa2 100644 +--- a/mach-defpager/mig-decls.h ++++ b/mach-defpager/mig-decls.h +@@ -31,4 +31,10 @@ begin_using_default_pager (mach_port_t port) + (hurd_ihash_key_t) port); + } + ++static inline struct dstruct * __attribute__ ((unused)) ++begin_using_default_pager_payload (unsigned long payload) ++{ ++ return (default_pager_t) payload; ++} ++ + #endif /* __MACH_DEFPAGER_MIG_DECLS_H__ */ +diff --git a/mach-defpager/mig-mutate.h b/mach-defpager/mig-mutate.h +index 54aeeba..31acaa6 100644 +--- a/mach-defpager/mig-mutate.h ++++ b/mach-defpager/mig-mutate.h +@@ -18,5 +18,8 @@ + along with the GNU Hurd. If not, see <http://www.gnu.org/licenses/>. */ + + #define MEMORY_OBJECT_INTRAN default_pager_t begin_using_default_pager (mach_port_t) ++#define MEMORY_OBJECT_INTRAN_PAYLOAD \ ++ default_pager_t begin_using_default_pager_payload ++ + #define MEMORY_OBJECT_IMPORTS import "mig-decls.h"; + #define DEFAULT_PAGER_IMPORTS import "mig-decls.h"; diff --git a/debian/patches/series b/debian/patches/series index b15cf450..5c93ec43 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -46,3 +46,4 @@ xkb-compat.patch xxx-fix-build.patch fix-receiver-lookups.patch +mach-defpager-protected-payload.patch |