Included here in plain text format for reference and review. <Will eventually send the man pages in groff format separately to the man-pages repository.> The formatting for the man pages still needs a little bit of work. Signed-off-by: Sohil Mehta <sohil.mehta@xxxxxxxxx> --- tools/uintr/manpages/0_overview.txt | 265 ++++++++++++++++++ tools/uintr/manpages/1_register_receiver.txt | 122 ++++++++ .../uintr/manpages/2_unregister_receiver.txt | 62 ++++ tools/uintr/manpages/3_create_fd.txt | 104 +++++++ tools/uintr/manpages/4_register_sender.txt | 121 ++++++++ tools/uintr/manpages/5_unregister_sender.txt | 79 ++++++ tools/uintr/manpages/6_wait.txt | 59 ++++ 7 files changed, 812 insertions(+) create mode 100644 tools/uintr/manpages/0_overview.txt create mode 100644 tools/uintr/manpages/1_register_receiver.txt create mode 100644 tools/uintr/manpages/2_unregister_receiver.txt create mode 100644 tools/uintr/manpages/3_create_fd.txt create mode 100644 tools/uintr/manpages/4_register_sender.txt create mode 100644 tools/uintr/manpages/5_unregister_sender.txt create mode 100644 tools/uintr/manpages/6_wait.txt diff --git a/tools/uintr/manpages/0_overview.txt b/tools/uintr/manpages/0_overview.txt new file mode 100644 index 000000000000..349538effb15 --- /dev/null +++ b/tools/uintr/manpages/0_overview.txt @@ -0,0 +1,265 @@ +UINTR(7) Miscellaneous Information Manual UINTR(7) + + + +NAME + Uintr - overview of User Interrupts + +DESCRIPTION + User Interrupts (Uintr) provides a low latency event delivery and inter + process communication mechanism. These events can be delivered directly + to userspace without a transition to the kernel. + + In the User Interrupts hardware architecture, a receiver is always + expected to be a user space task. However, a user interrupt can be sent + by another user space task, kernel or an external source (like a + device). The feature that allows another userspace task to send an + interrupt is referred to as User IPI. + + Uintr is a hardware dependent, opt-in feature. Application aren't + expected or able to send or receive interrupts unless they register + themselves with the kernel using the syscall interface described below. + It is recommended that applications wanting to use User Interrupts call + uintr_register_handler(2) and test whether the call succeeds. + + Hardware support for User interrupts may be detected using other + mechanisms but they could be misleading and are generally not needed: + - Using the cpuid instruction (Refer the Intel Software Developers + Manual). + - Checking for the "uintr" string in /proc/cpuinfo under the "flags" + field. + + + Applications wanting to use Uintr should also be able to function + without it as well. Uintr support might be unavailable because of any + one of the following reasons: + - the kernel code does not contain support + - the kernel support has been disabled + - the hardware does not support it + + + Uintr syscall interface + Applications can use and manage Uintr using the system calls described + here. The Uintr system calls are available only if the kernel is + configured with the CONFIG_X86_USER_INTERRUPTS option. + + 1) A user application registers an interrupt handler using + uintr_register_handler(2). The registered interrupt handler will be + invoked when a user interrupt is delivered to that thread. Only one + interrupt handler can be registered by a particular thread within a + process. + + 2) Each thread that registered a handler has its own unique vector + space of 64 vectors. The thread can then use uintr_create_fd(2) to + register a vector and create a user interrupt file descriptor - + uintr_fd. + + 3) The uintr_fd is only associated with only one Uintr vector. A new + uintr_fd must be created for each of the 64 vectors. uintr_fd is + automatically inherited by forked processes but the receiver can also + share the uintr_fd with potential senders using any of the existing FD + sharing mechanisms (like pidfd_getfd(2) or socket sendmsg(2)). Access + to uintr_fd allows a sender to generate an interrupt with the + associated vector. Upon interrupt delivery, the interrupt handler is + invoked with the vector number pushed onto the stack to identify the + source of the interrupt. + + 4) Each thread has a local flag called User Interrupt flag (UIF). The + thread can set or clear this flag to enable or disable interrupts. The + default value of UIF is always 0 (Interrupts disabled). A receiver must + execute the _stui() intrinsic instruction at some point (before or + anytime after registration) to start receiving user interrupts. To + disable interrupts during critical sections the thread can call the + _clui() instruction to clear UIF. + + 5a) For sending a user IPI, the sender task registers with the kernel + using uintr_register_sender(2). The kernel would setup the routing + tables to connect the sender and receiver. The syscall returns an index + that can be used with the 'SENDUIPI <index>' instruction to send a user + IPI. If the receiver is running, the interrupt is delivered directly + to the receiver without any kernel intervention. + + 5b) If the sender is the kernel or an external source, the uintr_fd can + be passed onto the related kernel entity to allow them to connect and + generate the user interrupt. <The exact details of this API are still + being worked upon.> + + 6) The receiver can block in the kernel while it is waiting for user + interrupts to get delivered using uintr_wait(2). If the receiver has + been context switched out due to other reasons the user interrupt will + be delivered when the receiver gets scheduled back in. + + <The behavior when the receiver has made some other blocking system + call like sleep(2) or read(2) is still to be decided. We are evaluating + if a thread made another blocking syscall should be interrupted and + woken up when a user interrupt arrives for that thread. uintr_wait(2) + has been implemented as a placeholder in the meantime.> + + 7) The sender and receiver are expected to coordinate and then call the + teardown syscalls to terminate the connection: + a. A sender unregisters with uintr_unregister_sender(2) + b. A vector is unregistered using close(uintr_fd) + c. A receiver unregisters with uintr_unregister_handler(2) + + If the sender and receiver aren't able to coordinate, some shared + kernel resources between them would get freed later when the file + descriptors get released automatically on process exit. + + + Multi-threaded applications need to be careful when using Uintr since + it is a thread specific feature. Actions by one thread don't reflect on + other threads of the same application. + + + Toolchain support + Support has added to GCC(11.1) and Binutils(2.36.1) to enable user + interrupt intrinsic instructions and compiler flag (-muintr). + + The "(interrupt)" attribute can be used to compile a function as a user + interrupt handler. In conjunction with the 'muintr' flag, the compiler + would: + - Generate the entry and exit sequences for the User interrupt + handler + - Handle the saving and restoring of registers + - Call uiret to return from a user interrupt handler + + User Interrupts related compiler intrinsic instructions - + <x86gprintrin.h>: + + _clui() - Disable user interrupts - clear UIF (User Interrupt Flag). + + _stui() - enable user interrupts - set UIF. + + _testui() - test current value of UIF. + + _uiret() - return from a user interrupt handler. + + _senduipi <uipi_index> - send a user IPI to a target task. The + uipi_index is obtained using uintr_register_sender(2). + + + Interrupt handler restrictions + There are restrictions on what can be done in a user interrupt handler. + + For example, the handler and the functions called from the handler + should only use general purpose registers. + + For details refer the Uintr compiler programming guide. + https://github.com/intel/uintr-compiler-guide/blob/uintr- + gcc-11.1/UINTR-compiler-guide.pdf + + +CONFORMING TO + Uintr related system calls are Linux specific. + +EXAMPLES + Build + To compile this sample an updated toolchain is needed. + - Use GCC release 11 or higher & + - Use Binutils release 2.36 or higher + + gcc -muintr -mgeneral-regs-only -minline-all-stringops uipi_sample.c -lpthread -o uipi_sample + + + Run + $./uipi_sample + Receiver enabled interrupts + Sending IPI from sender thread + -- User Interrupt handler -- + Success + + + Program source + #define _GNU_SOURCE + #include <pthread.h> + #include <stdio.h> + #include <stdlib.h> + #include <syscall.h> + #include <unistd.h> + #include <x86gprintrin.h> + + #define __NR_uintr_register_handler 449 + #define __NR_uintr_unregister_handler 450 + #define __NR_uintr_create_fd 451 + #define __NR_uintr_register_sender 452 + #define __NR_uintr_unregister_sender 453 + + #define uintr_register_handler(handler, flags) syscall(__NR_uintr_register_handler, handler, flags) + #define uintr_unregister_handler(flags) syscall(__NR_uintr_unregister_handler, flags) + #define uintr_create_fd(vector, flags) syscall(__NR_uintr_create_fd, vector, flags) + #define uintr_register_sender(fd, flags) syscall(__NR_uintr_register_sender, fd, flags) + #define uintr_unregister_sender(fd, flags) syscall(__NR_uintr_unregister_sender, fd, flags) + + unsigned int uintr_received; + unsigned int uintr_fd; + + void __attribute__ ((interrupt)) uintr_handler(struct __uintr_frame *ui_frame, + unsigned long long vector) + { + static const char print[] = "\t-- User Interrupt handler --\n"; + + write(STDOUT_FILENO, print, sizeof(print) - 1); + uintr_received = 1; + } + + void *sender_thread(void *arg) + { + int uipi_index; + + uipi_index = uintr_register_sender(uintr_fd, 0); + if (uipi_index < 0) { + printf("Sender register error\n"); + exit(EXIT_FAILURE); + } + + printf("Sending IPI from sender thread\n"); + _senduipi(uipi_index); + + uintr_unregister_sender(uintr_fd, 0); + + return NULL; + } + + int main(int argc, char *argv[]) + { + pthread_t pt; + + if (uintr_register_handler(uintr_handler, 0)) { + printf("Interrupt handler register error\n"); + exit(EXIT_FAILURE); + } + + uintr_fd = uintr_create_fd(0, 0); + if (uintr_fd < 0) { + printf("Interrupt vector registration error\n"); + exit(EXIT_FAILURE); + } + + _stui(); + printf("Receiver enabled interrupts\n"); + + if (pthread_create(&pt, NULL, &sender_thread, NULL)) { + printf("Error creating sender thread\n"); + exit(EXIT_FAILURE); + } + + /* Do some other work */ + while (!uintr_received) + usleep(1); + + pthread_join(pt, NULL); + close(uintr_fd); + uintr_unregister_handler(0); + + printf("Success\n"); + exit(EXIT_SUCCESS); + } + + +NOTES + Currently, there is no glibc wrapper for the Uintr related system call; + call the system calls using syscall(2). + + + + UINTR(7) diff --git a/tools/uintr/manpages/1_register_receiver.txt b/tools/uintr/manpages/1_register_receiver.txt new file mode 100644 index 000000000000..4b6652c94faa --- /dev/null +++ b/tools/uintr/manpages/1_register_receiver.txt @@ -0,0 +1,122 @@ +uintr_register_handler(2) System Calls Manual uintr_register_handler(2) + + + +NAME + uintr_register_handler - register a user interrupt handler + + +SYNOPSIS + int uintr_register_handler(u64 handler_address, unsigned int flags); + + +DESCRIPTION + uintr_register_handler() registers a user interrupt handler for the + calling process. In case of multi-threaded processes the user interrupt + handler is only registered for the thread that makes this system call. + + The handler_address is the function that would be invoked when the + process receives a user interrupt. The function should be defined as + below: + + void __attribute__ ((interrupt)) ui_handler(struct __uintr_frame *frame, + unsigned long long vector) + + For more details and an example for the handler definition refer + uintr(7). + + Providing an invalid handler_address could lead to undefined behavior + for the process. + + The flags argument is reserved for future use. Currently, it must be + specified as 0. + + Each user thread can register only one interrupt handler. Each thread + that would like to be a receiver must register once. The registration + is not inherited across forks(2) or when additional threads are created + within the same process. + + Each thread within a process gets its own interrupt vector space for 64 + vectors. The vector number is pushed onto the stack when a user + interrupt is delivered. Since the vector space is per-thread, each + receiver can receive up to 64 unique interrupt events. + + For information on creating uintr_fd to register and manage interrupt + vectors, refer uintr_create_fd(2) system call. + + Once an interrupt handler is registered it cannot be changed before the + handler is unregistered via uintr_unregister_handler(2). Calling + uintr_unregister_handler(2) would however invalidate the current + interrupt resources registered with the kernel. + + The interrupt handler gets invoked only while the process is running. + If the process is scheduled out or blocked in the kernel, interrupts + will be delivered when the process is scheduled again. <A mechanism to + unblock a process as soon as a user interrupt is posted is being worked + upon.> + + + Interrupt handler restrictions + There are restrictions on what can be done in a user interrupt handler. + + For example, the handler and the functions called from the handler + should only use general purpose registers. + + For details refer the Uintr compiler programming guide. + https://github.com/intel/uintr-compiler-guide/blob/uintr- + gcc-11.1/UINTR-compiler-guide.pdf + + + Security implications + A lot of security issues that are applicable to signal handlers, also + apply to user interrupt handlers. + + The user interrupt handler by-itself need not be re-entrant since + interrupts are automatically disabled when the handler is invoked. But + this isn't valid if the handler is shared between multiple threads or + nested interrupts have been enabled. + + Similar to signal handlers, the functions that are called from a user + interrupt should be async-signal-safe. Refer signal-safety(7) for a + discussion of async-signal-safe functions. + + It is recommended to disable interrupts using _clui() instruction + before executing any privileged code. Doing so would prevent a user + interrupt handler from running at a higher privilege level. + + +RETURN VALUE + On success, uintr_register_handler() returns 0. On error, -1 is + returned and errno is set to indicate the cause of the error. + + +ERRORS + EOPNOTSUPP Underlying hardware doesn't have support for Uintr. + + EINVAL flags is not 0. + + EFAULT handler address is not valid. + + ENOMEM The system is out of available memory. + + EBUSY An interrupt handler has already been registered. + + +VERSIONS + uintr_register_handler() first appeared in Linux <tbd>. + + +CONFORMING TO + uintr_register_handler() is Linux specific. + + +NOTES + Currently, there is no glibc wrapper for this system call; call it + using syscall(2). + + The user interrupt related system calls need hardware support to + generate and receive user interrupts. Refer uintr(7) for details. + + + + uintr_register_handler(2) diff --git a/tools/uintr/manpages/2_unregister_receiver.txt b/tools/uintr/manpages/2_unregister_receiver.txt new file mode 100644 index 000000000000..dd6981f33597 --- /dev/null +++ b/tools/uintr/manpages/2_unregister_receiver.txt @@ -0,0 +1,62 @@ +uintr_unregister_handler(2) System Calls Manual uintr_unregister_handler(2) + + + +NAME + uintr_unregister_handler - unregister a user interrupt handler + + +SYNOPSIS + int uintr_unregister_handler(unsigned int flags); + + +DESCRIPTION + uintr_unregister_handler() unregisters a previously registered user + interrupt handler. If no interrupt handler was registered by the + process uintr_unregister_handler() would return an error. + + Since interrupt handler is local to a thread, only the thread that has + registered via uintr_register_handler(2) can call + uintr_unregister_handler(). + + The interrupt resources such as interrupt vectors and uintr_fd, that + have been allocated for this thread, would be deactivated. Other + senders posting interrupts to this thread will not be delivered. + + The kernel does not automatically close the uintr_fds related to this + process/thread when uintr_unregister_handler() is called. The + application is expected to close the unused uintr_fds before or the + after the handler has been unregistered. + + +RETURN VALUE + On success, uintr_unregister_handler() returns 0. On error, -1 is + returned and errno is set to indicate the cause of the error. + + +ERRORS + EOPNOTSUPP Underlying hardware doesn't have support for Uintr. + + EINVAL flags is not 0. + + EINVAL No registered user interrupt handler. + + +VERSIONS + uintr_unregister_handler() first appeared in Linux <tbd>. + + +CONFORMING TO + uintr_unregister_handler() is Linux specific. + + +NOTES + Currently, there is no glibc wrapper for this system call; call it + using syscall(2). + + The user interrupt related system calls need hardware support to + generate and receive user interrupts. Refer uintr(7) for details. + + + + uintr_unregister_handler(2) diff --git a/tools/uintr/manpages/3_create_fd.txt b/tools/uintr/manpages/3_create_fd.txt new file mode 100644 index 000000000000..e90b0dce2703 --- /dev/null +++ b/tools/uintr/manpages/3_create_fd.txt @@ -0,0 +1,104 @@ +uintr_create_fd(2) System Calls Manual uintr_create_fd(2) + + + +NAME + uintr_create_fd - Create a user interrupt file descriptor - uintr_fd + + +SYNOPSIS + int uintr_create_fd(u64 vector, unsigned int flags); + + +DESCRIPTION + uintr_create_fd() allocates a new user interrupt file descriptor + (uintr_fd) based on the vector registered by the calling process. The + uintr_fd can be shared with other processes and the kernel to allow + them to generate interrupts with the associated vector. + + The caller must have registered a handler via uintr_register_handler(2) + before attempting to create uintr_fd. The interrupts generated based on + this uintr_fd will be delivered only to the thread that created this + file descriptor. A unique uintr_fd is generated for each vector + registered using uintr_create_fd(). + + Each thread has a private vector space of 64 vectors ranging from 0-63. + Vector number 63 has the highest priority while vector number 0 has the + lowest. If two or more interrupts are pending to be delivered then the + interrupt with the higher vector number will be delivered first + followed by the ones with lower vector numbers. Applications can choose + appropriate vector numbers to prioritize certain interrupts over + others. + + Upon interrupt delivery, the handler is invoked with the vector number + pushed onto the stack to help identify the source of the interrupt. + Since the vector space is per-thread, each receiver can receive up to + 64 unique interrupt events. + + A receiver can choose to share the same uintr_fd with multiple senders. + Since an interrupt with the same vector number would be delivered, the + receiver would need to use other mechanisms to identify the exact + source of the interrupt. + + The flags argument is reserved for future use. Currently, it must be + specified as 0. + + close(2) + When the file descriptor is no longer required it should be + closed. When all file descriptors associated with the same + uintr_fd object have been closed, the resources for object are + freed by the kernel. + + fork(2) + A copy of the file descriptor created by uintr_create_fd() is + inherited by the child produced by fork(2). The duplicate file + descriptor is associated with the same uintr_fd object. The + close-on-exec flag (FD_CLOEXEC; see fcntl(2)) is set on the + file descriptor returned by uintr_create_fd(). + + For information on how to generate interrupts with uintr_fd refer + uintr_register_sender(2). + + +RETURN VALUE + On success, uintr_create_fd() returns a new uintr_fd file descriptor. + On error, -1 is returned and errno is set to indicate the cause of the + error. + + +ERRORS + EOPNOTSUPP Underlying hardware doesn't have support for Uintr. + + EINVAL flags is not 0. + + EFAULT handler address is not valid. + + EMFILE The per-process limit on the number of open file + descriptors has been reached. + + ENFILE The system-wide limit on the total number of open files + has been reached. + + ENODEV Could not mount (internal) anonymous inode device. + + ENOMEM The system is out of available memory to allocate uintr_fd. + + +VERSIONS + uintr_create_fd() first appeared in Linux <tbd>. + + +CONFORMING TO + uintr_create_fd() is Linux specific. + + +NOTES + Currently, there is no glibc wrapper for this system call; call it + using syscall(2). + + The user interrupt related system calls need hardware support to + generate and receive user interrupts. Refer uintr(7) for details. + + + + uintr_create_fd(2) diff --git a/tools/uintr/manpages/4_register_sender.txt b/tools/uintr/manpages/4_register_sender.txt new file mode 100644 index 000000000000..1dc17f4c041f --- /dev/null +++ b/tools/uintr/manpages/4_register_sender.txt @@ -0,0 +1,121 @@ +uintr_register_sender(2) System Calls Manual uintr_register_sender(2) + + + +NAME + uintr_register_sender - Register a user inter-process interrupt sender + + +SYNOPSIS + int uintr_register_sender(int uintr_fd, unsigned int flags); + + +DESCRIPTION + uintr_register_sender() allows a sender process to connect with a Uintr + receiver based on the uintr_fd. It returns a user IPI index + (uipi_index) that the sender process can use in conjunction with the + SENDUIPI instruction to generate a user IPI. + + When a sender executes 'SENDUIPI <uipi_index>', a user IPI can be + delivered by the hardware to the receiver without any intervention from + the kernel. Upon IPI delivery, the handler is invoked with the vector + number, associated with uintr_fd, pushed onto the stack to help + identify the source of the interrupt. + + If the receiver for the thread is running the hardware would directly + deliver the user IPI to the receiver. If the receiver is not running or + has disabled receiving interrupts using the STUI instruction, the + interrupt will be stored in memory and delivered when the receiver is + able to receive it. + + If the sender tries to send multiple IPIs while the receiver is not + able to receive them then all the IPIs with the same vector would be + coalesced. Only a single IPI per vector would be delivered. + + uintr_register_sender() can be used to connect with multiple uintr_fds. + uintr_register_sender() would return a unique uipi_index for each + uintr_fd the sender connects with. + + In case of a multi-threaded process, the uipi_index is only valid for + the thread that registered itself. Other threads would need to register + themselves if they intend to be a user IPI sender. Executing SENDUIPI + on different threads can have varying results based on the connections + that have been setup. + + <We are also considering an alternate approach where the same + uipi_index would be valid for all threads that are part of the same + process. All threads would see consistent SENDUIPI behaviour in that + case.> + + If a process uses SENDUIPI without registering using + uintr_register_sender() it receives a SIGILL signal. If a process uses + an illegal uipi_index, it receives a SIGSEGV signal. See sigaction(2) + for details of the information available with that signal. + + The flags argument is reserved for future use. Currently, it must be + specified as 0. + + close(2) + When the file descriptor is no longer required it should be + closed. When all file descriptors associated with the same + uintr_fd object have been closed, the resources for object are + freed by the kernel. Freeing the uintr_fd object would also + result in the associated uipi_index to be freed. + + fork(2) + A copy of uintr_fd is inherited by the child produced by + fork(2). However the uipi_index would not get inherited by the + child. If the child wants to send a user IPI it would have to + explicitly register itself using the uintr_register_sender() + system call. + + For information on how to unregister a sender refer + uintr_unregister_sender(2). + + +RETURN VALUE + On success, uintr_register_sender() returns a new user IPI index - + uipi_index. On error, -1 is returned and errno is set to indicate the + cause of the error. + + +ERRORS + EOPNOTSUPP Underlying hardware doesn't have support for uintr(7). + + EOPNOTSUPP uintr_fd does not refer to a Uintr instance. + + EBADF The uintr_fd passed to the kernel is invalid. + + EINVAL flags is not 0. + + EISCONN A connection to this uintr_fd has already been established. + + ECONNRESET The user interrupt receiver has disabled the connection. + + ESHUTDOWN The user interrupt receiver has exited the connection. + + ENOSPC No uipi_index can be allocated. The system has run out of + the available user IPI indexes. + + ENOMEM The system is out of available memory to register a user + IPI sender. + + +VERSIONS + uintr_register_sender() first appeared in Linux <tbd>. + + +CONFORMING TO + uintr_register_sender() is Linux specific. + + +NOTES + Currently, there is no glibc wrapper for this system call; call it + using syscall(2). + + The user interrupt related system calls need hardware support to + generate and receive user interrupts. Refer uintr(7) for details. + + + + uintr_register_sender(2) diff --git a/tools/uintr/manpages/5_unregister_sender.txt b/tools/uintr/manpages/5_unregister_sender.txt new file mode 100644 index 000000000000..31a8c574dc25 --- /dev/null +++ b/tools/uintr/manpages/5_unregister_sender.txt @@ -0,0 +1,79 @@ +uintr_unregister_sender(2) System Calls Manual uintr_unregister_sender(2) + + + +NAME + uintr_unregister_sender - Unregister a user inter-process interrupt + sender + + +SYNOPSIS + int uintr_unregister_sender(int uintr_fd, unsigned int flags); + + +DESCRIPTION + uintr_unregister_sender() unregisters a sender process from a uintr_fd + it had previously connected with. If no connection is present with this + uintr_fd the system call return an error. + + The uipi_index that was allocated during uintr_register_sender(2) will + also be freed. If a process tries to use a uipi_index after it has been + freed it would receive a SIGSEGV signal. + + In case of a multi-threaded process uintr_unregister_sender() will only + disconnect the thread that makes this call. Other threads can continue + to use their connection with the uintr_fd based on their uipi_index. + + <We are considering an alternate approach where all threads in a + process see a consistent view of the uipi_index. In that case, + uintr_unregister_sender() would disconnect all threads from uintr_fd.> + + The flags argument is reserved for future use. Currently, it must be + specified as 0. + + close(2) + When the file descriptor is no longer required it should be + closed. When all file descriptors associated with the same + uintr_fd object have been closed, the resources for object are + freed by the kernel. Freeing the uintr_fd object would also + result in the associated uipi_index to be freed. + + The behavior of uintr_unregister_sender() system call after uintr_fd + has been close is undefined. + + +RETURN VALUE + On success, uintr_unregister_sender() returns 0. On error, -1 is + returned and errno is set to indicate the cause of the error. + + +ERRORS + EOPNOTSUPP Underlying hardware doesn't have support for uintr(7). + + EOPNOTSUPP uintr_fd does not refer to a Uintr instance. + + EBADF The uintr_fd passed to the kernel is invalid. + + EINVAL flags is not 0. + + EINVAL No connection has been setup with this uintr_fd. + + +VERSIONS + uintr_unregister_sender() first appeared in Linux <tbd>. + + +CONFORMING TO + uintr_unregister_sender() is Linux specific. + + +NOTES + Currently, there is no glibc wrapper for this system call; call it + using syscall(2). + + The user interrupt related system calls need hardware support to + generate and receive user interrupts. Refer uintr(7) for details. + + + + uintr_unregister_sender(2) diff --git a/tools/uintr/manpages/6_wait.txt b/tools/uintr/manpages/6_wait.txt new file mode 100644 index 000000000000..f281a6ce83aa --- /dev/null +++ b/tools/uintr/manpages/6_wait.txt @@ -0,0 +1,59 @@ +uintr_wait(2) System Calls Manual uintr_wait(2) + + + +NAME + uintr_wait - wait for user interrupts + + +SYNOPSIS + int uintr_wait(unsigned int flags); + + +DESCRIPTION + uintr_wait() causes the calling process (or thread) to sleep until a + user interrupt is delivered. + + uintr_wait() will block in the kernel only when a interrupt handler has + been registered using uintr_register_handler(2) + + <uintr_wait() is a placeholder syscall while we decide on the behaviour + of blocking system calls like sleep(2) and read(2) being interrupted by + uintr(7).> + + +RETURN VALUE + uintr_wait() returns only when a user interrupt is received and the + interrupt handler function returned. In this case, -1 is returned and + errno is set to EINTR. + + +ERRORS + EOPNOTSUPP Underlying hardware doesn't have support for Uintr. + + EOPNOTSUPP No interrupt handler registered. + + EINVAL flags is not 0. + + EINTR A user interrupt was received and the interrupt handler + returned. + + +VERSIONS + uintr_wait() first appeared in Linux <tbd>. + + +CONFORMING TO + uintr_wait() is Linux specific. + + +NOTES + Currently, there is no glibc wrapper for this system call; call it + using syscall(2). + + The user interrupt related system calls need hardware support to + generate and receive user interrupts. Refer uintr(7) for details. + + + + uintr_wait(2) -- 2.33.0
