1/* iig(DriverKit-286 Mar 29 2024 10:27:09) generated from IOInterruptDispatchSource.iig */
2
3#undef IIG_IMPLEMENTATION
4#define IIG_IMPLEMENTATION IOInterruptDispatchSource.iig
5
6#if KERNEL
7#include <libkern/c++/OSString.h>
8#else
9#include <DriverKit/DriverKit.h>
10#endif /* KERNEL */
11#include <DriverKit/IOReturn.h>
12#include <DriverKit/IOInterruptDispatchSource.h>
13
14
15#if __has_builtin(__builtin_load_member_function_pointer)
16#define SimpleMemberFunctionCast(cfnty, self, func) (cfnty)__builtin_load_member_function_pointer(self, func)
17#else
18#define SimpleMemberFunctionCast(cfnty, self, func) ({ union { typeof(func) memfun; cfnty cfun; } pair; pair.memfun = func; pair.cfun; })
19#endif
20
21
22struct IOInterruptDispatchSource_Create_Msg_Content
23{
24 IORPCMessage __hdr;
25 OSObjectRef __object;
26 OSObjectRef provider;
27 OSObjectRef queue;
28 uint32_t index;
29};
30#pragma pack(4)
31struct IOInterruptDispatchSource_Create_Msg
32{
33 IORPCMessageMach mach;
34 mach_msg_port_descriptor_t __object__descriptor;
35 mach_msg_port_descriptor_t provider__descriptor;
36 mach_msg_port_descriptor_t queue__descriptor;
37 IOInterruptDispatchSource_Create_Msg_Content content;
38};
39#pragma pack()
40#define IOInterruptDispatchSource_Create_Msg_ObjRefs (3)
41
42struct IOInterruptDispatchSource_Create_Rpl_Content
43{
44 IORPCMessage __hdr;
45 OSObjectRef source;
46};
47#pragma pack(4)
48struct IOInterruptDispatchSource_Create_Rpl
49{
50 IORPCMessageMach mach;
51 mach_msg_port_descriptor_t source__descriptor;
52 IOInterruptDispatchSource_Create_Rpl_Content content;
53};
54#pragma pack()
55#define IOInterruptDispatchSource_Create_Rpl_ObjRefs (1)
56
57
58typedef union
59{
60 const IORPC rpc;
61 struct
62 {
63 const struct IOInterruptDispatchSource_Create_Msg * message;
64 struct IOInterruptDispatchSource_Create_Rpl * reply;
65 uint32_t sendSize;
66 uint32_t replySize;
67 };
68}
69IOInterruptDispatchSource_Create_Invocation;
70struct IOInterruptDispatchSource_GetInterruptType_Msg_Content
71{
72 IORPCMessage __hdr;
73 OSObjectRef __object;
74 OSObjectRef provider;
75 uint32_t index;
76};
77#pragma pack(4)
78struct IOInterruptDispatchSource_GetInterruptType_Msg
79{
80 IORPCMessageMach mach;
81 mach_msg_port_descriptor_t __object__descriptor;
82 mach_msg_port_descriptor_t provider__descriptor;
83 IOInterruptDispatchSource_GetInterruptType_Msg_Content content;
84};
85#pragma pack()
86#define IOInterruptDispatchSource_GetInterruptType_Msg_ObjRefs (2)
87
88struct IOInterruptDispatchSource_GetInterruptType_Rpl_Content
89{
90 IORPCMessage __hdr;
91 unsigned long long interruptType;
92};
93#pragma pack(4)
94struct IOInterruptDispatchSource_GetInterruptType_Rpl
95{
96 IORPCMessageMach mach;
97 IOInterruptDispatchSource_GetInterruptType_Rpl_Content content;
98};
99#pragma pack()
100#define IOInterruptDispatchSource_GetInterruptType_Rpl_ObjRefs (0)
101
102
103typedef union
104{
105 const IORPC rpc;
106 struct
107 {
108 const struct IOInterruptDispatchSource_GetInterruptType_Msg * message;
109 struct IOInterruptDispatchSource_GetInterruptType_Rpl * reply;
110 uint32_t sendSize;
111 uint32_t replySize;
112 };
113}
114IOInterruptDispatchSource_GetInterruptType_Invocation;
115struct IOInterruptDispatchSource_SetHandler_Msg_Content
116{
117 IORPCMessage __hdr;
118 OSObjectRef __object;
119 OSObjectRef action;
120};
121#pragma pack(4)
122struct IOInterruptDispatchSource_SetHandler_Msg
123{
124 IORPCMessageMach mach;
125 mach_msg_port_descriptor_t __object__descriptor;
126 mach_msg_port_descriptor_t action__descriptor;
127 IOInterruptDispatchSource_SetHandler_Msg_Content content;
128};
129#pragma pack()
130#define IOInterruptDispatchSource_SetHandler_Msg_ObjRefs (2)
131
132struct IOInterruptDispatchSource_SetHandler_Rpl_Content
133{
134 IORPCMessage __hdr;
135};
136#pragma pack(4)
137struct IOInterruptDispatchSource_SetHandler_Rpl
138{
139 IORPCMessageMach mach;
140 IOInterruptDispatchSource_SetHandler_Rpl_Content content;
141};
142#pragma pack()
143#define IOInterruptDispatchSource_SetHandler_Rpl_ObjRefs (0)
144
145
146typedef union
147{
148 const IORPC rpc;
149 struct
150 {
151 const struct IOInterruptDispatchSource_SetHandler_Msg * message;
152 struct IOInterruptDispatchSource_SetHandler_Rpl * reply;
153 uint32_t sendSize;
154 uint32_t replySize;
155 };
156}
157IOInterruptDispatchSource_SetHandler_Invocation;
158struct IOInterruptDispatchSource_GetLastInterrupt_Msg_Content
159{
160 IORPCMessage __hdr;
161 OSObjectRef __object;
162};
163#pragma pack(4)
164struct IOInterruptDispatchSource_GetLastInterrupt_Msg
165{
166 IORPCMessageMach mach;
167 mach_msg_port_descriptor_t __object__descriptor;
168 IOInterruptDispatchSource_GetLastInterrupt_Msg_Content content;
169};
170#pragma pack()
171#define IOInterruptDispatchSource_GetLastInterrupt_Msg_ObjRefs (1)
172
173struct IOInterruptDispatchSource_GetLastInterrupt_Rpl_Content
174{
175 IORPCMessage __hdr;
176 unsigned long long count;
177 unsigned long long time;
178};
179#pragma pack(4)
180struct IOInterruptDispatchSource_GetLastInterrupt_Rpl
181{
182 IORPCMessageMach mach;
183 IOInterruptDispatchSource_GetLastInterrupt_Rpl_Content content;
184};
185#pragma pack()
186#define IOInterruptDispatchSource_GetLastInterrupt_Rpl_ObjRefs (0)
187
188
189typedef union
190{
191 const IORPC rpc;
192 struct
193 {
194 const struct IOInterruptDispatchSource_GetLastInterrupt_Msg * message;
195 struct IOInterruptDispatchSource_GetLastInterrupt_Rpl * reply;
196 uint32_t sendSize;
197 uint32_t replySize;
198 };
199}
200IOInterruptDispatchSource_GetLastInterrupt_Invocation;
201struct IOInterruptDispatchSource_InterruptOccurred_Msg_Content
202{
203 IORPCMessage __hdr;
204 OSObjectRef __object;
205 OSObjectRef action;
206 uint64_t count;
207 uint64_t time;
208};
209#pragma pack(4)
210struct IOInterruptDispatchSource_InterruptOccurred_Msg
211{
212 IORPCMessageMach mach;
213 mach_msg_port_descriptor_t __object__descriptor;
214 mach_msg_port_descriptor_t action__descriptor;
215 IOInterruptDispatchSource_InterruptOccurred_Msg_Content content;
216};
217#pragma pack()
218#define IOInterruptDispatchSource_InterruptOccurred_Msg_ObjRefs (2)
219
220struct IOInterruptDispatchSource_InterruptOccurred_Rpl_Content
221{
222 IORPCMessage __hdr;
223};
224#pragma pack(4)
225struct IOInterruptDispatchSource_InterruptOccurred_Rpl
226{
227 IORPCMessageMach mach;
228 IOInterruptDispatchSource_InterruptOccurred_Rpl_Content content;
229};
230#pragma pack()
231#define IOInterruptDispatchSource_InterruptOccurred_Rpl_ObjRefs (0)
232
233
234typedef union
235{
236 const IORPC rpc;
237 struct
238 {
239 const struct IOInterruptDispatchSource_InterruptOccurred_Msg * message;
240 struct IOInterruptDispatchSource_InterruptOccurred_Rpl * reply;
241 uint32_t sendSize;
242 uint32_t replySize;
243 };
244}
245IOInterruptDispatchSource_InterruptOccurred_Invocation;
246#if !KERNEL
247extern OSMetaClass * gOSContainerMetaClass;
248extern OSMetaClass * gOSDataMetaClass;
249extern OSMetaClass * gOSNumberMetaClass;
250extern OSMetaClass * gOSBooleanMetaClass;
251extern OSMetaClass * gOSDictionaryMetaClass;
252extern OSMetaClass * gOSArrayMetaClass;
253extern OSMetaClass * gOSSetMetaClass;
254extern OSMetaClass * gOSOrderedSetMetaClass;
255extern OSMetaClass * gOSStringMetaClass;
256extern OSMetaClass * gIOMemoryDescriptorMetaClass;
257extern OSMetaClass * gIOBufferMemoryDescriptorMetaClass;
258extern OSMetaClass * gIOUserClientMetaClass;
259extern OSMetaClass * gIOServiceStateNotificationDispatchSourceMetaClass;
260#endif /* !KERNEL */
261
262#if KERNEL
263OSDefineMetaClassAndStructors(IOInterruptDispatchSource, IODispatchSource);
264#endif /* KERNEL */
265
266#if !KERNEL
267
268#define IOInterruptDispatchSource_QueueNames ""
269
270#define IOInterruptDispatchSource_MethodNames ""
271
272#define IOInterruptDispatchSourceMetaClass_MethodNames ""
273
274struct OSClassDescription_IOInterruptDispatchSource_t
275{
276 OSClassDescription base;
277 uint64_t methodOptions[2 * 0];
278 uint64_t metaMethodOptions[2 * 0];
279 char queueNames[sizeof(IOInterruptDispatchSource_QueueNames)];
280 char methodNames[sizeof(IOInterruptDispatchSource_MethodNames)];
281 char metaMethodNames[sizeof(IOInterruptDispatchSourceMetaClass_MethodNames)];
282};
283
284const struct OSClassDescription_IOInterruptDispatchSource_t
285OSClassDescription_IOInterruptDispatchSource =
286{
287 .base =
288 {
289 .descriptionSize = sizeof(OSClassDescription_IOInterruptDispatchSource_t),
290 .name = "IOInterruptDispatchSource",
291 .superName = "IODispatchSource",
292 .methodOptionsSize = 2 * sizeof(uint64_t) * 0,
293 .methodOptionsOffset = __builtin_offsetof(struct OSClassDescription_IOInterruptDispatchSource_t, methodOptions),
294 .metaMethodOptionsSize = 2 * sizeof(uint64_t) * 0,
295 .metaMethodOptionsOffset = __builtin_offsetof(struct OSClassDescription_IOInterruptDispatchSource_t, metaMethodOptions),
296 .queueNamesSize = sizeof(IOInterruptDispatchSource_QueueNames),
297 .queueNamesOffset = __builtin_offsetof(struct OSClassDescription_IOInterruptDispatchSource_t, queueNames),
298 .methodNamesSize = sizeof(IOInterruptDispatchSource_MethodNames),
299 .methodNamesOffset = __builtin_offsetof(struct OSClassDescription_IOInterruptDispatchSource_t, methodNames),
300 .metaMethodNamesSize = sizeof(IOInterruptDispatchSourceMetaClass_MethodNames),
301 .metaMethodNamesOffset = __builtin_offsetof(struct OSClassDescription_IOInterruptDispatchSource_t, metaMethodNames),
302 .flags = 1*kOSClassCanRemote,
303 },
304 .methodOptions =
305 {
306 },
307 .metaMethodOptions =
308 {
309 },
310 .queueNames = IOInterruptDispatchSource_QueueNames,
311 .methodNames = IOInterruptDispatchSource_MethodNames,
312 .metaMethodNames = IOInterruptDispatchSourceMetaClass_MethodNames,
313};
314
315OSMetaClass * gIOInterruptDispatchSourceMetaClass;
316
317static kern_return_t
318IOInterruptDispatchSource_New(OSMetaClass * instance);
319
320const OSClassLoadInformation
321IOInterruptDispatchSource_Class =
322{
323 .description = &OSClassDescription_IOInterruptDispatchSource.base,
324 .metaPointer = &gIOInterruptDispatchSourceMetaClass,
325 .version = 1,
326 .instanceSize = sizeof(IOInterruptDispatchSource),
327
328 .New = &IOInterruptDispatchSource_New,
329};
330
331extern const void * const
332gIOInterruptDispatchSource_Declaration;
333const void * const
334gIOInterruptDispatchSource_Declaration
335__attribute__((visibility("hidden"),section("__DATA_CONST,__osclassinfo,regular,no_dead_strip"),no_sanitize("address")))
336 = &IOInterruptDispatchSource_Class;
337
338static kern_return_t
339IOInterruptDispatchSource_New(OSMetaClass * instance)
340{
341 if (!new(instance) IOInterruptDispatchSourceMetaClass) return (kIOReturnNoMemory);
342 return (kIOReturnSuccess);
343}
344
345kern_return_t
346IOInterruptDispatchSourceMetaClass::New(OSObject * instance)
347{
348 if (!new(instance) IOInterruptDispatchSource) return (kIOReturnNoMemory);
349 return (kIOReturnSuccess);
350}
351
352#endif /* !KERNEL */
353
354kern_return_t
355IOInterruptDispatchSource::Dispatch(const IORPC rpc)
356{
357 return _Dispatch(self: this, rpc);
358}
359
360kern_return_t
361IOInterruptDispatchSource::_Dispatch(IOInterruptDispatchSource * self, const IORPC rpc)
362{
363 kern_return_t ret = kIOReturnUnsupported;
364 IORPCMessage * msg = IORPCMessageFromMach(msg: rpc.message, reply: false);
365
366 switch (msg->msgid)
367 {
368 case IOInterruptDispatchSource_SetHandler_ID:
369 {
370 ret = IOInterruptDispatchSource::SetHandler_Invoke(rpc, target: self, SimpleMemberFunctionCast(IOInterruptDispatchSource::SetHandler_Handler, *self, &IOInterruptDispatchSource::SetHandler_Impl));
371 break;
372 }
373 case IODispatchSource_SetEnableWithCompletion_ID:
374 {
375 ret = IODispatchSource::SetEnableWithCompletion_Invoke(rpc, target: self, SimpleMemberFunctionCast(IODispatchSource::SetEnableWithCompletion_Handler, *self, &IOInterruptDispatchSource::SetEnableWithCompletion_Impl));
376 break;
377 }
378 case IODispatchSource_Cancel_ID:
379 {
380 ret = IODispatchSource::Cancel_Invoke(rpc, target: self, SimpleMemberFunctionCast(IODispatchSource::Cancel_Handler, *self, &IOInterruptDispatchSource::Cancel_Impl));
381 break;
382 }
383#if KERNEL
384 case IOInterruptDispatchSource_GetLastInterrupt_ID:
385 {
386 ret = IOInterruptDispatchSource::GetLastInterrupt_Invoke(rpc, target: self, SimpleMemberFunctionCast(IOInterruptDispatchSource::GetLastInterrupt_Handler, *self, &IOInterruptDispatchSource::GetLastInterrupt_Impl));
387 break;
388 }
389#endif /* !KERNEL */
390 case IODispatchSource_CheckForWork_ID:
391 {
392 ret = IODispatchSource::CheckForWork_Invoke(rpc, target: self, SimpleMemberFunctionCast(IODispatchSource::CheckForWork_Handler, *self, &IOInterruptDispatchSource::CheckForWork_Impl));
393 break;
394 }
395 case IOInterruptDispatchSource_InterruptOccurred_ID:
396 {
397 ret = IOInterruptDispatchSource::InterruptOccurred_Invoke(rpc, target: self, SimpleMemberFunctionCast(IOInterruptDispatchSource::InterruptOccurred_Handler, *self, &IOInterruptDispatchSource::InterruptOccurred_Impl));
398 break;
399 }
400
401 default:
402 ret = IODispatchSource::_Dispatch(self, rpc);
403 break;
404 }
405
406 return (ret);
407}
408
409#if KERNEL
410kern_return_t
411IOInterruptDispatchSource::MetaClass::Dispatch(const IORPC rpc)
412{
413#else /* KERNEL */
414kern_return_t
415IOInterruptDispatchSourceMetaClass::Dispatch(const IORPC rpc)
416{
417#endif /* !KERNEL */
418
419 kern_return_t ret = kIOReturnUnsupported;
420 IORPCMessage * msg = IORPCMessageFromMach(msg: rpc.message, reply: false);
421
422 switch (msg->msgid)
423 {
424#if KERNEL
425 case IOInterruptDispatchSource_Create_ID:
426 ret = IOInterruptDispatchSource::Create_Invoke(rpc, func: &IOInterruptDispatchSource::Create_Impl);
427 break;
428#endif /* !KERNEL */
429#if KERNEL
430 case IOInterruptDispatchSource_GetInterruptType_ID:
431 ret = IOInterruptDispatchSource::GetInterruptType_Invoke(rpc, func: &IOInterruptDispatchSource::GetInterruptType_Impl);
432 break;
433#endif /* !KERNEL */
434
435 default:
436 ret = OSMetaClassBase::Dispatch(rpc);
437 break;
438 }
439
440 return (ret);
441}
442
443kern_return_t
444IOInterruptDispatchSource::Create_Call(
445 IOService * provider,
446 uint32_t index,
447 IODispatchQueue * queue,
448 IOInterruptDispatchSource ** source)
449{
450 kern_return_t ret;
451 union
452 {
453 IOInterruptDispatchSource_Create_Msg msg;
454 struct
455 {
456 IOInterruptDispatchSource_Create_Rpl rpl;
457 mach_msg_max_trailer_t trailer;
458 } rpl;
459 } buf;
460 struct IOInterruptDispatchSource_Create_Msg * msg = &buf.msg;
461 struct IOInterruptDispatchSource_Create_Rpl * rpl = &buf.rpl.rpl;
462
463 memset(s: msg, c: 0, n: sizeof(struct IOInterruptDispatchSource_Create_Msg));
464 msg->mach.msgh.msgh_id = kIORPCVersion190615;
465 msg->mach.msgh.msgh_size = sizeof(*msg);
466 msg->content.__hdr.flags = 0*kIORPCMessageOneway
467 | 0*kIORPCMessageSimpleReply
468 | 0*kIORPCMessageLocalHost
469 | 0*kIORPCMessageOnqueue;
470 msg->content.__hdr.msgid = IOInterruptDispatchSource_Create_ID;
471 msg->content.__object = (OSObjectRef) OSTypeID(IOInterruptDispatchSource);
472 msg->content.__hdr.objectRefs = IOInterruptDispatchSource_Create_Msg_ObjRefs;
473 msg->mach.msgh_body.msgh_descriptor_count = 3;
474
475 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
476
477 msg->provider__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
478 msg->content.provider = (OSObjectRef) provider;
479
480 msg->content.index = index;
481
482 msg->queue__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
483 msg->content.queue = (OSObjectRef) queue;
484
485 IORPC rpc = { .message = &buf.msg.mach, .reply = &buf.rpl.rpl.mach, .sendSize = sizeof(buf.msg), .replySize = sizeof(buf.rpl) };
486 ret = OSMTypeID(IOInterruptDispatchSource)->Invoke(rpc);
487
488 if (kIOReturnSuccess == ret)
489 do {
490 {
491 if (rpl->mach.msgh.msgh_size != sizeof(*rpl)) { ret = kIOReturnIPCError; break; };
492 if (rpl->content.__hdr.msgid != IOInterruptDispatchSource_Create_ID) { ret = kIOReturnIPCError; break; };
493 if (rpl->mach.msgh_body.msgh_descriptor_count != 1) { ret = kIOReturnIPCError; break; };
494 if (IOInterruptDispatchSource_Create_Rpl_ObjRefs != rpl->content.__hdr.objectRefs) { ret = kIOReturnIPCError; break; };
495 }
496 }
497 while (false);
498 if (kIOReturnSuccess == ret)
499 {
500 *source = OSDynamicCast(IOInterruptDispatchSource, (OSObject *) rpl->content.source);
501 if (rpl->content.source && !*source) ret = kIOReturnBadArgument;
502 }
503
504
505 return (ret);
506}
507
508kern_return_t
509IOInterruptDispatchSource::GetInterruptType(
510 IOService * provider,
511 uint32_t index,
512 uint64_t * interruptType)
513{
514 kern_return_t ret;
515 union
516 {
517 IOInterruptDispatchSource_GetInterruptType_Msg msg;
518 struct
519 {
520 IOInterruptDispatchSource_GetInterruptType_Rpl rpl;
521 mach_msg_max_trailer_t trailer;
522 } rpl;
523 } buf;
524 struct IOInterruptDispatchSource_GetInterruptType_Msg * msg = &buf.msg;
525 struct IOInterruptDispatchSource_GetInterruptType_Rpl * rpl = &buf.rpl.rpl;
526
527 memset(s: msg, c: 0, n: sizeof(struct IOInterruptDispatchSource_GetInterruptType_Msg));
528 msg->mach.msgh.msgh_id = kIORPCVersion190615;
529 msg->mach.msgh.msgh_size = sizeof(*msg);
530 msg->content.__hdr.flags = 0*kIORPCMessageOneway
531 | 1*kIORPCMessageSimpleReply
532 | 0*kIORPCMessageLocalHost
533 | 0*kIORPCMessageOnqueue;
534 msg->content.__hdr.msgid = IOInterruptDispatchSource_GetInterruptType_ID;
535 msg->content.__object = (OSObjectRef) OSTypeID(IOInterruptDispatchSource);
536 msg->content.__hdr.objectRefs = IOInterruptDispatchSource_GetInterruptType_Msg_ObjRefs;
537 msg->mach.msgh_body.msgh_descriptor_count = 2;
538
539 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
540
541 msg->provider__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
542 msg->content.provider = (OSObjectRef) provider;
543
544 msg->content.index = index;
545
546 IORPC rpc = { .message = &buf.msg.mach, .reply = &buf.rpl.rpl.mach, .sendSize = sizeof(buf.msg), .replySize = sizeof(buf.rpl) };
547 ret = OSMTypeID(IOInterruptDispatchSource)->Invoke(rpc);
548
549 if (kIOReturnSuccess == ret)
550 do {
551 {
552 if (rpl->mach.msgh.msgh_size != sizeof(*rpl)) { ret = kIOReturnIPCError; break; };
553 if (rpl->content.__hdr.msgid != IOInterruptDispatchSource_GetInterruptType_ID) { ret = kIOReturnIPCError; break; };
554 if (rpl->mach.msgh_body.msgh_descriptor_count != 0) { ret = kIOReturnIPCError; break; };
555 if (IOInterruptDispatchSource_GetInterruptType_Rpl_ObjRefs != rpl->content.__hdr.objectRefs) { ret = kIOReturnIPCError; break; };
556 }
557 }
558 while (false);
559 if (kIOReturnSuccess == ret)
560 {
561 if (interruptType) *interruptType = rpl->content.interruptType;
562 }
563
564
565 return (ret);
566}
567
568kern_return_t
569IOInterruptDispatchSource::SetHandler(
570 OSAction * action,
571 OSDispatchMethod supermethod)
572{
573 kern_return_t ret;
574 union
575 {
576 IOInterruptDispatchSource_SetHandler_Msg msg;
577 struct
578 {
579 IOInterruptDispatchSource_SetHandler_Rpl rpl;
580 mach_msg_max_trailer_t trailer;
581 } rpl;
582 } buf;
583 struct IOInterruptDispatchSource_SetHandler_Msg * msg = &buf.msg;
584 struct IOInterruptDispatchSource_SetHandler_Rpl * rpl = &buf.rpl.rpl;
585
586 memset(s: msg, c: 0, n: sizeof(struct IOInterruptDispatchSource_SetHandler_Msg));
587 msg->mach.msgh.msgh_id = kIORPCVersion190615;
588 msg->mach.msgh.msgh_size = sizeof(*msg);
589 msg->content.__hdr.flags = 0*kIORPCMessageOneway
590 | 1*kIORPCMessageSimpleReply
591 | 0*kIORPCMessageLocalHost
592 | 0*kIORPCMessageOnqueue;
593 msg->content.__hdr.msgid = IOInterruptDispatchSource_SetHandler_ID;
594 msg->content.__object = (OSObjectRef) this;
595 msg->content.__hdr.objectRefs = IOInterruptDispatchSource_SetHandler_Msg_ObjRefs;
596 msg->mach.msgh_body.msgh_descriptor_count = 2;
597
598 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
599
600 msg->action__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
601 msg->content.action = (OSObjectRef) action;
602
603 IORPC rpc = { .message = &buf.msg.mach, .reply = &buf.rpl.rpl.mach, .sendSize = sizeof(buf.msg), .replySize = sizeof(buf.rpl) };
604 if (supermethod) ret = supermethod((OSObject *)this, rpc);
605 else ret = ((OSObject *)this)->Invoke(rpc);
606
607 if (kIOReturnSuccess == ret)
608 do {
609 {
610 if (rpl->mach.msgh.msgh_size != sizeof(*rpl)) { ret = kIOReturnIPCError; break; };
611 if (rpl->content.__hdr.msgid != IOInterruptDispatchSource_SetHandler_ID) { ret = kIOReturnIPCError; break; };
612 if (rpl->mach.msgh_body.msgh_descriptor_count != 0) { ret = kIOReturnIPCError; break; };
613 if (IOInterruptDispatchSource_SetHandler_Rpl_ObjRefs != rpl->content.__hdr.objectRefs) { ret = kIOReturnIPCError; break; };
614 }
615 }
616 while (false);
617 if (kIOReturnSuccess == ret)
618 {
619 }
620
621
622 return (ret);
623}
624
625kern_return_t
626IOInterruptDispatchSource::GetLastInterrupt(
627 uint64_t * count,
628 uint64_t * time,
629 OSDispatchMethod supermethod)
630{
631 kern_return_t ret;
632 union
633 {
634 IOInterruptDispatchSource_GetLastInterrupt_Msg msg;
635 struct
636 {
637 IOInterruptDispatchSource_GetLastInterrupt_Rpl rpl;
638 mach_msg_max_trailer_t trailer;
639 } rpl;
640 } buf;
641 struct IOInterruptDispatchSource_GetLastInterrupt_Msg * msg = &buf.msg;
642 struct IOInterruptDispatchSource_GetLastInterrupt_Rpl * rpl = &buf.rpl.rpl;
643
644 memset(s: msg, c: 0, n: sizeof(struct IOInterruptDispatchSource_GetLastInterrupt_Msg));
645 msg->mach.msgh.msgh_id = kIORPCVersion190615;
646 msg->mach.msgh.msgh_size = sizeof(*msg);
647 msg->content.__hdr.flags = 0*kIORPCMessageOneway
648 | 1*kIORPCMessageSimpleReply
649 | 0*kIORPCMessageLocalHost
650 | 0*kIORPCMessageOnqueue;
651 msg->content.__hdr.msgid = IOInterruptDispatchSource_GetLastInterrupt_ID;
652 msg->content.__object = (OSObjectRef) this;
653 msg->content.__hdr.objectRefs = IOInterruptDispatchSource_GetLastInterrupt_Msg_ObjRefs;
654 msg->mach.msgh_body.msgh_descriptor_count = 1;
655
656 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
657
658 IORPC rpc = { .message = &buf.msg.mach, .reply = &buf.rpl.rpl.mach, .sendSize = sizeof(buf.msg), .replySize = sizeof(buf.rpl) };
659 if (supermethod) ret = supermethod((OSObject *)this, rpc);
660 else ret = ((OSObject *)this)->Invoke(rpc);
661
662 if (kIOReturnSuccess == ret)
663 do {
664 {
665 if (rpl->mach.msgh.msgh_size != sizeof(*rpl)) { ret = kIOReturnIPCError; break; };
666 if (rpl->content.__hdr.msgid != IOInterruptDispatchSource_GetLastInterrupt_ID) { ret = kIOReturnIPCError; break; };
667 if (rpl->mach.msgh_body.msgh_descriptor_count != 0) { ret = kIOReturnIPCError; break; };
668 if (IOInterruptDispatchSource_GetLastInterrupt_Rpl_ObjRefs != rpl->content.__hdr.objectRefs) { ret = kIOReturnIPCError; break; };
669 }
670 }
671 while (false);
672 if (kIOReturnSuccess == ret)
673 {
674 if (count) *count = rpl->content.count;
675 if (time) *time = rpl->content.time;
676 }
677
678
679 return (ret);
680}
681
682kern_return_t
683IOInterruptDispatchSource::InterruptOccurred(
684 IORPC rpc,
685 OSAction * action,
686 uint64_t count,
687 uint64_t time,
688 OSDispatchMethod supermethod)
689{
690 kern_return_t ret;
691 struct IOInterruptDispatchSource_InterruptOccurred_Msg * msg = (typeof(msg)) rpc.reply;
692
693
694 memset(s: msg, c: 0, n: sizeof(struct IOInterruptDispatchSource_InterruptOccurred_Msg));
695 msg->mach.msgh.msgh_id = kIORPCVersion190615;
696 msg->mach.msgh.msgh_size = sizeof(*msg);
697 msg->content.__hdr.flags = 1*kIORPCMessageOneway
698 | 1*kIORPCMessageSimpleReply
699 | 0*kIORPCMessageLocalHost
700 | 1*kIORPCMessageOnqueue;
701 msg->content.__hdr.msgid = IOInterruptDispatchSource_InterruptOccurred_ID;
702 msg->content.__object = (OSObjectRef) action;
703 msg->content.__hdr.objectRefs = IOInterruptDispatchSource_InterruptOccurred_Msg_ObjRefs;
704 msg->mach.msgh_body.msgh_descriptor_count = 2;
705
706 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
707
708 msg->action__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
709 msg->content.action = (OSObjectRef) action;
710
711 msg->content.count = count;
712
713 msg->content.time = time;
714
715
716 ret = kIOReturnSuccess;
717
718 return (ret);
719}
720
721kern_return_t
722IOInterruptDispatchSource::Create_Invoke(const IORPC _rpc,
723 Create_Handler func)
724{
725 IOInterruptDispatchSource_Create_Invocation rpc = { .rpc: _rpc };
726 kern_return_t ret;
727 IOService * provider;
728 IODispatchQueue * queue;
729
730 if (3 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
731 if (IOInterruptDispatchSource_Create_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
732 if (rpc.message != NULL && rpc.sendSize < sizeof(IOInterruptDispatchSource_Create_Msg)) return (kIOReturnIPCError);
733 if (rpc.reply != NULL && rpc.replySize < sizeof(IOInterruptDispatchSource_Create_Rpl)) return (kIOReturnIPCError);
734 provider = OSDynamicCast(IOService, (OSObject *) rpc.message->content.provider);
735 if (!provider && rpc.message->content.provider) return (kIOReturnBadArgument);
736 queue = OSDynamicCast(IODispatchQueue, (OSObject *) rpc.message->content.queue);
737 if (!queue && rpc.message->content.queue) return (kIOReturnBadArgument);
738
739 ret = (*func)( provider,
740 rpc.message->content.index,
741 queue,
742 (IOInterruptDispatchSource **)&rpc.reply->content.source);
743
744 if (kIOReturnSuccess != ret) return (ret);
745
746 rpc.reply->content.__hdr.msgid = IOInterruptDispatchSource_Create_ID;
747 rpc.reply->content.__hdr.flags = kIORPCMessageOneway;
748 rpc.reply->mach.msgh.msgh_id = kIORPCVersion190615Reply;
749 rpc.reply->mach.msgh.msgh_size = sizeof(*rpc.reply);
750 rpc.reply->mach.msgh_body.msgh_descriptor_count = 1;
751 rpc.reply->content.__hdr.objectRefs = IOInterruptDispatchSource_Create_Rpl_ObjRefs;
752 rpc.reply->source__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
753
754 return (ret);
755}
756
757kern_return_t
758IOInterruptDispatchSource::GetInterruptType_Invoke(const IORPC _rpc,
759 GetInterruptType_Handler func)
760{
761 IOInterruptDispatchSource_GetInterruptType_Invocation rpc = { .rpc: _rpc };
762 kern_return_t ret;
763 IOService * provider;
764
765 if (2 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
766 if (IOInterruptDispatchSource_GetInterruptType_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
767 if (rpc.message != NULL && rpc.sendSize < sizeof(IOInterruptDispatchSource_GetInterruptType_Msg)) return (kIOReturnIPCError);
768 if (rpc.reply != NULL && rpc.replySize < sizeof(IOInterruptDispatchSource_GetInterruptType_Rpl)) return (kIOReturnIPCError);
769 provider = OSDynamicCast(IOService, (OSObject *) rpc.message->content.provider);
770 if (!provider && rpc.message->content.provider) return (kIOReturnBadArgument);
771
772 ret = (*func)( provider,
773 rpc.message->content.index,
774 &rpc.reply->content.interruptType);
775
776 if (kIOReturnSuccess != ret) return (ret);
777
778 rpc.reply->content.__hdr.msgid = IOInterruptDispatchSource_GetInterruptType_ID;
779 rpc.reply->content.__hdr.flags = kIORPCMessageOneway;
780 rpc.reply->mach.msgh.msgh_id = kIORPCVersion190615Reply;
781 rpc.reply->mach.msgh.msgh_size = sizeof(*rpc.reply);
782 rpc.reply->mach.msgh_body.msgh_descriptor_count = 0;
783 rpc.reply->content.__hdr.objectRefs = IOInterruptDispatchSource_GetInterruptType_Rpl_ObjRefs;
784
785 return (ret);
786}
787
788kern_return_t
789IOInterruptDispatchSource::SetHandler_Invoke(const IORPC _rpc,
790 OSMetaClassBase * target,
791 SetHandler_Handler func)
792{
793 IOInterruptDispatchSource_SetHandler_Invocation rpc = { .rpc: _rpc };
794 kern_return_t ret;
795 OSAction * action;
796
797 if (2 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
798 if (IOInterruptDispatchSource_SetHandler_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
799 if (rpc.message != NULL && rpc.sendSize < sizeof(IOInterruptDispatchSource_SetHandler_Msg)) return (kIOReturnIPCError);
800 if (rpc.reply != NULL && rpc.replySize < sizeof(IOInterruptDispatchSource_SetHandler_Rpl)) return (kIOReturnIPCError);
801 action = OSDynamicCast(OSAction, (OSObject *) rpc.message->content.action);
802 if (!action && rpc.message->content.action) return (kIOReturnBadArgument);
803
804 ret = (*func)(target,
805 action);
806
807 if (kIOReturnSuccess != ret) return (ret);
808
809 rpc.reply->content.__hdr.msgid = IOInterruptDispatchSource_SetHandler_ID;
810 rpc.reply->content.__hdr.flags = kIORPCMessageOneway;
811 rpc.reply->mach.msgh.msgh_id = kIORPCVersion190615Reply;
812 rpc.reply->mach.msgh.msgh_size = sizeof(*rpc.reply);
813 rpc.reply->mach.msgh_body.msgh_descriptor_count = 0;
814 rpc.reply->content.__hdr.objectRefs = IOInterruptDispatchSource_SetHandler_Rpl_ObjRefs;
815
816 return (ret);
817}
818
819kern_return_t
820IOInterruptDispatchSource::GetLastInterrupt_Invoke(const IORPC _rpc,
821 OSMetaClassBase * target,
822 GetLastInterrupt_Handler func)
823{
824 IOInterruptDispatchSource_GetLastInterrupt_Invocation rpc = { .rpc: _rpc };
825 kern_return_t ret;
826
827 if (1 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
828 if (IOInterruptDispatchSource_GetLastInterrupt_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
829 if (rpc.message != NULL && rpc.sendSize < sizeof(IOInterruptDispatchSource_GetLastInterrupt_Msg)) return (kIOReturnIPCError);
830 if (rpc.reply != NULL && rpc.replySize < sizeof(IOInterruptDispatchSource_GetLastInterrupt_Rpl)) return (kIOReturnIPCError);
831
832 ret = (*func)(target,
833 &rpc.reply->content.count,
834 &rpc.reply->content.time);
835
836 if (kIOReturnSuccess != ret) return (ret);
837
838 rpc.reply->content.__hdr.msgid = IOInterruptDispatchSource_GetLastInterrupt_ID;
839 rpc.reply->content.__hdr.flags = kIORPCMessageOneway;
840 rpc.reply->mach.msgh.msgh_id = kIORPCVersion190615Reply;
841 rpc.reply->mach.msgh.msgh_size = sizeof(*rpc.reply);
842 rpc.reply->mach.msgh_body.msgh_descriptor_count = 0;
843 rpc.reply->content.__hdr.objectRefs = IOInterruptDispatchSource_GetLastInterrupt_Rpl_ObjRefs;
844
845 return (ret);
846}
847
848kern_return_t
849IOInterruptDispatchSource::InterruptOccurred_Invoke(const IORPC _rpc,
850 OSMetaClassBase * target,
851 InterruptOccurred_Handler func)
852{
853 return IOInterruptDispatchSource::InterruptOccurred_Invoke(rpc: _rpc, target, func, NULL);
854}
855
856kern_return_t
857IOInterruptDispatchSource::InterruptOccurred_Invoke(const IORPC _rpc,
858 OSMetaClassBase * target,
859 InterruptOccurred_Handler func,
860 const OSMetaClass * targetActionClass)
861{
862 IOInterruptDispatchSource_InterruptOccurred_Invocation rpc = { .rpc: _rpc };
863 OSAction * action;
864
865 if (2 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
866 if (IOInterruptDispatchSource_InterruptOccurred_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
867 if (rpc.message != NULL && rpc.sendSize < sizeof(IOInterruptDispatchSource_InterruptOccurred_Msg)) return (kIOReturnIPCError);
868 if (rpc.reply != NULL && rpc.replySize < sizeof(IOInterruptDispatchSource_InterruptOccurred_Rpl)) return (kIOReturnIPCError);
869 if (targetActionClass) {
870 action = (OSAction *) OSMetaClassBase::safeMetaCast(anObject: (OSObject *) rpc.message->content.action, toMeta: targetActionClass);
871 } else {
872 action = OSDynamicCast(OSAction, (OSObject *) rpc.message->content.action);
873 }
874 if (!action && rpc.message->content.action) return (kIOReturnBadArgument);
875
876 (*func)(target,
877 action,
878 rpc.message->content.count,
879 rpc.message->content.time);
880
881
882 return (kIOReturnSuccess);
883}
884
885
886
887