1/* iig(DriverKit-286 Mar 29 2024 10:27:09) generated from IODataQueueDispatchSource.iig */
2
3#undef IIG_IMPLEMENTATION
4#define IIG_IMPLEMENTATION IODataQueueDispatchSource.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/IODataQueueDispatchSource.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 IODataQueueDispatchSource_Create_Msg_Content
23{
24 IORPCMessage __hdr;
25 OSObjectRef __object;
26 OSObjectRef queue;
27 uint64_t queueByteCount;
28};
29#pragma pack(4)
30struct IODataQueueDispatchSource_Create_Msg
31{
32 IORPCMessageMach mach;
33 mach_msg_port_descriptor_t __object__descriptor;
34 mach_msg_port_descriptor_t queue__descriptor;
35 IODataQueueDispatchSource_Create_Msg_Content content;
36};
37#pragma pack()
38#define IODataQueueDispatchSource_Create_Msg_ObjRefs (2)
39
40struct IODataQueueDispatchSource_Create_Rpl_Content
41{
42 IORPCMessage __hdr;
43 OSObjectRef source;
44};
45#pragma pack(4)
46struct IODataQueueDispatchSource_Create_Rpl
47{
48 IORPCMessageMach mach;
49 mach_msg_port_descriptor_t source__descriptor;
50 IODataQueueDispatchSource_Create_Rpl_Content content;
51};
52#pragma pack()
53#define IODataQueueDispatchSource_Create_Rpl_ObjRefs (1)
54
55
56typedef union
57{
58 const IORPC rpc;
59 struct
60 {
61 const struct IODataQueueDispatchSource_Create_Msg * message;
62 struct IODataQueueDispatchSource_Create_Rpl * reply;
63 uint32_t sendSize;
64 uint32_t replySize;
65 };
66}
67IODataQueueDispatchSource_Create_Invocation;
68struct IODataQueueDispatchSource_SetDataAvailableHandler_Msg_Content
69{
70 IORPCMessage __hdr;
71 OSObjectRef __object;
72 OSObjectRef action;
73};
74#pragma pack(4)
75struct IODataQueueDispatchSource_SetDataAvailableHandler_Msg
76{
77 IORPCMessageMach mach;
78 mach_msg_port_descriptor_t __object__descriptor;
79 mach_msg_port_descriptor_t action__descriptor;
80 IODataQueueDispatchSource_SetDataAvailableHandler_Msg_Content content;
81};
82#pragma pack()
83#define IODataQueueDispatchSource_SetDataAvailableHandler_Msg_ObjRefs (2)
84
85struct IODataQueueDispatchSource_SetDataAvailableHandler_Rpl_Content
86{
87 IORPCMessage __hdr;
88};
89#pragma pack(4)
90struct IODataQueueDispatchSource_SetDataAvailableHandler_Rpl
91{
92 IORPCMessageMach mach;
93 IODataQueueDispatchSource_SetDataAvailableHandler_Rpl_Content content;
94};
95#pragma pack()
96#define IODataQueueDispatchSource_SetDataAvailableHandler_Rpl_ObjRefs (0)
97
98
99typedef union
100{
101 const IORPC rpc;
102 struct
103 {
104 const struct IODataQueueDispatchSource_SetDataAvailableHandler_Msg * message;
105 struct IODataQueueDispatchSource_SetDataAvailableHandler_Rpl * reply;
106 uint32_t sendSize;
107 uint32_t replySize;
108 };
109}
110IODataQueueDispatchSource_SetDataAvailableHandler_Invocation;
111struct IODataQueueDispatchSource_SetDataServicedHandler_Msg_Content
112{
113 IORPCMessage __hdr;
114 OSObjectRef __object;
115 OSObjectRef action;
116};
117#pragma pack(4)
118struct IODataQueueDispatchSource_SetDataServicedHandler_Msg
119{
120 IORPCMessageMach mach;
121 mach_msg_port_descriptor_t __object__descriptor;
122 mach_msg_port_descriptor_t action__descriptor;
123 IODataQueueDispatchSource_SetDataServicedHandler_Msg_Content content;
124};
125#pragma pack()
126#define IODataQueueDispatchSource_SetDataServicedHandler_Msg_ObjRefs (2)
127
128struct IODataQueueDispatchSource_SetDataServicedHandler_Rpl_Content
129{
130 IORPCMessage __hdr;
131};
132#pragma pack(4)
133struct IODataQueueDispatchSource_SetDataServicedHandler_Rpl
134{
135 IORPCMessageMach mach;
136 IODataQueueDispatchSource_SetDataServicedHandler_Rpl_Content content;
137};
138#pragma pack()
139#define IODataQueueDispatchSource_SetDataServicedHandler_Rpl_ObjRefs (0)
140
141
142typedef union
143{
144 const IORPC rpc;
145 struct
146 {
147 const struct IODataQueueDispatchSource_SetDataServicedHandler_Msg * message;
148 struct IODataQueueDispatchSource_SetDataServicedHandler_Rpl * reply;
149 uint32_t sendSize;
150 uint32_t replySize;
151 };
152}
153IODataQueueDispatchSource_SetDataServicedHandler_Invocation;
154struct IODataQueueDispatchSource_CopyMemory_Msg_Content
155{
156 IORPCMessage __hdr;
157 OSObjectRef __object;
158};
159#pragma pack(4)
160struct IODataQueueDispatchSource_CopyMemory_Msg
161{
162 IORPCMessageMach mach;
163 mach_msg_port_descriptor_t __object__descriptor;
164 IODataQueueDispatchSource_CopyMemory_Msg_Content content;
165};
166#pragma pack()
167#define IODataQueueDispatchSource_CopyMemory_Msg_ObjRefs (1)
168
169struct IODataQueueDispatchSource_CopyMemory_Rpl_Content
170{
171 IORPCMessage __hdr;
172 OSObjectRef memory;
173};
174#pragma pack(4)
175struct IODataQueueDispatchSource_CopyMemory_Rpl
176{
177 IORPCMessageMach mach;
178 mach_msg_port_descriptor_t memory__descriptor;
179 IODataQueueDispatchSource_CopyMemory_Rpl_Content content;
180};
181#pragma pack()
182#define IODataQueueDispatchSource_CopyMemory_Rpl_ObjRefs (1)
183
184
185typedef union
186{
187 const IORPC rpc;
188 struct
189 {
190 const struct IODataQueueDispatchSource_CopyMemory_Msg * message;
191 struct IODataQueueDispatchSource_CopyMemory_Rpl * reply;
192 uint32_t sendSize;
193 uint32_t replySize;
194 };
195}
196IODataQueueDispatchSource_CopyMemory_Invocation;
197struct IODataQueueDispatchSource_CopyDataAvailableHandler_Msg_Content
198{
199 IORPCMessage __hdr;
200 OSObjectRef __object;
201};
202#pragma pack(4)
203struct IODataQueueDispatchSource_CopyDataAvailableHandler_Msg
204{
205 IORPCMessageMach mach;
206 mach_msg_port_descriptor_t __object__descriptor;
207 IODataQueueDispatchSource_CopyDataAvailableHandler_Msg_Content content;
208};
209#pragma pack()
210#define IODataQueueDispatchSource_CopyDataAvailableHandler_Msg_ObjRefs (1)
211
212struct IODataQueueDispatchSource_CopyDataAvailableHandler_Rpl_Content
213{
214 IORPCMessage __hdr;
215 OSObjectRef action;
216};
217#pragma pack(4)
218struct IODataQueueDispatchSource_CopyDataAvailableHandler_Rpl
219{
220 IORPCMessageMach mach;
221 mach_msg_port_descriptor_t action__descriptor;
222 IODataQueueDispatchSource_CopyDataAvailableHandler_Rpl_Content content;
223};
224#pragma pack()
225#define IODataQueueDispatchSource_CopyDataAvailableHandler_Rpl_ObjRefs (1)
226
227
228typedef union
229{
230 const IORPC rpc;
231 struct
232 {
233 const struct IODataQueueDispatchSource_CopyDataAvailableHandler_Msg * message;
234 struct IODataQueueDispatchSource_CopyDataAvailableHandler_Rpl * reply;
235 uint32_t sendSize;
236 uint32_t replySize;
237 };
238}
239IODataQueueDispatchSource_CopyDataAvailableHandler_Invocation;
240struct IODataQueueDispatchSource_CopyDataServicedHandler_Msg_Content
241{
242 IORPCMessage __hdr;
243 OSObjectRef __object;
244};
245#pragma pack(4)
246struct IODataQueueDispatchSource_CopyDataServicedHandler_Msg
247{
248 IORPCMessageMach mach;
249 mach_msg_port_descriptor_t __object__descriptor;
250 IODataQueueDispatchSource_CopyDataServicedHandler_Msg_Content content;
251};
252#pragma pack()
253#define IODataQueueDispatchSource_CopyDataServicedHandler_Msg_ObjRefs (1)
254
255struct IODataQueueDispatchSource_CopyDataServicedHandler_Rpl_Content
256{
257 IORPCMessage __hdr;
258 OSObjectRef action;
259};
260#pragma pack(4)
261struct IODataQueueDispatchSource_CopyDataServicedHandler_Rpl
262{
263 IORPCMessageMach mach;
264 mach_msg_port_descriptor_t action__descriptor;
265 IODataQueueDispatchSource_CopyDataServicedHandler_Rpl_Content content;
266};
267#pragma pack()
268#define IODataQueueDispatchSource_CopyDataServicedHandler_Rpl_ObjRefs (1)
269
270
271typedef union
272{
273 const IORPC rpc;
274 struct
275 {
276 const struct IODataQueueDispatchSource_CopyDataServicedHandler_Msg * message;
277 struct IODataQueueDispatchSource_CopyDataServicedHandler_Rpl * reply;
278 uint32_t sendSize;
279 uint32_t replySize;
280 };
281}
282IODataQueueDispatchSource_CopyDataServicedHandler_Invocation;
283struct IODataQueueDispatchSource_DataAvailable_Msg_Content
284{
285 IORPCMessage __hdr;
286 OSObjectRef __object;
287 OSObjectRef action;
288};
289#pragma pack(4)
290struct IODataQueueDispatchSource_DataAvailable_Msg
291{
292 IORPCMessageMach mach;
293 mach_msg_port_descriptor_t __object__descriptor;
294 mach_msg_port_descriptor_t action__descriptor;
295 IODataQueueDispatchSource_DataAvailable_Msg_Content content;
296};
297#pragma pack()
298#define IODataQueueDispatchSource_DataAvailable_Msg_ObjRefs (2)
299
300struct IODataQueueDispatchSource_DataAvailable_Rpl_Content
301{
302 IORPCMessage __hdr;
303};
304#pragma pack(4)
305struct IODataQueueDispatchSource_DataAvailable_Rpl
306{
307 IORPCMessageMach mach;
308 IODataQueueDispatchSource_DataAvailable_Rpl_Content content;
309};
310#pragma pack()
311#define IODataQueueDispatchSource_DataAvailable_Rpl_ObjRefs (0)
312
313
314typedef union
315{
316 const IORPC rpc;
317 struct
318 {
319 const struct IODataQueueDispatchSource_DataAvailable_Msg * message;
320 struct IODataQueueDispatchSource_DataAvailable_Rpl * reply;
321 uint32_t sendSize;
322 uint32_t replySize;
323 };
324}
325IODataQueueDispatchSource_DataAvailable_Invocation;
326struct IODataQueueDispatchSource_DataServiced_Msg_Content
327{
328 IORPCMessage __hdr;
329 OSObjectRef __object;
330 OSObjectRef action;
331};
332#pragma pack(4)
333struct IODataQueueDispatchSource_DataServiced_Msg
334{
335 IORPCMessageMach mach;
336 mach_msg_port_descriptor_t __object__descriptor;
337 mach_msg_port_descriptor_t action__descriptor;
338 IODataQueueDispatchSource_DataServiced_Msg_Content content;
339};
340#pragma pack()
341#define IODataQueueDispatchSource_DataServiced_Msg_ObjRefs (2)
342
343struct IODataQueueDispatchSource_DataServiced_Rpl_Content
344{
345 IORPCMessage __hdr;
346};
347#pragma pack(4)
348struct IODataQueueDispatchSource_DataServiced_Rpl
349{
350 IORPCMessageMach mach;
351 IODataQueueDispatchSource_DataServiced_Rpl_Content content;
352};
353#pragma pack()
354#define IODataQueueDispatchSource_DataServiced_Rpl_ObjRefs (0)
355
356
357typedef union
358{
359 const IORPC rpc;
360 struct
361 {
362 const struct IODataQueueDispatchSource_DataServiced_Msg * message;
363 struct IODataQueueDispatchSource_DataServiced_Rpl * reply;
364 uint32_t sendSize;
365 uint32_t replySize;
366 };
367}
368IODataQueueDispatchSource_DataServiced_Invocation;
369#if !KERNEL
370extern OSMetaClass * gOSContainerMetaClass;
371extern OSMetaClass * gOSDataMetaClass;
372extern OSMetaClass * gOSNumberMetaClass;
373extern OSMetaClass * gOSBooleanMetaClass;
374extern OSMetaClass * gOSDictionaryMetaClass;
375extern OSMetaClass * gOSArrayMetaClass;
376extern OSMetaClass * gOSSetMetaClass;
377extern OSMetaClass * gOSOrderedSetMetaClass;
378extern OSMetaClass * gOSStringMetaClass;
379extern OSMetaClass * gIOServiceMetaClass;
380extern OSMetaClass * gIOMemoryMapMetaClass;
381#endif /* !KERNEL */
382
383#if KERNEL
384OSDefineMetaClassAndStructors(IODataQueueDispatchSource, IODispatchSource);
385#endif /* KERNEL */
386
387#if !KERNEL
388
389#define IODataQueueDispatchSource_QueueNames ""
390
391#define IODataQueueDispatchSource_MethodNames ""
392
393#define IODataQueueDispatchSourceMetaClass_MethodNames ""
394
395struct OSClassDescription_IODataQueueDispatchSource_t
396{
397 OSClassDescription base;
398 uint64_t methodOptions[2 * 0];
399 uint64_t metaMethodOptions[2 * 0];
400 char queueNames[sizeof(IODataQueueDispatchSource_QueueNames)];
401 char methodNames[sizeof(IODataQueueDispatchSource_MethodNames)];
402 char metaMethodNames[sizeof(IODataQueueDispatchSourceMetaClass_MethodNames)];
403};
404
405const struct OSClassDescription_IODataQueueDispatchSource_t
406OSClassDescription_IODataQueueDispatchSource =
407{
408 .base =
409 {
410 .descriptionSize = sizeof(OSClassDescription_IODataQueueDispatchSource_t),
411 .name = "IODataQueueDispatchSource",
412 .superName = "IODispatchSource",
413 .methodOptionsSize = 2 * sizeof(uint64_t) * 0,
414 .methodOptionsOffset = __builtin_offsetof(struct OSClassDescription_IODataQueueDispatchSource_t, methodOptions),
415 .metaMethodOptionsSize = 2 * sizeof(uint64_t) * 0,
416 .metaMethodOptionsOffset = __builtin_offsetof(struct OSClassDescription_IODataQueueDispatchSource_t, metaMethodOptions),
417 .queueNamesSize = sizeof(IODataQueueDispatchSource_QueueNames),
418 .queueNamesOffset = __builtin_offsetof(struct OSClassDescription_IODataQueueDispatchSource_t, queueNames),
419 .methodNamesSize = sizeof(IODataQueueDispatchSource_MethodNames),
420 .methodNamesOffset = __builtin_offsetof(struct OSClassDescription_IODataQueueDispatchSource_t, methodNames),
421 .metaMethodNamesSize = sizeof(IODataQueueDispatchSourceMetaClass_MethodNames),
422 .metaMethodNamesOffset = __builtin_offsetof(struct OSClassDescription_IODataQueueDispatchSource_t, metaMethodNames),
423 .flags = 1*kOSClassCanRemote,
424 },
425 .methodOptions =
426 {
427 },
428 .metaMethodOptions =
429 {
430 },
431 .queueNames = IODataQueueDispatchSource_QueueNames,
432 .methodNames = IODataQueueDispatchSource_MethodNames,
433 .metaMethodNames = IODataQueueDispatchSourceMetaClass_MethodNames,
434};
435
436OSMetaClass * gIODataQueueDispatchSourceMetaClass;
437
438static kern_return_t
439IODataQueueDispatchSource_New(OSMetaClass * instance);
440
441const OSClassLoadInformation
442IODataQueueDispatchSource_Class =
443{
444 .description = &OSClassDescription_IODataQueueDispatchSource.base,
445 .metaPointer = &gIODataQueueDispatchSourceMetaClass,
446 .version = 1,
447 .instanceSize = sizeof(IODataQueueDispatchSource),
448
449 .New = &IODataQueueDispatchSource_New,
450};
451
452extern const void * const
453gIODataQueueDispatchSource_Declaration;
454const void * const
455gIODataQueueDispatchSource_Declaration
456__attribute__((visibility("hidden"),section("__DATA_CONST,__osclassinfo,regular,no_dead_strip"),no_sanitize("address")))
457 = &IODataQueueDispatchSource_Class;
458
459static kern_return_t
460IODataQueueDispatchSource_New(OSMetaClass * instance)
461{
462 if (!new(instance) IODataQueueDispatchSourceMetaClass) return (kIOReturnNoMemory);
463 return (kIOReturnSuccess);
464}
465
466kern_return_t
467IODataQueueDispatchSourceMetaClass::New(OSObject * instance)
468{
469 if (!new(instance) IODataQueueDispatchSource) return (kIOReturnNoMemory);
470 return (kIOReturnSuccess);
471}
472
473#endif /* !KERNEL */
474
475kern_return_t
476IODataQueueDispatchSource::Dispatch(const IORPC rpc)
477{
478 return _Dispatch(self: this, rpc);
479}
480
481kern_return_t
482IODataQueueDispatchSource::_Dispatch(IODataQueueDispatchSource * self, const IORPC rpc)
483{
484 kern_return_t ret = kIOReturnUnsupported;
485 IORPCMessage * msg = IORPCMessageFromMach(msg: rpc.message, reply: false);
486
487 switch (msg->msgid)
488 {
489#if KERNEL
490 case IODataQueueDispatchSource_SetDataAvailableHandler_ID:
491 {
492 ret = IODataQueueDispatchSource::SetDataAvailableHandler_Invoke(rpc, target: self, SimpleMemberFunctionCast(IODataQueueDispatchSource::SetDataAvailableHandler_Handler, *self, &IODataQueueDispatchSource::SetDataAvailableHandler_Impl));
493 break;
494 }
495#endif /* !KERNEL */
496#if KERNEL
497 case IODataQueueDispatchSource_SetDataServicedHandler_ID:
498 {
499 ret = IODataQueueDispatchSource::SetDataServicedHandler_Invoke(rpc, target: self, SimpleMemberFunctionCast(IODataQueueDispatchSource::SetDataServicedHandler_Handler, *self, &IODataQueueDispatchSource::SetDataServicedHandler_Impl));
500 break;
501 }
502#endif /* !KERNEL */
503 case IODispatchSource_SetEnableWithCompletion_ID:
504 {
505 ret = IODispatchSource::SetEnableWithCompletion_Invoke(rpc, target: self, SimpleMemberFunctionCast(IODispatchSource::SetEnableWithCompletion_Handler, *self, &IODataQueueDispatchSource::SetEnableWithCompletion_Impl));
506 break;
507 }
508 case IODispatchSource_Cancel_ID:
509 {
510 ret = IODispatchSource::Cancel_Invoke(rpc, target: self, SimpleMemberFunctionCast(IODispatchSource::Cancel_Handler, *self, &IODataQueueDispatchSource::Cancel_Impl));
511 break;
512 }
513#if KERNEL
514 case IODataQueueDispatchSource_CopyMemory_ID:
515 {
516 ret = IODataQueueDispatchSource::CopyMemory_Invoke(rpc, target: self, SimpleMemberFunctionCast(IODataQueueDispatchSource::CopyMemory_Handler, *self, &IODataQueueDispatchSource::CopyMemory_Impl));
517 break;
518 }
519#endif /* !KERNEL */
520#if KERNEL
521 case IODataQueueDispatchSource_CopyDataAvailableHandler_ID:
522 {
523 ret = IODataQueueDispatchSource::CopyDataAvailableHandler_Invoke(rpc, target: self, SimpleMemberFunctionCast(IODataQueueDispatchSource::CopyDataAvailableHandler_Handler, *self, &IODataQueueDispatchSource::CopyDataAvailableHandler_Impl));
524 break;
525 }
526#endif /* !KERNEL */
527#if KERNEL
528 case IODataQueueDispatchSource_CopyDataServicedHandler_ID:
529 {
530 ret = IODataQueueDispatchSource::CopyDataServicedHandler_Invoke(rpc, target: self, SimpleMemberFunctionCast(IODataQueueDispatchSource::CopyDataServicedHandler_Handler, *self, &IODataQueueDispatchSource::CopyDataServicedHandler_Impl));
531 break;
532 }
533#endif /* !KERNEL */
534 case IODispatchSource_CheckForWork_ID:
535 {
536 ret = IODispatchSource::CheckForWork_Invoke(rpc, target: self, SimpleMemberFunctionCast(IODispatchSource::CheckForWork_Handler, *self, &IODataQueueDispatchSource::CheckForWork_Impl));
537 break;
538 }
539
540 default:
541 ret = IODispatchSource::_Dispatch(self, rpc);
542 break;
543 }
544
545 return (ret);
546}
547
548#if KERNEL
549kern_return_t
550IODataQueueDispatchSource::MetaClass::Dispatch(const IORPC rpc)
551{
552#else /* KERNEL */
553kern_return_t
554IODataQueueDispatchSourceMetaClass::Dispatch(const IORPC rpc)
555{
556#endif /* !KERNEL */
557
558 kern_return_t ret = kIOReturnUnsupported;
559 IORPCMessage * msg = IORPCMessageFromMach(msg: rpc.message, reply: false);
560
561 switch (msg->msgid)
562 {
563#if KERNEL
564 case IODataQueueDispatchSource_Create_ID:
565 ret = IODataQueueDispatchSource::Create_Invoke(rpc, func: &IODataQueueDispatchSource::Create_Impl);
566 break;
567#endif /* !KERNEL */
568
569 default:
570 ret = OSMetaClassBase::Dispatch(rpc);
571 break;
572 }
573
574 return (ret);
575}
576
577kern_return_t
578IODataQueueDispatchSource::Create(
579 uint64_t queueByteCount,
580 IODispatchQueue * queue,
581 IODataQueueDispatchSource ** source)
582{
583 kern_return_t ret;
584 union
585 {
586 IODataQueueDispatchSource_Create_Msg msg;
587 struct
588 {
589 IODataQueueDispatchSource_Create_Rpl rpl;
590 mach_msg_max_trailer_t trailer;
591 } rpl;
592 } buf;
593 struct IODataQueueDispatchSource_Create_Msg * msg = &buf.msg;
594 struct IODataQueueDispatchSource_Create_Rpl * rpl = &buf.rpl.rpl;
595
596 memset(s: msg, c: 0, n: sizeof(struct IODataQueueDispatchSource_Create_Msg));
597 msg->mach.msgh.msgh_id = kIORPCVersion190615;
598 msg->mach.msgh.msgh_size = sizeof(*msg);
599 msg->content.__hdr.flags = 0*kIORPCMessageOneway
600 | 0*kIORPCMessageSimpleReply
601 | 0*kIORPCMessageLocalHost
602 | 0*kIORPCMessageOnqueue;
603 msg->content.__hdr.msgid = IODataQueueDispatchSource_Create_ID;
604 msg->content.__object = (OSObjectRef) OSTypeID(IODataQueueDispatchSource);
605 msg->content.__hdr.objectRefs = IODataQueueDispatchSource_Create_Msg_ObjRefs;
606 msg->mach.msgh_body.msgh_descriptor_count = 2;
607
608 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
609
610 msg->content.queueByteCount = queueByteCount;
611
612 msg->queue__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
613 msg->content.queue = (OSObjectRef) queue;
614
615 IORPC rpc = { .message = &buf.msg.mach, .reply = &buf.rpl.rpl.mach, .sendSize = sizeof(buf.msg), .replySize = sizeof(buf.rpl) };
616 ret = OSMTypeID(IODataQueueDispatchSource)->Invoke(rpc);
617
618 if (kIOReturnSuccess == ret)
619 do {
620 {
621 if (rpl->mach.msgh.msgh_size != sizeof(*rpl)) { ret = kIOReturnIPCError; break; };
622 if (rpl->content.__hdr.msgid != IODataQueueDispatchSource_Create_ID) { ret = kIOReturnIPCError; break; };
623 if (rpl->mach.msgh_body.msgh_descriptor_count != 1) { ret = kIOReturnIPCError; break; };
624 if (IODataQueueDispatchSource_Create_Rpl_ObjRefs != rpl->content.__hdr.objectRefs) { ret = kIOReturnIPCError; break; };
625 }
626 }
627 while (false);
628 if (kIOReturnSuccess == ret)
629 {
630 *source = OSDynamicCast(IODataQueueDispatchSource, (OSObject *) rpl->content.source);
631 if (rpl->content.source && !*source) ret = kIOReturnBadArgument;
632 }
633
634
635 return (ret);
636}
637
638kern_return_t
639IODataQueueDispatchSource::SetDataAvailableHandler(
640 OSAction * action,
641 OSDispatchMethod supermethod)
642{
643 kern_return_t ret;
644 union
645 {
646 IODataQueueDispatchSource_SetDataAvailableHandler_Msg msg;
647 struct
648 {
649 IODataQueueDispatchSource_SetDataAvailableHandler_Rpl rpl;
650 mach_msg_max_trailer_t trailer;
651 } rpl;
652 } buf;
653 struct IODataQueueDispatchSource_SetDataAvailableHandler_Msg * msg = &buf.msg;
654 struct IODataQueueDispatchSource_SetDataAvailableHandler_Rpl * rpl = &buf.rpl.rpl;
655
656 memset(s: msg, c: 0, n: sizeof(struct IODataQueueDispatchSource_SetDataAvailableHandler_Msg));
657 msg->mach.msgh.msgh_id = kIORPCVersion190615;
658 msg->mach.msgh.msgh_size = sizeof(*msg);
659 msg->content.__hdr.flags = 0*kIORPCMessageOneway
660 | 1*kIORPCMessageSimpleReply
661 | 0*kIORPCMessageLocalHost
662 | 0*kIORPCMessageOnqueue;
663 msg->content.__hdr.msgid = IODataQueueDispatchSource_SetDataAvailableHandler_ID;
664 msg->content.__object = (OSObjectRef) this;
665 msg->content.__hdr.objectRefs = IODataQueueDispatchSource_SetDataAvailableHandler_Msg_ObjRefs;
666 msg->mach.msgh_body.msgh_descriptor_count = 2;
667
668 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
669
670 msg->action__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
671 msg->content.action = (OSObjectRef) action;
672
673 IORPC rpc = { .message = &buf.msg.mach, .reply = &buf.rpl.rpl.mach, .sendSize = sizeof(buf.msg), .replySize = sizeof(buf.rpl) };
674 if (supermethod) ret = supermethod((OSObject *)this, rpc);
675 else ret = ((OSObject *)this)->Invoke(rpc);
676
677 if (kIOReturnSuccess == ret)
678 do {
679 {
680 if (rpl->mach.msgh.msgh_size != sizeof(*rpl)) { ret = kIOReturnIPCError; break; };
681 if (rpl->content.__hdr.msgid != IODataQueueDispatchSource_SetDataAvailableHandler_ID) { ret = kIOReturnIPCError; break; };
682 if (rpl->mach.msgh_body.msgh_descriptor_count != 0) { ret = kIOReturnIPCError; break; };
683 if (IODataQueueDispatchSource_SetDataAvailableHandler_Rpl_ObjRefs != rpl->content.__hdr.objectRefs) { ret = kIOReturnIPCError; break; };
684 }
685 }
686 while (false);
687 if (kIOReturnSuccess == ret)
688 {
689 }
690
691
692 return (ret);
693}
694
695kern_return_t
696IODataQueueDispatchSource::SetDataServicedHandler(
697 OSAction * action,
698 OSDispatchMethod supermethod)
699{
700 kern_return_t ret;
701 union
702 {
703 IODataQueueDispatchSource_SetDataServicedHandler_Msg msg;
704 struct
705 {
706 IODataQueueDispatchSource_SetDataServicedHandler_Rpl rpl;
707 mach_msg_max_trailer_t trailer;
708 } rpl;
709 } buf;
710 struct IODataQueueDispatchSource_SetDataServicedHandler_Msg * msg = &buf.msg;
711 struct IODataQueueDispatchSource_SetDataServicedHandler_Rpl * rpl = &buf.rpl.rpl;
712
713 memset(s: msg, c: 0, n: sizeof(struct IODataQueueDispatchSource_SetDataServicedHandler_Msg));
714 msg->mach.msgh.msgh_id = kIORPCVersion190615;
715 msg->mach.msgh.msgh_size = sizeof(*msg);
716 msg->content.__hdr.flags = 0*kIORPCMessageOneway
717 | 1*kIORPCMessageSimpleReply
718 | 0*kIORPCMessageLocalHost
719 | 0*kIORPCMessageOnqueue;
720 msg->content.__hdr.msgid = IODataQueueDispatchSource_SetDataServicedHandler_ID;
721 msg->content.__object = (OSObjectRef) this;
722 msg->content.__hdr.objectRefs = IODataQueueDispatchSource_SetDataServicedHandler_Msg_ObjRefs;
723 msg->mach.msgh_body.msgh_descriptor_count = 2;
724
725 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
726
727 msg->action__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
728 msg->content.action = (OSObjectRef) action;
729
730 IORPC rpc = { .message = &buf.msg.mach, .reply = &buf.rpl.rpl.mach, .sendSize = sizeof(buf.msg), .replySize = sizeof(buf.rpl) };
731 if (supermethod) ret = supermethod((OSObject *)this, rpc);
732 else ret = ((OSObject *)this)->Invoke(rpc);
733
734 if (kIOReturnSuccess == ret)
735 do {
736 {
737 if (rpl->mach.msgh.msgh_size != sizeof(*rpl)) { ret = kIOReturnIPCError; break; };
738 if (rpl->content.__hdr.msgid != IODataQueueDispatchSource_SetDataServicedHandler_ID) { ret = kIOReturnIPCError; break; };
739 if (rpl->mach.msgh_body.msgh_descriptor_count != 0) { ret = kIOReturnIPCError; break; };
740 if (IODataQueueDispatchSource_SetDataServicedHandler_Rpl_ObjRefs != rpl->content.__hdr.objectRefs) { ret = kIOReturnIPCError; break; };
741 }
742 }
743 while (false);
744 if (kIOReturnSuccess == ret)
745 {
746 }
747
748
749 return (ret);
750}
751
752kern_return_t
753IODataQueueDispatchSource::CopyMemory(
754 IOMemoryDescriptor ** memory,
755 OSDispatchMethod supermethod)
756{
757 kern_return_t ret;
758 union
759 {
760 IODataQueueDispatchSource_CopyMemory_Msg msg;
761 struct
762 {
763 IODataQueueDispatchSource_CopyMemory_Rpl rpl;
764 mach_msg_max_trailer_t trailer;
765 } rpl;
766 } buf;
767 struct IODataQueueDispatchSource_CopyMemory_Msg * msg = &buf.msg;
768 struct IODataQueueDispatchSource_CopyMemory_Rpl * rpl = &buf.rpl.rpl;
769
770 memset(s: msg, c: 0, n: sizeof(struct IODataQueueDispatchSource_CopyMemory_Msg));
771 msg->mach.msgh.msgh_id = kIORPCVersion190615;
772 msg->mach.msgh.msgh_size = sizeof(*msg);
773 msg->content.__hdr.flags = 0*kIORPCMessageOneway
774 | 0*kIORPCMessageSimpleReply
775 | 0*kIORPCMessageLocalHost
776 | 0*kIORPCMessageOnqueue;
777 msg->content.__hdr.msgid = IODataQueueDispatchSource_CopyMemory_ID;
778 msg->content.__object = (OSObjectRef) this;
779 msg->content.__hdr.objectRefs = IODataQueueDispatchSource_CopyMemory_Msg_ObjRefs;
780 msg->mach.msgh_body.msgh_descriptor_count = 1;
781
782 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
783
784 IORPC rpc = { .message = &buf.msg.mach, .reply = &buf.rpl.rpl.mach, .sendSize = sizeof(buf.msg), .replySize = sizeof(buf.rpl) };
785 if (supermethod) ret = supermethod((OSObject *)this, rpc);
786 else ret = ((OSObject *)this)->Invoke(rpc);
787
788 if (kIOReturnSuccess == ret)
789 do {
790 {
791 if (rpl->mach.msgh.msgh_size != sizeof(*rpl)) { ret = kIOReturnIPCError; break; };
792 if (rpl->content.__hdr.msgid != IODataQueueDispatchSource_CopyMemory_ID) { ret = kIOReturnIPCError; break; };
793 if (rpl->mach.msgh_body.msgh_descriptor_count != 1) { ret = kIOReturnIPCError; break; };
794 if (IODataQueueDispatchSource_CopyMemory_Rpl_ObjRefs != rpl->content.__hdr.objectRefs) { ret = kIOReturnIPCError; break; };
795 }
796 }
797 while (false);
798 if (kIOReturnSuccess == ret)
799 {
800 *memory = OSDynamicCast(IOMemoryDescriptor, (OSObject *) rpl->content.memory);
801 if (rpl->content.memory && !*memory) ret = kIOReturnBadArgument;
802 }
803
804
805 return (ret);
806}
807
808kern_return_t
809IODataQueueDispatchSource::CopyDataAvailableHandler(
810 OSAction ** action,
811 OSDispatchMethod supermethod)
812{
813 kern_return_t ret;
814 union
815 {
816 IODataQueueDispatchSource_CopyDataAvailableHandler_Msg msg;
817 struct
818 {
819 IODataQueueDispatchSource_CopyDataAvailableHandler_Rpl rpl;
820 mach_msg_max_trailer_t trailer;
821 } rpl;
822 } buf;
823 struct IODataQueueDispatchSource_CopyDataAvailableHandler_Msg * msg = &buf.msg;
824 struct IODataQueueDispatchSource_CopyDataAvailableHandler_Rpl * rpl = &buf.rpl.rpl;
825
826 memset(s: msg, c: 0, n: sizeof(struct IODataQueueDispatchSource_CopyDataAvailableHandler_Msg));
827 msg->mach.msgh.msgh_id = kIORPCVersion190615;
828 msg->mach.msgh.msgh_size = sizeof(*msg);
829 msg->content.__hdr.flags = 0*kIORPCMessageOneway
830 | 0*kIORPCMessageSimpleReply
831 | 0*kIORPCMessageLocalHost
832 | 0*kIORPCMessageOnqueue;
833 msg->content.__hdr.msgid = IODataQueueDispatchSource_CopyDataAvailableHandler_ID;
834 msg->content.__object = (OSObjectRef) this;
835 msg->content.__hdr.objectRefs = IODataQueueDispatchSource_CopyDataAvailableHandler_Msg_ObjRefs;
836 msg->mach.msgh_body.msgh_descriptor_count = 1;
837
838 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
839
840 IORPC rpc = { .message = &buf.msg.mach, .reply = &buf.rpl.rpl.mach, .sendSize = sizeof(buf.msg), .replySize = sizeof(buf.rpl) };
841 if (supermethod) ret = supermethod((OSObject *)this, rpc);
842 else ret = ((OSObject *)this)->Invoke(rpc);
843
844 if (kIOReturnSuccess == ret)
845 do {
846 {
847 if (rpl->mach.msgh.msgh_size != sizeof(*rpl)) { ret = kIOReturnIPCError; break; };
848 if (rpl->content.__hdr.msgid != IODataQueueDispatchSource_CopyDataAvailableHandler_ID) { ret = kIOReturnIPCError; break; };
849 if (rpl->mach.msgh_body.msgh_descriptor_count != 1) { ret = kIOReturnIPCError; break; };
850 if (IODataQueueDispatchSource_CopyDataAvailableHandler_Rpl_ObjRefs != rpl->content.__hdr.objectRefs) { ret = kIOReturnIPCError; break; };
851 }
852 }
853 while (false);
854 if (kIOReturnSuccess == ret)
855 {
856 *action = OSDynamicCast(OSAction, (OSObject *) rpl->content.action);
857 if (rpl->content.action && !*action) ret = kIOReturnBadArgument;
858 }
859
860
861 return (ret);
862}
863
864kern_return_t
865IODataQueueDispatchSource::CopyDataServicedHandler(
866 OSAction ** action,
867 OSDispatchMethod supermethod)
868{
869 kern_return_t ret;
870 union
871 {
872 IODataQueueDispatchSource_CopyDataServicedHandler_Msg msg;
873 struct
874 {
875 IODataQueueDispatchSource_CopyDataServicedHandler_Rpl rpl;
876 mach_msg_max_trailer_t trailer;
877 } rpl;
878 } buf;
879 struct IODataQueueDispatchSource_CopyDataServicedHandler_Msg * msg = &buf.msg;
880 struct IODataQueueDispatchSource_CopyDataServicedHandler_Rpl * rpl = &buf.rpl.rpl;
881
882 memset(s: msg, c: 0, n: sizeof(struct IODataQueueDispatchSource_CopyDataServicedHandler_Msg));
883 msg->mach.msgh.msgh_id = kIORPCVersion190615;
884 msg->mach.msgh.msgh_size = sizeof(*msg);
885 msg->content.__hdr.flags = 0*kIORPCMessageOneway
886 | 0*kIORPCMessageSimpleReply
887 | 0*kIORPCMessageLocalHost
888 | 0*kIORPCMessageOnqueue;
889 msg->content.__hdr.msgid = IODataQueueDispatchSource_CopyDataServicedHandler_ID;
890 msg->content.__object = (OSObjectRef) this;
891 msg->content.__hdr.objectRefs = IODataQueueDispatchSource_CopyDataServicedHandler_Msg_ObjRefs;
892 msg->mach.msgh_body.msgh_descriptor_count = 1;
893
894 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
895
896 IORPC rpc = { .message = &buf.msg.mach, .reply = &buf.rpl.rpl.mach, .sendSize = sizeof(buf.msg), .replySize = sizeof(buf.rpl) };
897 if (supermethod) ret = supermethod((OSObject *)this, rpc);
898 else ret = ((OSObject *)this)->Invoke(rpc);
899
900 if (kIOReturnSuccess == ret)
901 do {
902 {
903 if (rpl->mach.msgh.msgh_size != sizeof(*rpl)) { ret = kIOReturnIPCError; break; };
904 if (rpl->content.__hdr.msgid != IODataQueueDispatchSource_CopyDataServicedHandler_ID) { ret = kIOReturnIPCError; break; };
905 if (rpl->mach.msgh_body.msgh_descriptor_count != 1) { ret = kIOReturnIPCError; break; };
906 if (IODataQueueDispatchSource_CopyDataServicedHandler_Rpl_ObjRefs != rpl->content.__hdr.objectRefs) { ret = kIOReturnIPCError; break; };
907 }
908 }
909 while (false);
910 if (kIOReturnSuccess == ret)
911 {
912 *action = OSDynamicCast(OSAction, (OSObject *) rpl->content.action);
913 if (rpl->content.action && !*action) ret = kIOReturnBadArgument;
914 }
915
916
917 return (ret);
918}
919
920void
921IODataQueueDispatchSource::DataAvailable(
922 OSAction * action,
923 OSDispatchMethod supermethod)
924{
925 kern_return_t ret;
926 union
927 {
928 IODataQueueDispatchSource_DataAvailable_Msg msg;
929 } buf;
930 struct IODataQueueDispatchSource_DataAvailable_Msg * msg = &buf.msg;
931
932 memset(s: msg, c: 0, n: sizeof(struct IODataQueueDispatchSource_DataAvailable_Msg));
933 msg->mach.msgh.msgh_id = kIORPCVersion190615;
934 msg->mach.msgh.msgh_size = sizeof(*msg);
935 msg->content.__hdr.flags = 1*kIORPCMessageOneway
936 | 1*kIORPCMessageSimpleReply
937 | 0*kIORPCMessageLocalHost
938 | 0*kIORPCMessageOnqueue;
939 msg->content.__hdr.msgid = IODataQueueDispatchSource_DataAvailable_ID;
940 msg->content.__object = (OSObjectRef) action;
941 msg->content.__hdr.objectRefs = IODataQueueDispatchSource_DataAvailable_Msg_ObjRefs;
942 msg->mach.msgh_body.msgh_descriptor_count = 2;
943
944 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
945
946 msg->action__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
947 msg->content.action = (OSObjectRef) action;
948
949 IORPC rpc = { .message = &buf.msg.mach, .reply = NULL, .sendSize = sizeof(*msg), .replySize = 0 };
950 ret = action->Invoke(rpc);
951
952}
953
954void
955IODataQueueDispatchSource::DataServiced(
956 OSAction * action,
957 OSDispatchMethod supermethod)
958{
959 kern_return_t ret;
960 union
961 {
962 IODataQueueDispatchSource_DataServiced_Msg msg;
963 } buf;
964 struct IODataQueueDispatchSource_DataServiced_Msg * msg = &buf.msg;
965
966 memset(s: msg, c: 0, n: sizeof(struct IODataQueueDispatchSource_DataServiced_Msg));
967 msg->mach.msgh.msgh_id = kIORPCVersion190615;
968 msg->mach.msgh.msgh_size = sizeof(*msg);
969 msg->content.__hdr.flags = 1*kIORPCMessageOneway
970 | 1*kIORPCMessageSimpleReply
971 | 0*kIORPCMessageLocalHost
972 | 0*kIORPCMessageOnqueue;
973 msg->content.__hdr.msgid = IODataQueueDispatchSource_DataServiced_ID;
974 msg->content.__object = (OSObjectRef) action;
975 msg->content.__hdr.objectRefs = IODataQueueDispatchSource_DataServiced_Msg_ObjRefs;
976 msg->mach.msgh_body.msgh_descriptor_count = 2;
977
978 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
979
980 msg->action__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
981 msg->content.action = (OSObjectRef) action;
982
983 IORPC rpc = { .message = &buf.msg.mach, .reply = NULL, .sendSize = sizeof(*msg), .replySize = 0 };
984 ret = action->Invoke(rpc);
985
986}
987
988kern_return_t
989IODataQueueDispatchSource::Create_Invoke(const IORPC _rpc,
990 Create_Handler func)
991{
992 IODataQueueDispatchSource_Create_Invocation rpc = { .rpc: _rpc };
993 kern_return_t ret;
994 IODispatchQueue * queue;
995
996 if (2 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
997 if (IODataQueueDispatchSource_Create_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
998 if (rpc.message != NULL && rpc.sendSize < sizeof(IODataQueueDispatchSource_Create_Msg)) return (kIOReturnIPCError);
999 if (rpc.reply != NULL && rpc.replySize < sizeof(IODataQueueDispatchSource_Create_Rpl)) return (kIOReturnIPCError);
1000 queue = OSDynamicCast(IODispatchQueue, (OSObject *) rpc.message->content.queue);
1001 if (!queue && rpc.message->content.queue) return (kIOReturnBadArgument);
1002
1003 ret = (*func)( rpc.message->content.queueByteCount,
1004 queue,
1005 (IODataQueueDispatchSource **)&rpc.reply->content.source);
1006
1007 if (kIOReturnSuccess != ret) return (ret);
1008
1009 rpc.reply->content.__hdr.msgid = IODataQueueDispatchSource_Create_ID;
1010 rpc.reply->content.__hdr.flags = kIORPCMessageOneway;
1011 rpc.reply->mach.msgh.msgh_id = kIORPCVersion190615Reply;
1012 rpc.reply->mach.msgh.msgh_size = sizeof(*rpc.reply);
1013 rpc.reply->mach.msgh_body.msgh_descriptor_count = 1;
1014 rpc.reply->content.__hdr.objectRefs = IODataQueueDispatchSource_Create_Rpl_ObjRefs;
1015 rpc.reply->source__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
1016
1017 return (ret);
1018}
1019
1020kern_return_t
1021IODataQueueDispatchSource::SetDataAvailableHandler_Invoke(const IORPC _rpc,
1022 OSMetaClassBase * target,
1023 SetDataAvailableHandler_Handler func)
1024{
1025 IODataQueueDispatchSource_SetDataAvailableHandler_Invocation rpc = { .rpc: _rpc };
1026 kern_return_t ret;
1027 OSAction * action;
1028
1029 if (2 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
1030 if (IODataQueueDispatchSource_SetDataAvailableHandler_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
1031 if (rpc.message != NULL && rpc.sendSize < sizeof(IODataQueueDispatchSource_SetDataAvailableHandler_Msg)) return (kIOReturnIPCError);
1032 if (rpc.reply != NULL && rpc.replySize < sizeof(IODataQueueDispatchSource_SetDataAvailableHandler_Rpl)) return (kIOReturnIPCError);
1033 action = OSDynamicCast(OSAction, (OSObject *) rpc.message->content.action);
1034 if (!action && rpc.message->content.action) return (kIOReturnBadArgument);
1035
1036 ret = (*func)(target,
1037 action);
1038
1039 if (kIOReturnSuccess != ret) return (ret);
1040
1041 rpc.reply->content.__hdr.msgid = IODataQueueDispatchSource_SetDataAvailableHandler_ID;
1042 rpc.reply->content.__hdr.flags = kIORPCMessageOneway;
1043 rpc.reply->mach.msgh.msgh_id = kIORPCVersion190615Reply;
1044 rpc.reply->mach.msgh.msgh_size = sizeof(*rpc.reply);
1045 rpc.reply->mach.msgh_body.msgh_descriptor_count = 0;
1046 rpc.reply->content.__hdr.objectRefs = IODataQueueDispatchSource_SetDataAvailableHandler_Rpl_ObjRefs;
1047
1048 return (ret);
1049}
1050
1051kern_return_t
1052IODataQueueDispatchSource::SetDataServicedHandler_Invoke(const IORPC _rpc,
1053 OSMetaClassBase * target,
1054 SetDataServicedHandler_Handler func)
1055{
1056 IODataQueueDispatchSource_SetDataServicedHandler_Invocation rpc = { .rpc: _rpc };
1057 kern_return_t ret;
1058 OSAction * action;
1059
1060 if (2 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
1061 if (IODataQueueDispatchSource_SetDataServicedHandler_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
1062 if (rpc.message != NULL && rpc.sendSize < sizeof(IODataQueueDispatchSource_SetDataServicedHandler_Msg)) return (kIOReturnIPCError);
1063 if (rpc.reply != NULL && rpc.replySize < sizeof(IODataQueueDispatchSource_SetDataServicedHandler_Rpl)) return (kIOReturnIPCError);
1064 action = OSDynamicCast(OSAction, (OSObject *) rpc.message->content.action);
1065 if (!action && rpc.message->content.action) return (kIOReturnBadArgument);
1066
1067 ret = (*func)(target,
1068 action);
1069
1070 if (kIOReturnSuccess != ret) return (ret);
1071
1072 rpc.reply->content.__hdr.msgid = IODataQueueDispatchSource_SetDataServicedHandler_ID;
1073 rpc.reply->content.__hdr.flags = kIORPCMessageOneway;
1074 rpc.reply->mach.msgh.msgh_id = kIORPCVersion190615Reply;
1075 rpc.reply->mach.msgh.msgh_size = sizeof(*rpc.reply);
1076 rpc.reply->mach.msgh_body.msgh_descriptor_count = 0;
1077 rpc.reply->content.__hdr.objectRefs = IODataQueueDispatchSource_SetDataServicedHandler_Rpl_ObjRefs;
1078
1079 return (ret);
1080}
1081
1082kern_return_t
1083IODataQueueDispatchSource::CopyMemory_Invoke(const IORPC _rpc,
1084 OSMetaClassBase * target,
1085 CopyMemory_Handler func)
1086{
1087 IODataQueueDispatchSource_CopyMemory_Invocation rpc = { .rpc: _rpc };
1088 kern_return_t ret;
1089
1090 if (1 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
1091 if (IODataQueueDispatchSource_CopyMemory_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
1092 if (rpc.message != NULL && rpc.sendSize < sizeof(IODataQueueDispatchSource_CopyMemory_Msg)) return (kIOReturnIPCError);
1093 if (rpc.reply != NULL && rpc.replySize < sizeof(IODataQueueDispatchSource_CopyMemory_Rpl)) return (kIOReturnIPCError);
1094
1095 ret = (*func)(target,
1096 (IOMemoryDescriptor **)&rpc.reply->content.memory);
1097
1098 if (kIOReturnSuccess != ret) return (ret);
1099
1100 rpc.reply->content.__hdr.msgid = IODataQueueDispatchSource_CopyMemory_ID;
1101 rpc.reply->content.__hdr.flags = kIORPCMessageOneway;
1102 rpc.reply->mach.msgh.msgh_id = kIORPCVersion190615Reply;
1103 rpc.reply->mach.msgh.msgh_size = sizeof(*rpc.reply);
1104 rpc.reply->mach.msgh_body.msgh_descriptor_count = 1;
1105 rpc.reply->content.__hdr.objectRefs = IODataQueueDispatchSource_CopyMemory_Rpl_ObjRefs;
1106 rpc.reply->memory__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
1107
1108 return (ret);
1109}
1110
1111kern_return_t
1112IODataQueueDispatchSource::CopyDataAvailableHandler_Invoke(const IORPC _rpc,
1113 OSMetaClassBase * target,
1114 CopyDataAvailableHandler_Handler func)
1115{
1116 IODataQueueDispatchSource_CopyDataAvailableHandler_Invocation rpc = { .rpc: _rpc };
1117 kern_return_t ret;
1118
1119 if (1 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
1120 if (IODataQueueDispatchSource_CopyDataAvailableHandler_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
1121 if (rpc.message != NULL && rpc.sendSize < sizeof(IODataQueueDispatchSource_CopyDataAvailableHandler_Msg)) return (kIOReturnIPCError);
1122 if (rpc.reply != NULL && rpc.replySize < sizeof(IODataQueueDispatchSource_CopyDataAvailableHandler_Rpl)) return (kIOReturnIPCError);
1123
1124 ret = (*func)(target,
1125 (OSAction **)&rpc.reply->content.action);
1126
1127 if (kIOReturnSuccess != ret) return (ret);
1128
1129 rpc.reply->content.__hdr.msgid = IODataQueueDispatchSource_CopyDataAvailableHandler_ID;
1130 rpc.reply->content.__hdr.flags = kIORPCMessageOneway;
1131 rpc.reply->mach.msgh.msgh_id = kIORPCVersion190615Reply;
1132 rpc.reply->mach.msgh.msgh_size = sizeof(*rpc.reply);
1133 rpc.reply->mach.msgh_body.msgh_descriptor_count = 1;
1134 rpc.reply->content.__hdr.objectRefs = IODataQueueDispatchSource_CopyDataAvailableHandler_Rpl_ObjRefs;
1135 rpc.reply->action__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
1136
1137 return (ret);
1138}
1139
1140kern_return_t
1141IODataQueueDispatchSource::CopyDataServicedHandler_Invoke(const IORPC _rpc,
1142 OSMetaClassBase * target,
1143 CopyDataServicedHandler_Handler func)
1144{
1145 IODataQueueDispatchSource_CopyDataServicedHandler_Invocation rpc = { .rpc: _rpc };
1146 kern_return_t ret;
1147
1148 if (1 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
1149 if (IODataQueueDispatchSource_CopyDataServicedHandler_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
1150 if (rpc.message != NULL && rpc.sendSize < sizeof(IODataQueueDispatchSource_CopyDataServicedHandler_Msg)) return (kIOReturnIPCError);
1151 if (rpc.reply != NULL && rpc.replySize < sizeof(IODataQueueDispatchSource_CopyDataServicedHandler_Rpl)) return (kIOReturnIPCError);
1152
1153 ret = (*func)(target,
1154 (OSAction **)&rpc.reply->content.action);
1155
1156 if (kIOReturnSuccess != ret) return (ret);
1157
1158 rpc.reply->content.__hdr.msgid = IODataQueueDispatchSource_CopyDataServicedHandler_ID;
1159 rpc.reply->content.__hdr.flags = kIORPCMessageOneway;
1160 rpc.reply->mach.msgh.msgh_id = kIORPCVersion190615Reply;
1161 rpc.reply->mach.msgh.msgh_size = sizeof(*rpc.reply);
1162 rpc.reply->mach.msgh_body.msgh_descriptor_count = 1;
1163 rpc.reply->content.__hdr.objectRefs = IODataQueueDispatchSource_CopyDataServicedHandler_Rpl_ObjRefs;
1164 rpc.reply->action__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
1165
1166 return (ret);
1167}
1168
1169kern_return_t
1170IODataQueueDispatchSource::DataAvailable_Invoke(const IORPC _rpc,
1171 OSMetaClassBase * target,
1172 DataAvailable_Handler func)
1173{
1174 return IODataQueueDispatchSource::DataAvailable_Invoke(rpc: _rpc, target, func, NULL);
1175}
1176
1177kern_return_t
1178IODataQueueDispatchSource::DataAvailable_Invoke(const IORPC _rpc,
1179 OSMetaClassBase * target,
1180 DataAvailable_Handler func,
1181 const OSMetaClass * targetActionClass)
1182{
1183 IODataQueueDispatchSource_DataAvailable_Invocation rpc = { .rpc: _rpc };
1184 OSAction * action;
1185
1186 if (2 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
1187 if (IODataQueueDispatchSource_DataAvailable_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
1188 if (rpc.message != NULL && rpc.sendSize < sizeof(IODataQueueDispatchSource_DataAvailable_Msg)) return (kIOReturnIPCError);
1189 if (rpc.reply != NULL && rpc.replySize < sizeof(IODataQueueDispatchSource_DataAvailable_Rpl)) return (kIOReturnIPCError);
1190 if (targetActionClass) {
1191 action = (OSAction *) OSMetaClassBase::safeMetaCast(anObject: (OSObject *) rpc.message->content.action, toMeta: targetActionClass);
1192 } else {
1193 action = OSDynamicCast(OSAction, (OSObject *) rpc.message->content.action);
1194 }
1195 if (!action && rpc.message->content.action) return (kIOReturnBadArgument);
1196
1197 (*func)(target,
1198 action);
1199
1200
1201 return (kIOReturnSuccess);
1202}
1203
1204kern_return_t
1205IODataQueueDispatchSource::DataServiced_Invoke(const IORPC _rpc,
1206 OSMetaClassBase * target,
1207 DataServiced_Handler func)
1208{
1209 return IODataQueueDispatchSource::DataServiced_Invoke(rpc: _rpc, target, func, NULL);
1210}
1211
1212kern_return_t
1213IODataQueueDispatchSource::DataServiced_Invoke(const IORPC _rpc,
1214 OSMetaClassBase * target,
1215 DataServiced_Handler func,
1216 const OSMetaClass * targetActionClass)
1217{
1218 IODataQueueDispatchSource_DataServiced_Invocation rpc = { .rpc: _rpc };
1219 OSAction * action;
1220
1221 if (2 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
1222 if (IODataQueueDispatchSource_DataServiced_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
1223 if (rpc.message != NULL && rpc.sendSize < sizeof(IODataQueueDispatchSource_DataServiced_Msg)) return (kIOReturnIPCError);
1224 if (rpc.reply != NULL && rpc.replySize < sizeof(IODataQueueDispatchSource_DataServiced_Rpl)) return (kIOReturnIPCError);
1225 if (targetActionClass) {
1226 action = (OSAction *) OSMetaClassBase::safeMetaCast(anObject: (OSObject *) rpc.message->content.action, toMeta: targetActionClass);
1227 } else {
1228 action = OSDynamicCast(OSAction, (OSObject *) rpc.message->content.action);
1229 }
1230 if (!action && rpc.message->content.action) return (kIOReturnBadArgument);
1231
1232 (*func)(target,
1233 action);
1234
1235
1236 return (kIOReturnSuccess);
1237}
1238
1239
1240
1241