Xenomai  3.0.8
driver.h
Go to the documentation of this file.
1 
26 #ifndef _COBALT_RTDM_DRIVER_H
27 #define _COBALT_RTDM_DRIVER_H
28 
29 #include <asm/atomic.h>
30 #include <linux/list.h>
31 #include <linux/module.h>
32 #include <linux/cdev.h>
33 #include <linux/wait.h>
34 #include <linux/notifier.h>
35 #include <xenomai/version.h>
36 #include <cobalt/kernel/heap.h>
37 #include <cobalt/kernel/sched.h>
38 #include <cobalt/kernel/intr.h>
39 #include <cobalt/kernel/synch.h>
40 #include <cobalt/kernel/select.h>
41 #include <cobalt/kernel/clock.h>
42 #include <cobalt/kernel/apc.h>
43 #include <cobalt/kernel/init.h>
44 #include <cobalt/kernel/ancillaries.h>
45 #include <cobalt/kernel/tree.h>
46 #include <rtdm/fd.h>
47 #include <rtdm/rtdm.h>
48 
49 /* debug support */
50 #include <cobalt/kernel/assert.h>
51 #include <trace/events/cobalt-rtdm.h>
52 #ifdef CONFIG_PCI
53 #include <asm-generic/xenomai/pci_ids.h>
54 #endif /* CONFIG_PCI */
55 #include <asm/xenomai/syscall.h>
56 
57 struct class;
58 typedef struct xnselector rtdm_selector_t;
59 enum rtdm_selecttype;
60 
73 #define RTDM_EXCLUSIVE 0x0001
74 
80 #define RTDM_FIXED_MINOR 0x0002
81 
83 #define RTDM_NAMED_DEVICE 0x0010
84 
87 #define RTDM_PROTOCOL_DEVICE 0x0020
88 
90 #define RTDM_DEVICE_TYPE_MASK 0x00F0
91 
93 #define RTDM_SECURE_DEVICE 0x80000000
94 
97 #define RTDM_MAX_MINOR 4096
98 
113  RTDM_SELECTTYPE_READ = XNSELECT_READ,
114 
116  RTDM_SELECTTYPE_WRITE = XNSELECT_WRITE,
117 
119  RTDM_SELECTTYPE_EXCEPT = XNSELECT_EXCEPT
120 };
137  struct rtdm_fd fd;
138 
142 
144  char dev_private[0];
145 };
146 
147 static inline struct rtdm_dev_context *rtdm_fd_to_context(struct rtdm_fd *fd)
148 {
149  return container_of(fd, struct rtdm_dev_context, fd);
150 }
151 
161 static inline void *rtdm_fd_to_private(struct rtdm_fd *fd)
162 {
163  return &rtdm_fd_to_context(fd)->dev_private[0];
164 }
165 
174 static inline struct rtdm_fd *rtdm_private_to_fd(void *dev_private)
175 {
176  struct rtdm_dev_context *ctx;
177  ctx = container_of(dev_private, struct rtdm_dev_context, dev_private);
178  return &ctx->fd;
179 }
180 
189 static inline bool rtdm_fd_is_user(struct rtdm_fd *fd)
190 {
191  return rtdm_fd_owner(fd) != &cobalt_kernel_ppd;
192 }
193 
202 static inline struct rtdm_device *rtdm_fd_device(struct rtdm_fd *fd)
203 {
204  return rtdm_fd_to_context(fd)->device;
205 }
206 
215 struct rtdm_profile_info {
217  const char *name;
219  int class_id;
222  int subclass_id;
224  int version;
226  unsigned int magic;
227  struct module *owner;
228  struct class *kdev_class;
229 };
230 
231 struct rtdm_driver;
232 
236 struct rtdm_sm_ops {
238  int (*start)(struct rtdm_driver *drv);
240  int (*stop)(struct rtdm_driver *drv);
241 };
242 
249 struct rtdm_driver {
255  struct rtdm_profile_info profile_info;
269  size_t context_size;
275  struct rtdm_fd_ops ops;
286  struct {
287  union {
288  struct {
289  struct cdev cdev;
290  int major;
291  } named;
292  };
293  atomic_t refcount;
294  struct notifier_block nb_statechange;
295  DECLARE_BITMAP(minor_map, RTDM_MAX_MINOR);
296  };
297 };
298 
299 #define RTDM_CLASS_MAGIC 0x8284636c
300 
319 #define RTDM_PROFILE_INFO(__name, __id, __subid, __version) \
320 { \
321  .name = ( # __name ), \
322  .class_id = (__id), \
323  .subclass_id = (__subid), \
324  .version = (__version), \
325  .magic = ~RTDM_CLASS_MAGIC, \
326  .owner = THIS_MODULE, \
327  .kdev_class = NULL, \
328 }
329 
330 int rtdm_drv_set_sysclass(struct rtdm_driver *drv, struct class *cls);
331 
338 struct rtdm_device {
342  void *device_data;
354  const char *label;
369  int minor;
371  struct {
372  unsigned int magic;
373  char *name;
374  union {
375  struct {
376  xnhandle_t handle;
377  } named;
378  struct {
379  struct xnid id;
380  } proto;
381  };
382  dev_t rdev;
383  struct device *kdev;
384  struct class *kdev_class;
385  atomic_t refcount;
386  struct rtdm_fd_ops ops;
387  wait_queue_head_t putwq;
388  };
389 };
390 
393 /* --- device registration --- */
394 
395 int rtdm_dev_register(struct rtdm_device *device);
396 
397 void rtdm_dev_unregister(struct rtdm_device *device);
398 
399 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
400 
401 static inline struct device *rtdm_dev_to_kdev(struct rtdm_device *device)
402 {
403  return device->kdev;
404 }
405 
406 /* --- clock services --- */
407 static inline nanosecs_abs_t rtdm_clock_read(void)
408 {
409  return xnclock_read_realtime(&nkclock);
410 }
411 
412 static inline nanosecs_abs_t rtdm_clock_read_monotonic(void)
413 {
414  return xnclock_read_monotonic(&nkclock);
415 }
416 #endif /* !DOXYGEN_CPP */
417 
418 /* --- timeout sequences */
419 
420 typedef nanosecs_abs_t rtdm_toseq_t;
421 
422 void rtdm_toseq_init(rtdm_toseq_t *timeout_seq, nanosecs_rel_t timeout);
423 
459 #define cobalt_atomic_enter(__context) \
460  do { \
461  xnlock_get_irqsave(&nklock, (__context)); \
462  xnsched_lock(); \
463  } while (0)
464 
477 #define cobalt_atomic_leave(__context) \
478  do { \
479  xnsched_unlock(); \
480  xnlock_put_irqrestore(&nklock, (__context)); \
481  } while (0)
482 
511 #ifdef DOXYGEN_CPP /* Beautify doxygen output */
512 #define RTDM_EXECUTE_ATOMICALLY(code_block) \
513 { \
514  <ENTER_ATOMIC_SECTION> \
515  code_block; \
516  <LEAVE_ATOMIC_SECTION> \
517 }
518 #else /* This is how it really works */
519 static inline __attribute__((deprecated)) void
520 rtdm_execute_atomically(void) { }
521 
522 #define RTDM_EXECUTE_ATOMICALLY(code_block) \
523 { \
524  spl_t __rtdm_s; \
525  \
526  rtdm_execute_atomically(); \
527  xnlock_get_irqsave(&nklock, __rtdm_s); \
528  xnsched_lock(); \
529  code_block; \
530  xnsched_unlock(); \
531  xnlock_put_irqrestore(&nklock, __rtdm_s); \
532 }
533 #endif
534 
545 #define RTDM_LOCK_UNLOCKED(__name) IPIPE_SPIN_LOCK_UNLOCKED
546 
547 #define DEFINE_RTDM_LOCK(__name) \
548  rtdm_lock_t __name = RTDM_LOCK_UNLOCKED(__name)
549 
551 typedef ipipe_spinlock_t rtdm_lock_t;
552 
554 typedef unsigned long rtdm_lockctx_t;
555 
563 static inline void rtdm_lock_init(rtdm_lock_t *lock)
564 {
565  raw_spin_lock_init(lock);
566 }
567 
575 static inline void rtdm_lock_get(rtdm_lock_t *lock)
576 {
577  XENO_BUG_ON(COBALT, !spltest());
578  raw_spin_lock(lock);
579  xnsched_lock();
580 }
581 
589 static inline void rtdm_lock_put(rtdm_lock_t *lock)
590 {
591  raw_spin_unlock(lock);
592  xnsched_unlock();
593 }
594 
603 #define rtdm_lock_get_irqsave(__lock, __context) \
604  ((__context) = __rtdm_lock_get_irqsave(__lock))
605 
606 static inline rtdm_lockctx_t __rtdm_lock_get_irqsave(rtdm_lock_t *lock)
607 {
608  rtdm_lockctx_t context;
609 
610  context = ipipe_test_and_stall_head();
611  raw_spin_lock(lock);
612  xnsched_lock();
613 
614  return context;
615 }
616 
625 static inline
627 {
628  raw_spin_unlock(lock);
629  xnsched_unlock();
630  ipipe_restore_head(context);
631 }
632 
640 #define rtdm_lock_irqsave(__context) \
641  splhigh(__context)
642 
650 #define rtdm_lock_irqrestore(__context) \
651  splexit(__context)
652 
655 #ifndef DOXYGEN_CPP
656 
657 struct rtdm_waitqueue {
658  struct xnsynch wait;
659 };
660 typedef struct rtdm_waitqueue rtdm_waitqueue_t;
661 
662 #define RTDM_WAITQUEUE_INITIALIZER(__name) { \
663  .wait = XNSYNCH_WAITQUEUE_INITIALIZER((__name).wait), \
664  }
665 
666 #define DEFINE_RTDM_WAITQUEUE(__name) \
667  struct rtdm_waitqueue __name = RTDM_WAITQUEUE_INITIALIZER(__name)
668 
669 #define DEFINE_RTDM_WAITQUEUE_ONSTACK(__name) \
670  DEFINE_RTDM_WAITQUEUE(__name)
671 
672 static inline void rtdm_waitqueue_init(struct rtdm_waitqueue *wq)
673 {
674  *wq = (struct rtdm_waitqueue)RTDM_WAITQUEUE_INITIALIZER(*wq);
675 }
676 
677 static inline void rtdm_waitqueue_destroy(struct rtdm_waitqueue *wq)
678 {
679  xnsynch_destroy(&wq->wait);
680 }
681 
682 static inline int __rtdm_dowait(struct rtdm_waitqueue *wq,
683  nanosecs_rel_t timeout, xntmode_t timeout_mode)
684 {
685  int ret;
686 
687  ret = xnsynch_sleep_on(&wq->wait, timeout, timeout_mode);
688  if (ret & XNBREAK)
689  return -EINTR;
690  if (ret & XNTIMEO)
691  return -ETIMEDOUT;
692  if (ret & XNRMID)
693  return -EIDRM;
694  return 0;
695 }
696 
697 static inline int __rtdm_timedwait(struct rtdm_waitqueue *wq,
698  nanosecs_rel_t timeout, rtdm_toseq_t *toseq)
699 {
700  if (toseq && timeout > 0)
701  return __rtdm_dowait(wq, *toseq, XN_ABSOLUTE);
702 
703  return __rtdm_dowait(wq, timeout, XN_RELATIVE);
704 }
705 
706 #define rtdm_timedwait_condition_locked(__wq, __cond, __timeout, __toseq) \
707  ({ \
708  int __ret = 0; \
709  while (__ret == 0 && !(__cond)) \
710  __ret = __rtdm_timedwait(__wq, __timeout, __toseq); \
711  __ret; \
712  })
713 
714 #define rtdm_wait_condition_locked(__wq, __cond) \
715  ({ \
716  int __ret = 0; \
717  while (__ret == 0 && !(__cond)) \
718  __ret = __rtdm_dowait(__wq, \
719  XN_INFINITE, XN_RELATIVE); \
720  __ret; \
721  })
722 
723 #define rtdm_timedwait_condition(__wq, __cond, __timeout, __toseq) \
724  ({ \
725  spl_t __s; \
726  int __ret; \
727  xnlock_get_irqsave(&nklock, __s); \
728  __ret = rtdm_timedwait_condition_locked(__wq, __cond, \
729  __timeout, __toseq); \
730  xnlock_put_irqrestore(&nklock, __s); \
731  __ret; \
732  })
733 
734 #define rtdm_timedwait(__wq, __timeout, __toseq) \
735  __rtdm_timedwait(__wq, __timeout, __toseq)
736 
737 #define rtdm_timedwait_locked(__wq, __timeout, __toseq) \
738  rtdm_timedwait(__wq, __timeout, __toseq)
739 
740 #define rtdm_wait_condition(__wq, __cond) \
741  ({ \
742  spl_t __s; \
743  int __ret; \
744  xnlock_get_irqsave(&nklock, __s); \
745  __ret = rtdm_wait_condition_locked(__wq, __cond); \
746  xnlock_put_irqrestore(&nklock, __s); \
747  __ret; \
748  })
749 
750 #define rtdm_wait(__wq) \
751  __rtdm_dowait(__wq, XN_INFINITE, XN_RELATIVE)
752 
753 #define rtdm_wait_locked(__wq) rtdm_wait(__wq)
754 
755 #define rtdm_waitqueue_lock(__wq, __context) cobalt_atomic_enter(__context)
756 
757 #define rtdm_waitqueue_unlock(__wq, __context) cobalt_atomic_leave(__context)
758 
759 #define rtdm_waitqueue_signal(__wq) \
760  ({ \
761  struct xnthread *__waiter; \
762  __waiter = xnsynch_wakeup_one_sleeper(&(__wq)->wait); \
763  xnsched_run(); \
764  __waiter != NULL; \
765  })
766 
767 #define __rtdm_waitqueue_flush(__wq, __reason) \
768  ({ \
769  int __ret; \
770  __ret = xnsynch_flush(&(__wq)->wait, __reason); \
771  xnsched_run(); \
772  __ret == XNSYNCH_RESCHED; \
773  })
774 
775 #define rtdm_waitqueue_broadcast(__wq) \
776  __rtdm_waitqueue_flush(__wq, 0)
777 
778 #define rtdm_waitqueue_flush(__wq) \
779  __rtdm_waitqueue_flush(__wq, XNBREAK)
780 
781 #define rtdm_waitqueue_wakeup(__wq, __waiter) \
782  do { \
783  xnsynch_wakeup_this_sleeper(&(__wq)->wait, __waiter); \
784  xnsched_run(); \
785  } while (0)
786 
787 #define rtdm_for_each_waiter(__pos, __wq) \
788  xnsynch_for_each_sleeper(__pos, &(__wq)->wait)
789 
790 #define rtdm_for_each_waiter_safe(__pos, __tmp, __wq) \
791  xnsynch_for_each_sleeper_safe(__pos, __tmp, &(__wq)->wait)
792 
793 #endif /* !DOXYGEN_CPP */
794 
797 /* --- Interrupt management services --- */
803 typedef struct xnintr rtdm_irq_t;
804 
811 #define RTDM_IRQTYPE_SHARED XN_IRQTYPE_SHARED
812 
814 #define RTDM_IRQTYPE_EDGE XN_IRQTYPE_EDGE
815 
824 typedef int (*rtdm_irq_handler_t)(rtdm_irq_t *irq_handle);
825 
832 #define RTDM_IRQ_NONE XN_IRQ_NONE
833 
834 #define RTDM_IRQ_HANDLED XN_IRQ_HANDLED
835 
836 #define RTDM_IRQ_DISABLE XN_IRQ_DISABLE
837 
850 #define rtdm_irq_get_arg(irq_handle, type) ((type *)irq_handle->cookie)
851 
853 int rtdm_irq_request(rtdm_irq_t *irq_handle, unsigned int irq_no,
854  rtdm_irq_handler_t handler, unsigned long flags,
855  const char *device_name, void *arg);
856 
857 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
858 static inline int rtdm_irq_free(rtdm_irq_t *irq_handle)
859 {
860  if (!XENO_ASSERT(COBALT, xnsched_root_p()))
861  return -EPERM;
862  xnintr_detach(irq_handle);
863  return 0;
864 }
865 
866 static inline int rtdm_irq_enable(rtdm_irq_t *irq_handle)
867 {
868  xnintr_enable(irq_handle);
869  return 0;
870 }
871 
872 static inline int rtdm_irq_disable(rtdm_irq_t *irq_handle)
873 {
874  xnintr_disable(irq_handle);
875  return 0;
876 }
877 #endif /* !DOXYGEN_CPP */
878 
879 /* --- non-real-time signalling services --- */
880 
886 typedef struct rtdm_nrtsig rtdm_nrtsig_t;
897 typedef void (*rtdm_nrtsig_handler_t)(rtdm_nrtsig_t *nrt_sig, void *arg);
898 
899 struct rtdm_nrtsig {
900  rtdm_nrtsig_handler_t handler;
901  void *arg;
902 };
903 
904 void rtdm_schedule_nrt_work(struct work_struct *lostage_work);
907 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
908 static inline void rtdm_nrtsig_init(rtdm_nrtsig_t *nrt_sig,
909  rtdm_nrtsig_handler_t handler, void *arg)
910 {
911  nrt_sig->handler = handler;
912  nrt_sig->arg = arg;
913 }
914 
915 static inline void rtdm_nrtsig_destroy(rtdm_nrtsig_t *nrt_sig)
916 {
917  nrt_sig->handler = NULL;
918  nrt_sig->arg = NULL;
919 }
920 
921 void rtdm_nrtsig_pend(rtdm_nrtsig_t *nrt_sig);
922 #endif /* !DOXYGEN_CPP */
923 
924 /* --- timer services --- */
925 
931 typedef struct xntimer rtdm_timer_t;
932 
938 typedef void (*rtdm_timer_handler_t)(rtdm_timer_t *timer);
939 
947  RTDM_TIMERMODE_RELATIVE = XN_RELATIVE,
948 
950  RTDM_TIMERMODE_ABSOLUTE = XN_ABSOLUTE,
951 
954 };
959 #ifndef DOXYGEN_CPP /* Avoid broken doxygen output */
960 #define rtdm_timer_init(timer, handler, name) \
961 ({ \
962  xntimer_init((timer), &nkclock, handler, \
963  NULL, XNTIMER_IGRAVITY); \
964  xntimer_set_name((timer), (name)); \
965  0; \
966 })
967 
968 #endif /* !DOXYGEN_CPP */
969 
970 void rtdm_timer_destroy(rtdm_timer_t *timer);
971 
972 int rtdm_timer_start(rtdm_timer_t *timer, nanosecs_abs_t expiry,
973  nanosecs_rel_t interval, enum rtdm_timer_mode mode);
974 
975 void rtdm_timer_stop(rtdm_timer_t *timer);
976 
977 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
978 static inline int rtdm_timer_start_in_handler(rtdm_timer_t *timer,
979  nanosecs_abs_t expiry,
980  nanosecs_rel_t interval,
981  enum rtdm_timer_mode mode)
982 {
983  return xntimer_start(timer, expiry, interval, (xntmode_t)mode);
984 }
985 
986 static inline void rtdm_timer_stop_in_handler(rtdm_timer_t *timer)
987 {
988  xntimer_stop(timer);
989 }
990 #endif /* !DOXYGEN_CPP */
991 
992 /* --- task services --- */
998 typedef struct xnthread rtdm_task_t;
999 
1005 typedef void (*rtdm_task_proc_t)(void *arg);
1006 
1011 #define RTDM_TASK_LOWEST_PRIORITY 0
1012 #define RTDM_TASK_HIGHEST_PRIORITY 99
1013 
1019 #define RTDM_TASK_RAISE_PRIORITY (+1)
1020 #define RTDM_TASK_LOWER_PRIORITY (-1)
1021 
1025 int rtdm_task_init(rtdm_task_t *task, const char *name,
1026  rtdm_task_proc_t task_proc, void *arg,
1027  int priority, nanosecs_rel_t period);
1028 int __rtdm_task_sleep(xnticks_t timeout, xntmode_t mode);
1030 
1031 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
1032 static inline void rtdm_task_destroy(rtdm_task_t *task)
1033 {
1034  xnthread_cancel(task);
1035  xnthread_join(task, true);
1036 }
1037 
1038 static inline int rtdm_task_should_stop(void)
1039 {
1040  return xnthread_test_info(xnthread_current(), XNCANCELD);
1041 }
1042 
1043 void rtdm_task_join(rtdm_task_t *task);
1044 
1045 static inline void __deprecated rtdm_task_join_nrt(rtdm_task_t *task,
1046  unsigned int poll_delay)
1047 {
1048  rtdm_task_join(task);
1049 }
1050 
1051 static inline void rtdm_task_set_priority(rtdm_task_t *task, int priority)
1052 {
1053  union xnsched_policy_param param = { .rt = { .prio = priority } };
1054  xnthread_set_schedparam(task, &xnsched_class_rt, &param);
1055  xnsched_run();
1056 }
1057 
1058 static inline int rtdm_task_set_period(rtdm_task_t *task,
1059  nanosecs_abs_t start_date,
1060  nanosecs_rel_t period)
1061 {
1062  if (period < 0)
1063  period = 0;
1064  if (start_date == 0)
1065  start_date = XN_INFINITE;
1066 
1067  return xnthread_set_periodic(task, start_date, XN_ABSOLUTE, period);
1068 }
1069 
1070 static inline int rtdm_task_unblock(rtdm_task_t *task)
1071 {
1072  int res = xnthread_unblock(task);
1073 
1074  xnsched_run();
1075  return res;
1076 }
1077 
1078 static inline rtdm_task_t *rtdm_task_current(void)
1079 {
1080  return xnthread_current();
1081 }
1082 
1083 static inline int rtdm_task_wait_period(unsigned long *overruns_r)
1084 {
1085  if (!XENO_ASSERT(COBALT, !xnsched_unblockable_p()))
1086  return -EPERM;
1087  return xnthread_wait_period(overruns_r);
1088 }
1089 
1090 static inline int rtdm_task_sleep(nanosecs_rel_t delay)
1091 {
1092  return __rtdm_task_sleep(delay, XN_RELATIVE);
1093 }
1094 
1095 static inline int
1096 rtdm_task_sleep_abs(nanosecs_abs_t wakeup_date, enum rtdm_timer_mode mode)
1097 {
1098  /* For the sake of a consistent API usage... */
1099  if (mode != RTDM_TIMERMODE_ABSOLUTE && mode != RTDM_TIMERMODE_REALTIME)
1100  return -EINVAL;
1101  return __rtdm_task_sleep(wakeup_date, (xntmode_t)mode);
1102 }
1103 
1104 /* rtdm_task_sleep_abs shall be used instead */
1105 static inline int __deprecated rtdm_task_sleep_until(nanosecs_abs_t wakeup_time)
1106 {
1107  return __rtdm_task_sleep(wakeup_time, XN_REALTIME);
1108 }
1109 
1110 #define rtdm_task_busy_wait(__condition, __spin_ns, __sleep_ns) \
1111  ({ \
1112  __label__ done; \
1113  nanosecs_abs_t __end; \
1114  int __ret = 0; \
1115  for (;;) { \
1116  __end = rtdm_clock_read_monotonic() + __spin_ns; \
1117  for (;;) { \
1118  if (__condition) \
1119  goto done; \
1120  if (rtdm_clock_read_monotonic() >= __end) \
1121  break; \
1122  } \
1123  __ret = rtdm_task_sleep(__sleep_ns); \
1124  if (__ret) \
1125  break; \
1126  } \
1127  done: \
1128  __ret; \
1129  })
1130 
1131 #define rtdm_wait_context xnthread_wait_context
1132 
1133 static inline
1134 void rtdm_wait_complete(struct rtdm_wait_context *wc)
1135 {
1136  xnthread_complete_wait(wc);
1137 }
1138 
1139 static inline
1140 int rtdm_wait_is_completed(struct rtdm_wait_context *wc)
1141 {
1142  return xnthread_wait_complete_p(wc);
1143 }
1144 
1145 static inline void rtdm_wait_prepare(struct rtdm_wait_context *wc)
1146 {
1147  xnthread_prepare_wait(wc);
1148 }
1149 
1150 static inline
1151 struct rtdm_wait_context *rtdm_wait_get_context(rtdm_task_t *task)
1152 {
1153  return xnthread_get_wait_context(task);
1154 }
1155 
1156 #endif /* !DOXYGEN_CPP */
1157 
1158 /* --- event services --- */
1159 
1160 typedef struct rtdm_event {
1161  struct xnsynch synch_base;
1162  DECLARE_XNSELECT(select_block);
1163 } rtdm_event_t;
1164 
1165 #define RTDM_EVENT_PENDING XNSYNCH_SPARE1
1166 
1167 void rtdm_event_init(rtdm_event_t *event, unsigned long pending);
1168 int rtdm_event_select(rtdm_event_t *event, rtdm_selector_t *selector,
1169  enum rtdm_selecttype type, unsigned fd_index);
1170 int rtdm_event_wait(rtdm_event_t *event);
1171 int rtdm_event_timedwait(rtdm_event_t *event, nanosecs_rel_t timeout,
1172  rtdm_toseq_t *timeout_seq);
1173 void rtdm_event_signal(rtdm_event_t *event);
1174 
1175 void rtdm_event_clear(rtdm_event_t *event);
1176 
1177 void rtdm_event_pulse(rtdm_event_t *event);
1178 
1179 void rtdm_event_destroy(rtdm_event_t *event);
1180 
1181 /* --- semaphore services --- */
1182 
1183 typedef struct rtdm_sem {
1184  unsigned long value;
1185  struct xnsynch synch_base;
1186  DECLARE_XNSELECT(select_block);
1187 } rtdm_sem_t;
1188 
1189 void rtdm_sem_init(rtdm_sem_t *sem, unsigned long value);
1190 int rtdm_sem_select(rtdm_sem_t *sem, rtdm_selector_t *selector,
1191  enum rtdm_selecttype type, unsigned fd_index);
1192 int rtdm_sem_down(rtdm_sem_t *sem);
1193 int rtdm_sem_timeddown(rtdm_sem_t *sem, nanosecs_rel_t timeout,
1194  rtdm_toseq_t *timeout_seq);
1195 void rtdm_sem_up(rtdm_sem_t *sem);
1196 
1197 void rtdm_sem_destroy(rtdm_sem_t *sem);
1198 
1199 /* --- mutex services --- */
1200 
1201 typedef struct rtdm_mutex {
1202  struct xnsynch synch_base;
1203  atomic_t fastlock;
1204 } rtdm_mutex_t;
1205 
1206 void rtdm_mutex_init(rtdm_mutex_t *mutex);
1207 int rtdm_mutex_lock(rtdm_mutex_t *mutex);
1208 int rtdm_mutex_timedlock(rtdm_mutex_t *mutex, nanosecs_rel_t timeout,
1209  rtdm_toseq_t *timeout_seq);
1210 void rtdm_mutex_unlock(rtdm_mutex_t *mutex);
1211 void rtdm_mutex_destroy(rtdm_mutex_t *mutex);
1212 
1213 /* --- utility functions --- */
1214 
1215 #define rtdm_printk(format, ...) printk(format, ##__VA_ARGS__)
1216 
1217 struct rtdm_ratelimit_state {
1218  rtdm_lock_t lock; /* protect the state */
1219  nanosecs_abs_t interval;
1220  int burst;
1221  int printed;
1222  int missed;
1223  nanosecs_abs_t begin;
1224 };
1225 
1226 int rtdm_ratelimit(struct rtdm_ratelimit_state *rs, const char *func);
1227 
1228 #define DEFINE_RTDM_RATELIMIT_STATE(name, interval_init, burst_init) \
1229  struct rtdm_ratelimit_state name = { \
1230  .lock = RTDM_LOCK_UNLOCKED((name).lock), \
1231  .interval = interval_init, \
1232  .burst = burst_init, \
1233  }
1234 
1235 /* We use the Linux defaults */
1236 #define DEF_RTDM_RATELIMIT_INTERVAL 5000000000LL
1237 #define DEF_RTDM_RATELIMIT_BURST 10
1238 
1239 #define rtdm_printk_ratelimited(fmt, ...) ({ \
1240  static DEFINE_RTDM_RATELIMIT_STATE(_rs, \
1241  DEF_RTDM_RATELIMIT_INTERVAL, \
1242  DEF_RTDM_RATELIMIT_BURST); \
1243  \
1244  if (rtdm_ratelimit(&_rs, __func__)) \
1245  printk(fmt, ##__VA_ARGS__); \
1246 })
1247 
1248 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
1249 static inline void *rtdm_malloc(size_t size)
1250 {
1251  return xnmalloc(size);
1252 }
1253 
1254 static inline void rtdm_free(void *ptr)
1255 {
1256  xnfree(ptr);
1257 }
1258 
1259 int rtdm_mmap_to_user(struct rtdm_fd *fd,
1260  void *src_addr, size_t len,
1261  int prot, void **pptr,
1262  struct vm_operations_struct *vm_ops,
1263  void *vm_private_data);
1264 
1265 int rtdm_iomap_to_user(struct rtdm_fd *fd,
1266  phys_addr_t src_addr, size_t len,
1267  int prot, void **pptr,
1268  struct vm_operations_struct *vm_ops,
1269  void *vm_private_data);
1270 
1271 int rtdm_mmap_kmem(struct vm_area_struct *vma, void *va);
1272 
1273 int rtdm_mmap_vmem(struct vm_area_struct *vma, void *va);
1274 
1275 int rtdm_mmap_iomem(struct vm_area_struct *vma, phys_addr_t pa);
1276 
1277 int rtdm_munmap(void *ptr, size_t len);
1278 
1279 static inline int rtdm_read_user_ok(struct rtdm_fd *fd,
1280  const void __user *ptr, size_t size)
1281 {
1282  return access_rok(ptr, size);
1283 }
1284 
1285 static inline int rtdm_rw_user_ok(struct rtdm_fd *fd,
1286  const void __user *ptr, size_t size)
1287 {
1288  return access_wok(ptr, size);
1289 }
1290 
1291 static inline int rtdm_copy_from_user(struct rtdm_fd *fd,
1292  void *dst, const void __user *src,
1293  size_t size)
1294 {
1295  return __xn_copy_from_user(dst, src, size) ? -EFAULT : 0;
1296 }
1297 
1298 static inline int rtdm_safe_copy_from_user(struct rtdm_fd *fd,
1299  void *dst, const void __user *src,
1300  size_t size)
1301 {
1302  return cobalt_copy_from_user(dst, src, size);
1303 }
1304 
1305 static inline int rtdm_copy_to_user(struct rtdm_fd *fd,
1306  void __user *dst, const void *src,
1307  size_t size)
1308 {
1309  return __xn_copy_to_user(dst, src, size) ? -EFAULT : 0;
1310 }
1311 
1312 static inline int rtdm_safe_copy_to_user(struct rtdm_fd *fd,
1313  void __user *dst, const void *src,
1314  size_t size)
1315 {
1316  return cobalt_copy_to_user(dst, src, size);
1317 }
1318 
1319 static inline int rtdm_strncpy_from_user(struct rtdm_fd *fd,
1320  char *dst,
1321  const char __user *src, size_t count)
1322 {
1323  return cobalt_strncpy_from_user(dst, src, count);
1324 }
1325 
1326 static inline int rtdm_rt_capable(struct rtdm_fd *fd)
1327 {
1328  if (!XENO_ASSERT(COBALT, !xnsched_interrupt_p()))
1329  return 0;
1330 
1331  if (!rtdm_fd_is_user(fd))
1332  return !xnsched_root_p();
1333 
1334  return xnthread_current() != NULL;
1335 }
1336 
1337 static inline int rtdm_in_rt_context(void)
1338 {
1339  return (ipipe_current_domain != ipipe_root_domain);
1340 }
1341 
1342 #define RTDM_IOV_FASTMAX 16
1343 
1344 int rtdm_get_iovec(struct rtdm_fd *fd, struct iovec **iov,
1345  const struct user_msghdr *msg,
1346  struct iovec *iov_fast);
1347 
1348 int rtdm_put_iovec(struct rtdm_fd *fd, struct iovec *iov,
1349  const struct user_msghdr *msg,
1350  struct iovec *iov_fast);
1351 
1352 static inline
1353 void rtdm_drop_iovec(struct iovec *iov, struct iovec *iov_fast)
1354 {
1355  if (iov != iov_fast)
1356  xnfree(iov);
1357 }
1358 
1359 ssize_t rtdm_get_iov_flatlen(struct iovec *iov, int iovlen);
1360 
1361 #endif /* !DOXYGEN_CPP */
1362 
1363 #endif /* _COBALT_RTDM_DRIVER_H */
void(* rtdm_task_proc_t)(void *arg)
Real-time task procedure.
Definition: driver.h:1005
static void rtdm_lock_put_irqrestore(rtdm_lock_t *lock, rtdm_lockctx_t context)
Release lock and restore preemption state.
Definition: driver.h:626
void rtdm_mutex_destroy(rtdm_mutex_t *mutex)
Destroy a mutex.
Definition: drvlib.c:1260
struct rtdm_fd_ops ops
I/O operation handlers.
Definition: driver.h:275
void rtdm_task_busy_sleep(nanosecs_rel_t delay)
Busy-wait a specified amount of time.
Definition: drvlib.c:483
int rtdm_nrtsig_init(rtdm_nrtsig_t *nrt_sig, rtdm_nrtsig_handler_t handler, void *arg)
Register a non-real-time signal handler.
int socket_type
Protocol device identification: socket type (SOCK_xxx)
Definition: driver.h:273
void xnintr_enable(struct xnintr *intr)
Enable an interrupt line.
Definition: intr.c:892
void rtdm_mutex_unlock(rtdm_mutex_t *mutex)
Release a mutex.
Definition: drvlib.c:1278
void(* rtdm_nrtsig_handler_t)(rtdm_nrtsig_t *nrt_sig, void *arg)
Non-real-time signal handler.
Definition: driver.h:897
void xnintr_detach(struct xnintr *intr)
Detach an interrupt descriptor.
Definition: intr.c:866
Select ouput buffer availability events.
Definition: driver.h:116
ipipe_spinlock_t rtdm_lock_t
Lock variable.
Definition: driver.h:551
void xnthread_cancel(struct xnthread *thread)
Cancel a thread.
Definition: thread.c:1500
#define XNCANCELD
Cancellation request is pending.
Definition: thread.h:72
int rtdm_rw_user_ok(struct rtdm_fd *fd, const void __user *ptr, size_t size)
Check if read/write access to user-space memory block is safe.
int rtdm_munmap(void *ptr, size_t len)
Unmap a user memory range.
Definition: drvlib.c:2100
int rtdm_task_sleep_abs(nanosecs_abs_t wakeup_time, enum rtdm_timer_mode mode)
Sleep until a specified absolute time.
static void * rtdm_fd_to_private(struct rtdm_fd *fd)
Locate the driver private area associated to a device context structure.
Definition: driver.h:161
static void rtdm_lock_put(rtdm_lock_t *lock)
Release lock without preemption restoration.
Definition: driver.h:589
int64_t nanosecs_rel_t
RTDM type for representing relative intervals.
Definition: rtdm.h:49
struct rtdm_profile_info profile_info
Class profile information.
Definition: driver.h:255
int rtdm_drv_set_sysclass(struct rtdm_driver *drv, struct class *cls)
Set the kernel device class of a RTDM driver.
Definition: device.c:604
Adjustable timer with absolute timeout.
Definition: driver.h:953
void rtdm_timer_stop_in_handler(rtdm_timer_t *timer)
Stop a timer from inside a timer handler.
RTDM file operation descriptor.
Definition: fd.h:243
int(* rtdm_irq_handler_t)(rtdm_irq_t *irq_handle)
Interrupt handler.
Definition: driver.h:824
char dev_private[0]
Begin of driver defined context data structure.
Definition: driver.h:144
int rtdm_ratelimit(struct rtdm_ratelimit_state *rs, const char *func)
Enforces a rate limit.
Definition: drvlib.c:2122
void xnintr_disable(struct xnintr *intr)
Disable an interrupt line.
Definition: intr.c:923
size_t context_size
Size of the private memory area the core should automatically allocate for each open file descriptor...
Definition: driver.h:269
int rtdm_timer_start(rtdm_timer_t *timer, nanosecs_abs_t expiry, nanosecs_rel_t interval, enum rtdm_timer_mode mode)
Start a timer.
Definition: drvlib.c:556
int rtdm_dev_register(struct rtdm_device *device)
Register a RTDM device.
Definition: device.c:389
#define XNTIMEO
Woken up due to a timeout condition.
Definition: thread.h:66
void rtdm_task_join(rtdm_task_t *task)
Wait on a real-time task to terminate.
Definition: drvlib.c:460
int(* start)(struct rtdm_driver *drv)
Handler called upon transition to COBALT_STATE_WARMUP.
Definition: driver.h:238
Select exceptional events.
Definition: driver.h:119
int rtdm_sem_select(rtdm_sem_t *sem, rtdm_selector_t *selector, enum rtdm_selecttype type, unsigned int fd_index)
Bind a selector to a semaphore.
Definition: drvlib.c:1198
void * device_data
Driver definable device data.
Definition: driver.h:342
static struct rtdm_device * rtdm_fd_device(struct rtdm_fd *fd)
Locate a device structure from a file descriptor.
Definition: driver.h:202
int rtdm_strncpy_from_user(struct rtdm_fd *fd, char *dst, const char __user *src, size_t count)
Copy user-space string to specified buffer.
void * rtdm_malloc(size_t size)
Allocate memory block.
int rtdm_task_sleep(nanosecs_rel_t delay)
Sleep a specified amount of time.
int rtdm_irq_request(rtdm_irq_t *irq_handle, unsigned int irq_no, rtdm_irq_handler_t handler, unsigned long flags, const char *device_name, void *arg)
Register an interrupt handler.
Definition: drvlib.c:1423
void rtdm_timer_destroy(rtdm_timer_t *timer)
Destroy a timer.
Definition: drvlib.c:526
int rtdm_event_wait(rtdm_event_t *event)
Wait on event occurrence.
Definition: drvlib.c:826
int rtdm_mutex_lock(rtdm_mutex_t *mutex)
Request a mutex.
Definition: drvlib.c:1308
void rtdm_event_pulse(rtdm_event_t *event)
Signal an event occurrence to currently listening waiters.
Definition: drvlib.c:766
Monotonic timer with absolute timeout.
Definition: driver.h:950
void rtdm_wait_prepare(struct rtdm_wait_context *wc)
Register wait context.
void rtdm_toseq_init(rtdm_toseq_t *timeout_seq, nanosecs_rel_t timeout)
Initialise a timeout sequence
Definition: drvlib.c:696
int rtdm_sem_timeddown(rtdm_sem_t *sem, nanosecs_rel_t timeout, rtdm_toseq_t *timeout_seq)
Decrement a semaphore with timeout.
Definition: drvlib.c:1097
rtdm_task_t * rtdm_task_current(void)
Get current real-time task.
void rtdm_nrtsig_pend(rtdm_nrtsig_t *nrt_sig)
Trigger non-real-time signal.
Definition: drvlib.c:1571
int xnsynch_destroy(struct xnsynch *synch)
Destroy a synchronization object.
Definition: synch.c:117
static struct xnthread * xnthread_current(void)
Retrieve the current Cobalt core TCB.
Definition: thread.h:371
int rtdm_irq_enable(rtdm_irq_t *irq_handle)
Enable interrupt line.
static bool rtdm_fd_is_user(struct rtdm_fd *fd)
Tell whether the passed file descriptor belongs to an application.
Definition: driver.h:189
#define spltest()
Test hard interrupt state on the local processor.
Definition: lock.h:64
void rtdm_waitqueue_destroy(struct rtdm_waitqueue *wq)
Deletes a RTDM wait queue.
const char * label
Device label template for composing the device name.
Definition: driver.h:354
RTDM state management handlers.
Definition: driver.h:236
int rtdm_event_select(rtdm_event_t *event, rtdm_selector_t *selector, enum rtdm_selecttype type, unsigned int fd_index)
Bind a selector to an event.
Definition: drvlib.c:965
int xnthread_wait_period(unsigned long *overruns_r)
Wait for the next periodic release point.
Definition: thread.c:1365
uint64_t nanosecs_abs_t
RTDM type for representing absolute dates.
Definition: rtdm.h:43
int rtdm_copy_from_user(struct rtdm_fd *fd, void *dst, const void __user *src, size_t size)
Copy user-space memory block to specified buffer.
void rtdm_dev_unregister(struct rtdm_device *device)
Unregister a RTDM device.
Definition: device.c:534
void rtdm_timer_stop(rtdm_timer_t *timer)
Stop a timer.
Definition: drvlib.c:578
int xntimer_start(struct xntimer *timer, xnticks_t value, xnticks_t interval, xntmode_t mode)
Arm a timer.
Definition: timer.c:113
static void rtdm_lock_init(rtdm_lock_t *lock)
Dynamic lock initialisation.
Definition: driver.h:563
int rtdm_irq_disable(rtdm_irq_t *irq_handle)
Disable interrupt line.
rtdm_selecttype
Definition: driver.h:111
int rtdm_copy_to_user(struct rtdm_fd *fd, void __user *dst, const void *src, size_t size)
Copy specified buffer to user-space memory block.
void rtdm_event_destroy(rtdm_event_t *event)
Destroy an event.
Definition: drvlib.c:747
int rtdm_task_wait_period(unsigned long *overruns_r)
Wait on next real-time task period.
void rtdm_sem_init(rtdm_sem_t *sem, unsigned long value)
Initialise a semaphore.
Definition: drvlib.c:1006
Select input data availability events.
Definition: driver.h:113
nanosecs_abs_t rtdm_clock_read(void)
Get system time.
int xnthread_set_periodic(struct xnthread *thread, xnticks_t idate, xntmode_t timeout_mode, xnticks_t period)
Make a thread periodic.
Definition: thread.c:1280
int device_flags
Device flags, see Device Flags for details.
Definition: driver.h:260
struct rtdm_driver * driver
Device driver.
Definition: driver.h:340
int rtdm_task_unblock(rtdm_task_t *task)
Activate a blocked real-time task.
struct rtdm_device * device
Set of active device operation handlers.
Definition: driver.h:141
void rtdm_event_signal(rtdm_event_t *event)
Signal an event occurrence.
Definition: drvlib.c:784
int __must_check xnsynch_sleep_on(struct xnsynch *synch, xnticks_t timeout, xntmode_t timeout_mode)
Sleep on an ownerless synchronization object.
Definition: synch.c:162
void rtdm_mutex_init(rtdm_mutex_t *mutex)
Initialise a mutex.
Definition: drvlib.c:1242
nanosecs_abs_t rtdm_clock_read_monotonic(void)
Get monotonic time.
int rtdm_rt_capable(struct rtdm_fd *fd)
Test if the caller is capable of running in real-time context.
#define XNBREAK
Forcibly awaken from a wait state.
Definition: thread.h:68
Copyright © 2011 Gilles Chanteperdrix gilles.chanteperdrix@xenomai.org.
Definition: atomic.h:24
int rtdm_task_sleep_until(nanosecs_abs_t wakeup_time)
Sleep until a specified absolute time.
int rtdm_safe_copy_to_user(struct rtdm_fd *fd, void __user *dst, const void *src, size_t size)
Check if read/write access to user-space memory block is safe and copy specified buffer to it...
static void xntimer_stop(struct xntimer *timer)
Disarm a timer.
Definition: timer.h:472
int rtdm_irq_free(rtdm_irq_t *irq_handle)
Release an interrupt handler.
int xnthread_unblock(struct xnthread *thread)
Unblock a thread.
Definition: thread.c:1189
int base_minor
Base minor for named devices.
Definition: driver.h:284
int device_count
Count of devices this driver manages.
Definition: driver.h:282
void rtdm_event_init(rtdm_event_t *event, unsigned long pending)
Initialise an event.
Definition: drvlib.c:721
void rtdm_free(void *ptr)
Release real-time memory block.
int rtdm_mmap_vmem(struct vm_area_struct *vma, void *va)
Map a virtual memory range to a virtual user area.
Definition: drvlib.c:2051
int rtdm_wait_is_completed(struct rtdm_wait_context *wc)
Test completion of a wait context.
int xnthread_join(struct xnthread *thread, bool uninterruptible)
Join with a terminated thread.
Definition: thread.c:1629
int rtdm_in_rt_context(void)
Test if running in a real-time task.
int rtdm_task_should_stop(void)
Check for pending termination request.
rtdm_timer_mode
Definition: driver.h:945
int rtdm_task_set_period(rtdm_task_t *task, nanosecs_abs_t start_date, nanosecs_rel_t period)
Adjust real-time task period.
int rtdm_timer_start_in_handler(rtdm_timer_t *timer, nanosecs_abs_t expiry, nanosecs_rel_t interval, enum rtdm_timer_mode mode)
Start a timer from inside a timer handler.
void rtdm_task_set_priority(rtdm_task_t *task, int priority)
Adjust real-time task priority.
void rtdm_schedule_nrt_work(struct work_struct *lostage_work)
Put a work task in Linux non real-time global workqueue from primary mode.
Definition: drvlib.c:1602
void rtdm_waitqueue_init(struct rtdm_waitqueue *wq)
Initialize a RTDM wait queue.
int rtdm_event_timedwait(rtdm_event_t *event, nanosecs_rel_t timeout, rtdm_toseq_t *timeout_seq)
Wait on event occurrence with timeout.
Definition: drvlib.c:864
void rtdm_task_destroy(rtdm_task_t *task)
Destroy a real-time task.
int rtdm_mutex_timedlock(rtdm_mutex_t *mutex, nanosecs_rel_t timeout, rtdm_toseq_t *timeout_seq)
Request a mutex with timeout.
Definition: drvlib.c:1342
#define XNRMID
Pending on a removed resource.
Definition: thread.h:67
int protocol_family
Protocol device identification: protocol family (PF_xxx)
Definition: driver.h:271
int rtdm_mmap_to_user(struct rtdm_fd *fd, void *src_addr, size_t len, int prot, void **pptr, struct vm_operations_struct *vm_ops, void *vm_private_data)
Map a kernel memory range into the address space of the user.
Definition: drvlib.c:1913
Device context.
Definition: driver.h:136
static int xnsched_run(void)
The rescheduling procedure.
Definition: sched.h:329
void rtdm_sem_destroy(rtdm_sem_t *sem)
Destroy a semaphore.
Definition: drvlib.c:1031
void rtdm_sem_up(rtdm_sem_t *sem)
Increment a semaphore.
Definition: drvlib.c:1156
Monotonic timer with relative timeout.
Definition: driver.h:947
int rtdm_iomap_to_user(struct rtdm_fd *fd, phys_addr_t src_addr, size_t len, int prot, void **pptr, struct vm_operations_struct *vm_ops, void *vm_private_data)
Map an I/O memory range into the address space of the user.
Definition: drvlib.c:1982
void rtdm_wait_complete(struct rtdm_wait_context *wc)
Mark completion for a wait context.
#define RTDM_MAX_MINOR
Maximum number of named devices per driver.
Definition: driver.h:97
struct rtdm_sm_ops smops
State management handlers.
Definition: driver.h:277
RTDM device.
Definition: driver.h:338
void(* rtdm_timer_handler_t)(rtdm_timer_t *timer)
Timer handler.
Definition: driver.h:938
int rtdm_mmap_kmem(struct vm_area_struct *vma, void *va)
Map a kernel logical memory range to a virtual user area.
Definition: drvlib.c:2026
int minor
Minor number of the device.
Definition: driver.h:369
int xnthread_set_schedparam(struct xnthread *thread, struct xnsched_class *sched_class, const union xnsched_policy_param *sched_param)
Change the base scheduling parameters of a thread.
Definition: thread.c:1803
static struct rtdm_fd * rtdm_private_to_fd(void *dev_private)
Locate a device file descriptor structure from its driver private area.
Definition: driver.h:174
int rtdm_sem_down(rtdm_sem_t *sem)
Decrement a semaphore.
Definition: drvlib.c:1059
int rtdm_task_init(rtdm_task_t *task, const char *name, rtdm_task_proc_t task_proc, void *arg, int priority, nanosecs_rel_t period)
Initialise and start a real-time task.
Definition: drvlib.c:108
unsigned long rtdm_lockctx_t
Variable to save the context while holding a lock.
Definition: driver.h:554
void rtdm_event_clear(rtdm_event_t *event)
Clear event state.
Definition: drvlib.c:927
int rtdm_read_user_ok(struct rtdm_fd *fd, const void __user *ptr, size_t size)
Check if read access to user-space memory block is safe.
RTDM driver.
Definition: driver.h:249
int rtdm_mmap_iomem(struct vm_area_struct *vma, phys_addr_t pa)
Map an I/O memory range to a virtual user area.
Definition: drvlib.c:2079
int(* stop)(struct rtdm_driver *drv)
Handler called upon transition to COBALT_STATE_TEARDOWN.
Definition: driver.h:240
static void rtdm_lock_get(rtdm_lock_t *lock)
Acquire lock from non-preemptible contexts.
Definition: driver.h:575
void rtdm_nrtsig_destroy(rtdm_nrtsig_t *nrt_sig)
Release a non-realtime signal handler.
int rtdm_safe_copy_from_user(struct rtdm_fd *fd, void *dst, const void __user *src, size_t size)
Check if read access to user-space memory block and copy it to specified buffer.