include/vlc_interrupt.h

   1 /*****************************************************************************
   2  * vlc_interrupt.h:
   3  *****************************************************************************
   4  * Copyright (C) 2015 Remlab T:mi
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published by
   8  * the Free Software Foundation; either version 2.1 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  19  *****************************************************************************/
  20
  21 /**
  22  * @file
  23  * This file declares interruptible sleep functions.
  24  */
  25
  26 #ifndef VLC_INTERRUPT_H
  27 # define VLC_INTERRUPT_H 1
  28 # include <vlc_threads.h>
  29 # ifndef _WIN32
  30 #  include <sys/socket.h> /* socklen_t */
  31 # else
  32 #  include <ws2tcpip.h>
  33 # endif
  34
  35 struct pollfd;
  36 struct iovec;
  37 struct sockaddr;
  38 struct msghdr;
  39
  40 /**
  41  * @defgroup interrupt Interruptible sleep
  42  * @{
  43  * @defgroup interrupt_sleep Interruptible sleep functions
  44  * @{
  45  */
  46
  47 /**
  48  * Interruptible variant of vlc_sem_wait().
  49  *
  50  * Waits on a semaphore like vlc_sem_wait(). If the calling thread has an
  51  * interruption context (as set by vlc_interrupt_set()), and another thread
  52  * invokes vlc_interrupt_raise() on that context, the semaphore is incremented.
  53  *
  54  * @warning The calling thread should be the only thread ever to wait on the
  55  * specified semaphore. Otherwise, interruptions may not be delivered
  56  * accurately (the wrong thread may be woken up).
  57  *
  58  * @note This function is (always) a cancellation point.
  59  *
  60  * @return EINTR if the semaphore was incremented due to an interruption,
  61  * otherwise zero.
  62  */
  63 VLC_API int vlc_sem_wait_i11e(vlc_sem_t *);
  64
  65 /**
  66  * Interruptible variant of mwait().
  67  *
  68  * Waits for a specified timestamp or, if the calling thread has an
  69  * interruption context, an interruption.
  70  *
  71  * @return EINTR if an interruption occurred, otherwise 0 once the timestamp is
  72  * reached.
  73  */
  74 VLC_API int vlc_mwait_i11e(mtime_t);
  75
  76 /**
  77  * Interruptible variant of msleep().
  78  *
  79  * Waits for a specified timeout duration or, if the calling thread has an
  80  * interruption context, an interruption.
  81  *
  82  * @param delay timeout value (in microseconds)
  83  *
  84  * @return EINTR if an interruption occurred, otherwise 0 once the timeout
  85  * expired.
  86  */
  87 static inline int vlc_msleep_i11e(mtime_t delay)
  88 {
  89     return vlc_mwait_i11e(mdate() + delay);
  90 }
  91
  92 /**
  93  * Interruptible variant of poll().
  94  *
  95  * Waits for file descriptors I/O events, a timeout, a signal or a VLC I/O
  96  * interruption. Except for VLC I/O interruptions, this function behaves
  97  * just like the standard poll().
  98  *
  99  * @note This function is always a cancellation point (as poll()).
 100  * @see poll() manual page
 101  *
 102  * @param fds table of events to wait for
 103  * @param nfds number of entries in the table
 104  * @param timeout time to wait in milliseconds or -1 for infinite
 105  *
 106  * @return A strictly positive result represent the number of pending events.
 107  * 0 is returned if the time-out is reached without events.
 108  * -1 is returned if a VLC I/O interrupt occurs (and errno is set to EINTR)
 109  * or if an error occurs.
 110  */
 111 VLC_API int vlc_poll_i11e(struct pollfd *, unsigned, int);
 112
 113 VLC_API ssize_t vlc_readv_i11e(int fd, struct iovec *, int);
 114 VLC_API ssize_t vlc_writev_i11e(int fd, const struct iovec *, int);
 115 VLC_API ssize_t vlc_read_i11e(int fd, void *, size_t);
 116 VLC_API ssize_t vlc_write_i11e(int fd, const void *, size_t);
 117
 118 VLC_API ssize_t vlc_recvmsg_i11e(int fd, struct msghdr *, int flags);
 119 VLC_API ssize_t vlc_sendmsg_i11e(int fd, const struct msghdr *, int flags);
 120
 121 VLC_API ssize_t vlc_recvfrom_i11e(int fd, void *, size_t, int flags,
 122                                 struct sockaddr *, socklen_t *);
 123 VLC_API ssize_t vlc_sendto_i11e(int fd, const void *, size_t, int flags,
 124                               const struct sockaddr *, socklen_t);
 125
 126 static inline ssize_t vlc_recv_i11e(int fd, void *buf, size_t len, int flags)
 127 {
 128     return vlc_recvfrom_i11e(fd, buf, len, flags, NULL, NULL);
 129 }
 130
 131 static inline
 132 ssize_t vlc_send_i11e(int fd, const void *buf, size_t len, int flags)
 133 {
 134     return vlc_sendto_i11e(fd, buf, len, flags, NULL, 0);
 135 }
 136
 137 VLC_API int vlc_accept_i11e(int fd, struct sockaddr *, socklen_t *, bool);
 138
 139 /**
 140  * @}
 141  * @defgroup interrupt_context Interrupt context signaling and manipulation
 142  * @{
 143  */
 144 typedef struct vlc_interrupt vlc_interrupt_t;
 145
 146 /**
 147  * Creates an interruption context.
 148  */
 149 VLC_API vlc_interrupt_t *vlc_interrupt_create(void) VLC_USED;
 150
 151 /**
 152  * Destroys an interrupt context.
 153  */
 154 VLC_API void vlc_interrupt_destroy(vlc_interrupt_t *);
 155
 156 /**
 157  * Sets the interruption context for the calling thread.
 158  * @param newctx the interruption context to attach or NULL for none
 159  * @return the previous interruption context or NULL if none
 160  *
 161  * @note This function is not a cancellation point.
 162  * @warning A context can be attached to no more than one thread at a time.
 163  */
 164 VLC_API vlc_interrupt_t *vlc_interrupt_set(vlc_interrupt_t *);
 165
 166 /**
 167  * Raises an interruption through a specified context.
 168  *
 169  * This is used to asynchronously wake a thread up while it is waiting on some
 170  * other events (typically I/O events).
 171  *
 172  * @note This function is thread-safe.
 173  * @note This function is not a cancellation point.
 174  */
 175 VLC_API void vlc_interrupt_raise(vlc_interrupt_t *);
 176
 177 /**
 178  * Marks the interruption context as "killed".
 179  *
 180  * This is not reversible.
 181  */
 182 VLC_API void vlc_interrupt_kill(vlc_interrupt_t *);
 183
 184 /**
 185  * Checks if the interruption context was "killed".
 186  *
 187  * Indicates whether the interruption context of the calling thread (if any)
 188  * was killed with vlc_interrupt_kill().
 189  */
 190 VLC_API bool vlc_killed(void) VLC_USED;
 191
 192 /**
 193  * Enables forwarding of interruption.
 194  *
 195  * If an interruption is raised through the context of the calling thread,
 196  * it will be forwarded to the specified other context. This is used to cross
 197  * thread boundaries.
 198  *
 199  * If the calling thread already has an interruption pending, this function
 200  * dequeues the interrupt, return an error code and does not enable forwarding.
 201  *
 202  * If the calling thread has no interrupt context, this function does nothing
 203  * and returns zero.
 204  *
 205  * @param to context to forward to
 206  * @return 0 on success, or EINTR on error
 207  */
 208 VLC_API int vlc_interrupt_forward_start(vlc_interrupt_t *to,
 209                                         void *data[2]) VLC_USED;
 210
 211 /**
 212  * Undoes vlc_interrupt_forward_start().
 213  *
 214  * This function must be called after each succesful call to
 215  * vlc_interrupt_forward_start() before any other interruptible call is made
 216  * in the same thread.
 217  *
 218  * If an interruption was raised against the context of the calling thread
 219  * (after the previous call to vlc_interrupt_forward_start()), it is dequeued.
 220  *
 221  * If the calling thread has no interrupt context, this function does nothing
 222  * and returns zero.
 223  *
 224  * @return 0 if no interrupt was raised, EINTR if an interrupt was raised
 225  */
 226 VLC_API int vlc_interrupt_forward_stop(void *const data[2]);
 227
 228 /** @} @} */
 229 #endif