minix/lib/libsys/sys_privctl.c

#include "syslib.h"

int sys_privctl(endpoint_t proc_ep, int request, void *p)
{
  message m;

  m.CTL_ENDPT = proc_ep;
  m.CTL_REQUEST = request;
  m.CTL_ARG_PTR = p;

  return _kernel_call(SYS_PRIVCTL, &m);
}

int sys_privquery_mem(endpoint_t proc_ep, phys_bytes start, phys_bytes len)
{
  message m;

  m.CTL_ENDPT = proc_ep;
  m.CTL_REQUEST = SYS_PRIV_QUERY_MEM;
  m.CTL_PHYSSTART = start;
  m.CTL_PHYSLEN = len;

  return _kernel_call(SYS_PRIVCTL, &m);
}
Added sys_privctl.c. 2006-01-27 13:54:47 +01:00			`#include "syslib.h"`

Fixed compilation errors in ps.c and rs/manager.c. The former was fixed by disabling code using no-longer-existant flags and the latter by removing the spurious parameter i from sys_privctl 2009-09-23 10:46:17 +02:00			`int sys_privctl(endpoint_t proc_ep, int request, void *p)`
Added sys_privctl.c. 2006-01-27 13:54:47 +01:00			`{`
			`message m;`

endpoint_t in syslib - headers use the endpoint_t in syslib.h and the implmentation was using int instead. Both uses endpoint_t now - every variable named like proc, proc_nr or proc_nr_e of type endpoint_t has name proc_ep now - endpoint_t defined as u32_t not int 2009-09-22 23:42:02 +02:00			`m.CTL_ENDPT = proc_ep;`
Added sys_privctl.c. 2006-01-27 13:54:47 +01:00			`m.CTL_REQUEST = request;`
Make sys_privctl make the prototype. 2006-01-27 15:14:13 +01:00			`m.CTL_ARG_PTR = p;`
Added sys_privctl.c. 2006-01-27 13:54:47 +01:00
Removal of the system task * Userspace change to use the new kernel calls - _taskcall(SYSTASK...) changed to _kernel_call(...) - int 32 reused for the kernel calls - _do_kernel_call() to make the trap to kernel - kernel_call() to make the actuall kernel call from C using _do_kernel_call() - unlike ipc call the kernel call always succeeds as kernel is always available, however, kernel may return an error * Kernel side implementation of kernel calls - the SYSTEm task does not run, only the proc table entry is preserved - every data_copy(SYSTEM is no data_copy(KERNEL - "locking" is an empty operation now as everything runs in kernel - sys_task() is replaced by kernel_call() which copies the message into kernel, dispatches the call to its handler and finishes by either copying the results back to userspace (if need be) or by suspending the process because of VM - suspended processes are later made runnable once the memory issue is resolved, picked up by the scheduler and only at this time the call is resumed (in fact restarted) which does not need to copy the message from userspace as the message is already saved in the process structure. - no ned for the vmrestart queue, the scheduler will restart the system calls - no special case in do_vmctl(), all requests remove the RTS_VMREQUEST flag 2010-02-09 16:20:09 +01:00			`return _kernel_call(SYS_PRIVCTL, &m);`
Added sys_privctl.c. 2006-01-27 13:54:47 +01:00			`}`
- enable remembering of device memory ranges set by PCI and told to kernel - makes VM ask the kernel if a certain process is allowed to map in a range of physical memory (VM rounds it to page boundaries afterwards - but it's impossible to map anything smaller otherwise so I assume this is safe, i.e. there won't be anything else in that page; certainly no regular memory) - VM permission check cleanup (no more hardcoded calls, less hardcoded logic, more readable main loop), a loose end left by GQ - remove do_copy warning, as the ipc server triggers this but it's no more harmful than the special cases already excluded explicitly (VFS, PM, etc). 2009-11-03 12:12:23 +01:00
			`int sys_privquery_mem(endpoint_t proc_ep, phys_bytes start, phys_bytes len)`
			`{`
			`message m;`

			`m.CTL_ENDPT = proc_ep;`
			`m.CTL_REQUEST = SYS_PRIV_QUERY_MEM;`
			`m.CTL_PHYSSTART = start;`
			`m.CTL_PHYSLEN = len;`

Removal of the system task * Userspace change to use the new kernel calls - _taskcall(SYSTASK...) changed to _kernel_call(...) - int 32 reused for the kernel calls - _do_kernel_call() to make the trap to kernel - kernel_call() to make the actuall kernel call from C using _do_kernel_call() - unlike ipc call the kernel call always succeeds as kernel is always available, however, kernel may return an error * Kernel side implementation of kernel calls - the SYSTEm task does not run, only the proc table entry is preserved - every data_copy(SYSTEM is no data_copy(KERNEL - "locking" is an empty operation now as everything runs in kernel - sys_task() is replaced by kernel_call() which copies the message into kernel, dispatches the call to its handler and finishes by either copying the results back to userspace (if need be) or by suspending the process because of VM - suspended processes are later made runnable once the memory issue is resolved, picked up by the scheduler and only at this time the call is resumed (in fact restarted) which does not need to copy the message from userspace as the message is already saved in the process structure. - no ned for the vmrestart queue, the scheduler will restart the system calls - no special case in do_vmctl(), all requests remove the RTS_VMREQUEST flag 2010-02-09 16:20:09 +01:00			`return _kernel_call(SYS_PRIVCTL, &m);`
- enable remembering of device memory ranges set by PCI and told to kernel - makes VM ask the kernel if a certain process is allowed to map in a range of physical memory (VM rounds it to page boundaries afterwards - but it's impossible to map anything smaller otherwise so I assume this is safe, i.e. there won't be anything else in that page; certainly no regular memory) - VM permission check cleanup (no more hardcoded calls, less hardcoded logic, more readable main loop), a loose end left by GQ - remove do_copy warning, as the ipc server triggers this but it's no more harmful than the special cases already excluded explicitly (VFS, PM, etc). 2009-11-03 12:12:23 +01:00			`}`