应用程序与驱动程序客服端方式交互

最新推荐文章于 2023-03-22 16:14:17 发布
最新推荐文章于 2023-03-22 16:14:17 发布
阅读量681 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： xcode
原文链接：http://blog.51cto.com/haidragon/2164506
博客介绍了IOService 3环与0环交互的实现方式。3环通过IOServiceOpen打开连接驱动，0环在start中设置与之交互的Client，方式有设置键值对或new一个Client，还列出了3环和0环涉及的代码文件。

应用程序与驱动程序客服端方式交互
实现方式是：
3 环通过IOServiceOpen打开连接驱动
0 环在 start 中设置一个与之交互的Client（方式有设置键值对或 new一个Client）
3 环：
// UserClientShared.h

//
//  UserClientShared.h
//  UserSpaceClient
//

#include <stdint.h>

typedef struct TimerValue
{
    uint64_t    time;
    uint64_t    timebase;
} TimerValue;

// 用于用户客户端方法的控制请求码
enum TimerRequestCode {
    kTestUserClientStartTimer,
    kTestUserClientStopTimer,
    kTestUserClientGetElapsedTimerTime,
    kTestUserClientGetElapsedTimerValue,
    kTestUserClientDelayForMs,
    kTestUserClientDelayForTime,
    kTestUserClientInstallTimer,

    kTestUserClientMethodCount
};

//main.cpp

//
//  main.c
//  UserSpaceClient
//

#include <CoreFoundation/CoreFoundation.h>
#include <IOKit/IOKitLib.h>
#include "UserClientShared.h"

kern_return_t   StartTimer (io_connect_t connection);
kern_return_t   StopTimer (io_connect_t connection);
kern_return_t   GetElapsedTimerTime (io_connect_t connection, uint32_t* timerTime);
kern_return_t   GetElapsedTimerValue (io_connect_t connection, TimerValue* timerValue);
kern_return_t   DelayForMs (io_connect_t connection, uint32_t milliseconds);
kern_return_t   DelayForTime (io_connect_t connection, const TimerValue* timerValue);

//以下这些控制请求 都会调试驱动中IOUserClient的externalMethod方法（也就是必须实现）
kern_return_t   StartTimer (io_connect_t connection)
{
    //IOConnectCallMethod用于控制请求
    return IOConnectCallMethod(
                               //连接（端口）
                               connection,
                               //控制码（函数）
                               kTestUserClientStartTimer,
                               //参数
                               NULL, 0, NULL, 0, NULL, NULL, NULL, NULL);
}

kern_return_t   StopTimer (io_connect_t connection)
{
    return IOConnectCallMethod(connection, kTestUserClientStopTimer, NULL, 0, NULL, 0, NULL, NULL, NULL, NULL);
}

kern_return_t   GetElapsedTimerTime (io_connect_t connection, uint32_t* timerTime)
{
    uint64_t        scalarOut[1];
    uint32_t        scalarOutCount;
    kern_return_t   result;

    scalarOutCount = 1;     // 初始化为scalarOut数组的长度
    result = IOConnectCallScalarMethod(connection, kTestUserClientGetElapsedTimerTime, NULL, 0, scalarOut, &scalarOutCount);
    if (result == kIOReturnSuccess)
        *timerTime = (uint32_t)scalarOut[0];

    return result;
}

kern_return_t   GetElapsedTimerValue (io_connect_t connection, TimerValue* timerValue)
{
    size_t  structOutSize;

    structOutSize = sizeof(TimerValue);
    return IOConnectCallStructMethod(connection, kTestUserClientGetElapsedTimerValue, NULL, 0, timerValue, &structOutSize);
}

kern_return_t   DelayForMs (io_connect_t connection, uint32_t milliseconds)
{
    uint64_t        scalarIn[1];

    scalarIn[0] = milliseconds;
    return IOConnectCallScalarMethod(connection, kTestUserClientDelayForMs, scalarIn, 1, NULL, NULL);
}

kern_return_t   DelayForTime (io_connect_t connection, const TimerValue* timerValue)
{
    return IOConnectCallStructMethod(connection, kTestUserClientDelayForTime, timerValue, sizeof(TimerValue), NULL, 0);
}

IONotificationPortRef   gAsyncNotificationPort = NULL;

IONotificationPortRef   MyDriverGetAsyncCompletionPort ()
{
    // If the port has been allocated, return the existing instance
    if (gAsyncNotificationPort != NULL)
        return gAsyncNotificationPort;

    gAsyncNotificationPort = IONotificationPortCreate(kIOMasterPortDefault);
    return gAsyncNotificationPort;
}

kern_return_t   InstallTimer (io_connect_t connection, uint32_t milliseconds, IOAsyncCallback0 timerCallback, void* context)
{
    io_async_ref64_t    asyncRef;
    uint64_t            scalarIn[1];
    //设置回调函数
    asyncRef[kIOAsyncCalloutFuncIndex] = (uint64_t)timerCallback;
    asyncRef[kIOAsyncCalloutRefconIndex] = (uint64_t)context;
    //设置输入参数
    scalarIn[0] = milliseconds;
    return IOConnectCallAsyncScalarMethod(connection, kTestUserClientInstallTimer, IONotificationPortGetMachPort(gAsyncNotificationPort),
                                          asyncRef, kIOAsyncCalloutCount, scalarIn, 1, NULL, NULL);
}

void DelayCallback (void *refcon, IOReturn result)
{
    printf("DelayCallback - refcon %08x and result %08x\n", (uint32_t)refcon, result);
    if (refcon == (void*)0xdeadbeef)
        CFRunLoopStop(CFRunLoopGetMain());
}

int main (int argc, const char * argv[])
{
    CFDictionaryRef     matchingDict = NULL;
    io_iterator_t       iter = 0;
    io_service_t        service = 0;
    kern_return_t       kr;

    ////创建一个匹配字典，用于查找任意的 USB 设备
    matchingDict = IOServiceMatching("com_osxkernel_driver_IOKitTest");

    //为匹配字典的所有IO注册表对象创建迭代器
    kr = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, &iter);
    if (kr != KERN_SUCCESS)
        return -1;

    ////迭代所有匹配的对象
    while ((service = IOIteratorNext(iter)) != 0)
    {
        task_port_t     owningTask = mach_task_self();
        uint32_t        type = 0;
        //就是一个端口
        io_connect_t    driverConnection;
        //建立驱动连接
        //会触发驱动程序 IOService类中的newUserClient方法实例化一个新的Client对象 驱动中可以不要实现
        //只要设置一个值就好
//        bool com_osxkernel_driver_IOKitTest::start (IOService *provider)
//        {
//            bool res = super::start(provider);
//            setProperty("IOUserClientClass", "com_osxkernel_driver_IOKitTestUserClient");
//            registerService();
//            return res;
//        }
//        virtual IOReturn newUserClient(
        //用户传递的参数
          //task_t owningTask, void * securityID,
//        UInt32 type, OSDictionary * properties,
         //handler返回给调用者
//        IOUserClient ** handler );
//
//        virtual IOReturn newUserClient( task_t owningTask, void * securityID,
//                                       UInt32 type, IOUserClient ** handler );
        kr = IOServiceOpen(
                           //表示希望连接到的驱动程序
                           service,
                           //表示运行的应用程序
                           owningTask,
                           //无符号 32位×××
                           type,
                           //成功后的返回值
                           &driverConnection);
        if (kr == KERN_SUCCESS)
        {
            uint32_t        timerTime;
            TimerValue      timerValue;
            IONotificationPortRef   notificationPort;
            //获取一个通知端口
            notificationPort = MyDriverGetAsyncCompletionPort();
            if (notificationPort)
            {
                CFRunLoopSourceRef      runLoopSource;
                runLoopSource = IONotificationPortGetRunLoopSource(notificationPort);
                CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopDefaultMode);
            }

            kr = StopTimer(driverConnection);
            printf("StopTimer - %08x\n", kr);

            kr = StartTimer(driverConnection);
            printf("StartTimer - %08x\n", kr);

            kr = GetElapsedTimerTime(driverConnection, &timerTime);
            printf("GetElapsedTimerTime - %08x, time %d\n", kr, timerTime);

            kr = DelayForMs(driverConnection, 100);
            printf("DelayForMs - %08x\n", kr);

            kr = GetElapsedTimerTime(driverConnection, &timerTime);
            printf("GetElapsedTimerTime - %08x, time %d\n", kr, timerTime);

            kr = GetElapsedTimerValue(driverConnection, &timerValue);
            printf("GetElapsedTimerValue - %08x, time %lld / %lld\n", kr, timerValue.time, timerValue.timebase);

            timerValue.timebase = 0;
            timerValue.time = 500;
            kr = DelayForTime(driverConnection, &timerValue);
            printf("DelayForTime - %08x\n", kr);

            timerValue.timebase = 1000;
            kr = DelayForTime(driverConnection, &timerValue);
            printf("DelayForTime - %08x\n", kr);

            kr = GetElapsedTimerTime(driverConnection, &timerTime);
            printf("GetElapsedTimerTime - %08x, time %d\n", kr, timerTime);

            kr = StopTimer(driverConnection);
            printf("StopTimer - %08x\n", kr);

            kr = InstallTimer(driverConnection, 10000, DelayCallback, (void*)0xdeadbeef);
            printf("InstallTimer - %08x\n", kr);
            kr = InstallTimer(driverConnection, 5000, DelayCallback, (void*)0xdead0005);
            printf("InstallTimer - %08x\n", kr);
            kr = InstallTimer(driverConnection, 2000, DelayCallback, (void*)0xdead0002);
            printf("InstallTimer - %08x\n", kr);
            kr = InstallTimer(driverConnection, 7000, DelayCallback, (void*)0xdead0007);
            printf("InstallTimer - %08x\n", kr);

            CFRunLoopRun();

            IONotificationPortDestroy(gAsyncNotificationPort);
            gAsyncNotificationPort = NULL;
            //关闭驱动连接
            IOServiceClose(driverConnection);
        }

        IOObjectRelease(service);
    }
    IOObjectRelease(iter);

    return 0;
}

0 环：
//IOKitTestUserClient.h

//
//  IOKitTestUserClient.h
//  IOKitTest
//

#include <IOKit/IOUserClient.h>
#include "IOKitTest.h"
#include "UserClientShared.h"

class com_osxkernel_driver_IOKitTestUserClient : public IOUserClient
{
    OSDeclareDefaultStructors(com_osxkernel_driver_IOKitTestUserClient)

private:
    task_t                              m_task;
    com_osxkernel_driver_IOKitTest*     m_driver;

    bool        m_timerRunning;
    uint64_t    m_timerStartTime;

    static const IOExternalMethodDispatch   sMethods[kTestUserClientMethodCount];

    static IOReturn     sStartTimer (OSObject* target, void* reference, IOExternalMethodArguments* arguments);
    static IOReturn     sStopTimer (OSObject* target, void* reference, IOExternalMethodArguments* arguments);
    static IOReturn     sGetElapsedTimerTime (OSObject* target, void* reference, IOExternalMethodArguments* arguments);
    static IOReturn     sGetElapsedTimerValue (OSObject* target, void* reference, IOExternalMethodArguments* arguments);
    static IOReturn     sDelayForMs (OSObject* target, void* reference, IOExternalMethodArguments* arguments);
    static IOReturn     sDelayForTime (OSObject* target, void* reference, IOExternalMethodArguments* arguments);
    static IOReturn     sInstallTimer (OSObject* target, void* reference, IOExternalMethodArguments* arguments);
    static void         DelayThreadFunc (void *parameter, wait_result_t);

    IOReturn        startTimer ();
    IOReturn        stopTimer ();
    IOReturn        getElapsedTimerTime (uint32_t* timerTime);
    IOReturn        getElapsedTimerValue (TimerValue* timerValue);
    IOReturn        delayForMs (uint32_t milliseconds);
    IOReturn        delayForTime (const TimerValue* timerValue);

public: 
    virtual bool        initWithTask (task_t owningTask, void* securityToken, UInt32 type, OSDictionary* properties);
    virtual IOReturn    clientClose (void);
    virtual IOReturn    clientDied (void);

    virtual bool        start (IOService* provider);
    virtual void        stop (IOService* provider);
    virtual void        free (void);

    virtual IOReturn    externalMethod (
                                        //32位的请求控制码 指定客户端应用程序请求的是哪一个操作
                                        uint32_t selector,
                                        //标题及结体体参数
                                        IOExternalMethodArguments* arguments,
                                        //应该调用的类方法
                                        IOExternalMethodDispatch* dispatch = 0, OSObject* target = 0, void* reference = 0);
};

//UserClientShared.h

//
//  UserClientShared.h
//  UserSpaceClient
//

#include <stdint.h>

typedef struct TimerValue
{
    uint64_t    time;
    uint64_t    timebase;
} TimerValue;

// 用于用户客户端方法的控制请求码
enum TimerRequestCode {
    kTestUserClientStartTimer,
    kTestUserClientStopTimer,
    kTestUserClientGetElapsedTimerTime,
    kTestUserClientGetElapsedTimerValue,
    kTestUserClientDelayForMs,
    kTestUserClientDelayForTime,
    kTestUserClientInstallTimer,

    kTestUserClientMethodCount
};

IOKitTestUserClient.cpp

//
//  IOKitTestUserClient.cpp
//  IOKitTest
//

#include <IOKit/IOLib.h>
#include "IOKitTestUserClient.h"

#define super IOUserClient

OSDefineMetaClassAndStructors(com_osxkernel_driver_IOKitTestUserClient, IOUserClient)

bool    com_osxkernel_driver_IOKitTestUserClient::initWithTask (task_t owningTask, void* securityToken, UInt32 type, OSDictionary* properties)
{
    if (!owningTask)
        return false;
    if (! super::initWithTask(owningTask, securityToken , type, properties))
        return false;

    m_task = owningTask;
    //判断进程的权限
    IOReturn ret = clientHasPrivilege(securityToken, kIOClientPrivilegeAdministrator);
    if ( ret == kIOReturnSuccess )
    {
        // m_taskIsAdmin = true;
    }

    return true;
}

bool    com_osxkernel_driver_IOKitTestUserClient::start (IOService* provider)
{
    if (! super::start(provider))
        return false;

    m_driver = OSDynamicCast(com_osxkernel_driver_IOKitTest, provider);
    if (!m_driver)
        return false;

    return true;
}

void    com_osxkernel_driver_IOKitTestUserClient::stop (IOService* provider)
{
    IOLog("userClient::stop\n");
    super::stop(provider);
}

void    com_osxkernel_driver_IOKitTestUserClient::free (void)
{
    IOLog("userClient::free\n");
    super::free();
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::clientClose (void)
{
    terminate();
    return kIOReturnSuccess;
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::clientDied (void)
{
    IOLog("userClient::clientDied\n");
    return super::clientDied();
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::sStartTimer (OSObject* target, void* reference, IOExternalMethodArguments* arguments)
{
    com_osxkernel_driver_IOKitTestUserClient*   me = (com_osxkernel_driver_IOKitTestUserClient*)target;

    return me->startTimer();
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::sStopTimer (OSObject* target, void* reference, IOExternalMethodArguments* arguments)
{
    com_osxkernel_driver_IOKitTestUserClient*   me = (com_osxkernel_driver_IOKitTestUserClient*)target;

    return me->stopTimer();
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::sGetElapsedTimerTime (OSObject* target, void* reference, IOExternalMethodArguments* arguments)
{
    com_osxkernel_driver_IOKitTestUserClient*   me = (com_osxkernel_driver_IOKitTestUserClient*)target;
    uint32_t        timerTime;
    IOReturn        result;
    //调用实现操作的方法
    result = me->getElapsedTimerTime(&timerTime);
    //将操作的标量结果返回给调用进程
    arguments->scalarOutput[0] = timerTime;

    return result;
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::sGetElapsedTimerValue (OSObject* target, void* reference, IOExternalMethodArguments* arguments)
{
    com_osxkernel_driver_IOKitTestUserClient*   me = (com_osxkernel_driver_IOKitTestUserClient*)target;

    return me->getElapsedTimerValue((TimerValue*)arguments->structureOutput);
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::sDelayForMs (OSObject* target, void* reference, IOExternalMethodArguments* arguments)
{
    com_osxkernel_driver_IOKitTestUserClient*   me = (com_osxkernel_driver_IOKitTestUserClient*)target;

    return me->delayForMs((uint32_t)arguments->scalarInput[0]);
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::sDelayForTime (OSObject* target, void* reference, IOExternalMethodArguments* arguments)
{
    com_osxkernel_driver_IOKitTestUserClient*   me = (com_osxkernel_driver_IOKitTestUserClient*)target;

    return me->delayForTime((TimerValue*)arguments->structureInput);
}

//保存后台操作所需参数的结构体
struct TimerParams
{
    OSAsyncReference64      asyncRef;
    uint32_t                milliseconds;
    OSObject*               userClient;
};

IOReturn    com_osxkernel_driver_IOKitTestUserClient::sInstallTimer (OSObject* target, void* reference, IOExternalMethodArguments* arguments)
{
    TimerParams*    timerParams;
    thread_t        newThread;

    //分配一个结构体，存储定时器需要的参数
    timerParams = (TimerParams*)IOMalloc(sizeof(TimerParams));
    //取得asyncReference缓冲区的一个副本
    bcopy(arguments->asyncReference, timerParams->asyncRef, sizeof(OSAsyncReference64));
    //取得用户应用程序提供的milliseconds值的一个副本
    timerParams->milliseconds = (uint32_t)arguments->scalarInput[0];
    //取得userClient对象的一个引用
    timerParams->userClient = target;
    //异步操作执行时，保留该用户客户端
    target->retain();

    //启动一个后台线程，在返回给调用者之后继续执行操作
    kernel_thread_start(DelayThreadFunc, timerParams, &newThread);
    thread_deallocate(newThread);

    //立即返回给调用应用程序
    return kIOReturnSuccess;
}

void    com_osxkernel_driver_IOKitTestUserClient::DelayThreadFunc (void *parameter, wait_result_t)
{
    TimerParams*    timerParams = (TimerParams*)parameter;

    //按请求的时间睡眠
    IOSleep(timerParams->milliseconds);
    //向用户应用程序发送操作完成的通知
    sendAsyncResult64(timerParams->asyncRef, kIOReturnSuccess, NULL, 0);

    //后台操作已经完成
    timerParams->userClient->release();

    IOFree(timerParams, sizeof(TimerParams));
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::startTimer ()
{
    if (m_timerRunning == true)
        return kIOReturnBusy;

    m_timerRunning = true;
    clock_get_uptime(&m_timerStartTime);

    return kIOReturnSuccess;
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::stopTimer ()
{
    if (m_timerRunning == false)
        return kIOReturnNotOpen;

    m_timerRunning = false;
    return kIOReturnSuccess;
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::getElapsedTimerTime (uint32_t* timerTime)
{
    uint64_t    timeNow;
    uint64_t    elapsedTime;

    if (m_timerRunning == false)
        return kIOReturnNotOpen;

    clock_get_uptime(&timeNow);
    absolutetime_to_nanoseconds((timeNow - m_timerStartTime), &elapsedTime);
    *timerTime = (uint32_t)(elapsedTime / 1000000);

    return kIOReturnSuccess;
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::getElapsedTimerValue (TimerValue* timerValue)
{
    uint64_t    timeNow;
    uint64_t    elapsedTime;

    if (m_timerRunning == false)
        return kIOReturnNotOpen;

    clock_get_uptime(&timeNow);
    absolutetime_to_nanoseconds((timeNow - m_timerStartTime), &elapsedTime);
    timerValue->timebase = 1000000;
    timerValue->time = (elapsedTime * timerValue->timebase) / 1000000000;

    return kIOReturnSuccess;
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::delayForMs (uint32_t milliseconds)
{
    IOSleep(milliseconds);
    return kIOReturnSuccess;
}

IOReturn    com_osxkernel_driver_IOKitTestUserClient::delayForTime (const TimerValue* timerValue)
{
    uint32_t        milliseconds;

    if (timerValue->timebase == 0)
        return kIOReturnBadArgument;

    milliseconds = (uint32_t)((timerValue->time * 1000) / timerValue->timebase);
    IOSleep(milliseconds);

    return kIOReturnSuccess;
}

//调试表
const IOExternalMethodDispatch com_osxkernel_driver_IOKitTestUserClient::sMethods[kTestUserClientMethodCount] =
{
    // kTestUserClientStartTimer   (void)
    { sStartTimer, 0, 0, 0, 0 },

    // kTestUserClientStopTimer   (void)
    { sStopTimer, 0, 0, 0, 0 },

    // kTestUserClientGetElapsedTimerTime   (uint32_t* timerValue)
    { sGetElapsedTimerTime, 0, 0, 1, 0 },

    // kTestUserClientGetElapsedTimerValue   (TimerValue* timerValue)
    { sGetElapsedTimerValue, 0, 0, 0, sizeof(TimerValue) },

    // kTestUserClientDelayForMs   (uint32_t milliseconds)
    { sDelayForMs, 1, 0, 0, 0 },

    // kTestUserClientDelayForTime  (const TimerValue* timerValue)
    { sDelayForTime, 0, sizeof(TimerValue), 0, 0 },

    // kTestUserClientInstallTimer  (uint32_t milliseconds)
    { sInstallTimer, 1, 0, 0, 0 }
};
//驱动程序的IOUserClient子类提供的实现
IOReturn    com_osxkernel_driver_IOKitTestUserClient::externalMethod (uint32_t selector, IOExternalMethodArguments* arguments,
                                    IOExternalMethodDispatch* dispatch, OSObject* target, void* reference)
{
    //判断控制码 确保请求的控制码选择器在范围内
    if (selector >= kTestUserClientMethodCount)
        return kIOReturnUnsupported;
    //选择相应的控制码（也就是调试表）
    dispatch = (IOExternalMethodDispatch*)&sMethods[selector];
    target = this;
    reference = NULL;
    //返回父类的
    return super::externalMethod(selector, arguments, dispatch, target, reference);
    //超类的实现
//    externalMethod(selector, arguments, dispatch, target, reference){
//        Dispatch->function(target,reference,args);
//    }
}

//IOKitTest.h

#include <IOKit/IOService.h>

class com_osxkernel_driver_IOKitTest : public IOService
{
    OSDeclareDefaultStructors(com_osxkernel_driver_IOKitTest)

public: 
    virtual bool        init (OSDictionary* dictionary = NULL);
    virtual void        free (void);

    virtual bool        start (IOService* provider);
    virtual void        stop (IOService* provider);
};

//IOKitTest.cpp

        #include "IOKitTest.h"
#include <IOKit/IOLib.h>

#define super IOService

OSDefineMetaClassAndStructors(com_osxkernel_driver_IOKitTest, IOService)

bool com_osxkernel_driver_IOKitTest::init (OSDictionary* dict)
{
    bool res = super::init(dict);
    return res;
}

void com_osxkernel_driver_IOKitTest::free (void)
{
    super::free();
}
//启动时设置与之交互的IOUserClientClass
bool com_osxkernel_driver_IOKitTest::start (IOService *provider)
{
    bool res = super::start(provider);
    setProperty("IOUserClientClass", "com_osxkernel_driver_IOKitTestUserClient");
    registerService();
    return res;
}

void com_osxkernel_driver_IOKitTest::stop (IOService *provider)
{
    super::stop(provider);
}

liuhailongdeMacBook-Air:~ liuhailong$ sudo chown -R root:wheel /Users/liuhailong/Library/Developer/Xcode/DerivedData/IOKitTest-dpmmsjcydkpiyxewowmltvnxxxgh/Build/Products/Debug/IOKitTest.kext 
liuhailongdeMacBook-Air:~ liuhailong$  sudo kextload /Users/liuhailong/Library/Developer/Xcode/DerivedData/IOKitTest-dpmmsjcydkpiyxewowmltvnxxxgh/Build/Products/Debug/IOKitTest.kext 
/Users/liuhailong/Library/Developer/Xcode/DerivedData/IOKitTest-dpmmsjcydkpiyxewowmltvnxxxgh/Build/Products/Debug/IOKitTest.kext failed to load - (libkern/kext) link error; check the system/kernel logs for errors or try kextutil(8).
liuhailongdeMacBook-Air:~ liuhailong$ sudo chown -R root:wheel /Users/liuhailong/Library/Developer/Xcode/DerivedData/IOKitTest-dpmmsjcydkpiyxewowmltvnxxxgh/Build/Products/Debug/IOKitTest.kext 
liuhailongdeMacBook-Air:~ liuhailong$  sudo kextload /Users/liuhailong/Library/Developer/Xcode/DerivedData/IOKitTest-dpmmsjcydkpiyxewowmltvnxxxgh/Build/Products/Debug/IOKitTest.kext 
liuhailongdeMacBook-Air:~ liuhailong$ /Users/liuhailong/Library/Developer/Xcode/DerivedData/UserSpaceClient-ffozqcnbwexasqelqqgpccijiicg/Build/Products/Debug/UserSpaceClient 
StopTimer - e00002cd
StartTimer - 00000000
GetElapsedTimerTime - 00000000, time 0
DelayForMs - 00000000
GetElapsedTimerTime - 00000000, time 100
GetElapsedTimerValue - 00000000, time 100170 / 1000000
DelayForTime - e00002c2
DelayForTime - 00000000
GetElapsedTimerTime - 00000000, time 600
StopTimer - 00000000
InstallTimer - 00000000
InstallTimer - 00000000
InstallTimer - 00000000
InstallTimer - 00000000
DelayCallback - refcon dead0002 and result 00000000
DelayCallback - refcon dead0005 and result 00000000
DelayCallback - refcon dead0007 and result 00000000
DelayCallback - refcon deadbeef and result 00000000
liuhailongdeMacBook-Air:~ liuhailong$

应用程序与驱动程序客服端方式交互

转载于:https://blog.51cto.com/haidragon/2164506

【AI智能体】Dify 基于知识库搭建智能客服问答应用详解
congge
07-16 4937
Dify 基于知识库搭建智能客服问答应用详解
TCP非堵塞IO的connect连接处理模型
xiaomiCJH的博客
07-29 440
一、非堵塞connect版本 当在非堵塞TCP套接字上， 我们调用connect函数会立刻返回EINPROGRESS， 不过此时TCP三路握手正在进行， 我们可以通过检查套接字的状态。 *非堵塞connect有三个用途 1）、我们可以把三路握手叠加到其他的处理上面。 因为在连接过程中花费1个RTT时间，在局域网或者广域网上的时间幅度偏差很大（几毫秒甚至几秒）， 那么我们可以利用这些时
增值税发票 基础驱动及应用客户端.rar
10-31
增值税发票综合服务平台基础驱动以及客户端程序 增值税发票综合服务平台基础驱动以及客户端程序
通过灰盒Fuzzing技术来发现Mac OS X安全漏洞
weixin_34293911的博客
03-08 508
vvun91e0n · 2015/07/17 9:30通过灰盒Fuzzing技术来发现Mac OS X安全漏洞翻译-原文地址：security.di.unimi.it/~joystick/pubs/eurosec14.pdf注：部分不太重要的没有翻译。0x01 前言内核是所有操作系统的核心，它的安全性非常重要。任何地方一个漏洞，都足以危害整个系统的安全。非特权用户如果找到这样的漏洞可以轻松的使整个...
exception EXC_RESOURCE - WAKEUPS 分析（二）
weixin_30244681的博客
09-21 3111
一、问题： 　　直播助手在使用ReplayKit2 Extension的过程中，ReplayKit2的Upload进程工作在后台模式，苹果对处于后台的进程进行了内存和CPU资源的限制。 　　对于内存： 　　　　每种Extension的限制不同，ReplayKit2 Extension 的内存限制是 Active Memory limit = 50MB， 如果使用的物理内存超过这个限...
用户空间与内核空间数据交换的方式
weixin_34236869的博客
12-24 151
1、编写自己的系统调用从前文可以看出，系统调用是用户级程序访问内核最基本的方法。目前linux大致提供了二百多个标准的系统调用（参见内核代码树中的include/asm-i386/unistd.h和arch/i386/kernel/entry.S文件），并且允许我们添加自己的系统调用来实现和内核的信息交换。比如我们希望建立一个系统调用日志系统，将所有的系统调用动作记录下来，...
iOS内核初探（别人的分析研究）
热门推荐
joosonmao的专栏
03-20 1万+
看标题就知道我下一步想干嘛了，坚持吧，发现现在已经到了关键时刻！     因为由于IOS内核的代码是不开源的。所以，我必须自己来挖掘和分析。IOS SDK不支持内核的调试。我利用反汇编工具IDA Pro来分析苹果系统的内核。 因为从IDA Pro6.2版本开始，已经完全支持苹果系统的反汇编。经过一些分析，IOS内核和程序开发人员最经常交互的模块是I/O Kit。 从反汇编的角度来看，I/O Ki
C#聊天程序，服务器端+客服端源码
06-17
在本资源中，我们拥有一个基于C#编写的聊天程序，包括了服务器端和客户端的完整源代码。这个程序提供了一个基本的实时通信框架，适用于学习C#网络编程或者构建简单的即时通讯应用。以下是该聊天程序的核心知识点和...
MFC对话框TCP客服端程序
01-20
在这个“MFC对话框TCP客服端程序”中，我们关注的是如何利用MFC构建一个基于对话框的应用程序，并实现TCP（Transmission Control Protocol）通信，以便与服务器端进行数据交互。 首先，TCP是一种面向连接的、可靠的...
oracle10g客服端
09-26
6. **ODAC (Oracle Data Access Components)**：对于开发人员来说，ODAC是Oracle与.NET应用程序交互的重要组件，它提供了ADO.NET驱动和其他相关库，使得开发者能够在C#、VB.NET等.NET环境中访问Oracle数据库。...
Go+Vue打印店远程打印小程序源码.rar
最新发布
11-23
这种小程序的设计可以为需要打印服务的用户提供便捷的解决方案，无论他们身在何处，只需通过小程序即可与打印店进行交互。 Go语言是一种编译型、静态类型语言，被设计得简单而高效，它非常适合用于服务器端的程序...
Mac osx 获取MAC网卡地址
征战无悔人生
06-22 3320
- (void)applicationDidFinishLaunching:(NSNotification *)aNotification { kern_return_t kr; CFMutableDictionaryRef matchDict; io_iterator_t iterator; io_registry_entry_t entry; matchDi
mac qt使用IOKit
qq_42095701的博客
03-22 685
mac qt使用IOKit
linux越狱80x24,通过沙盒逃逸和内核R/W导致RCE的iOS越狱漏洞
weixin_42566121的博客
05-25 741
简介该漏洞是由安全研究员(08Tc3wBB)在TyphoonPwn 2019上所演示，并获得了60000美元的奖励！漏洞描述这篇文章描述了iOS 12.3.1中发现的一系列漏洞，将这些漏洞组合在一起后，可以在内核的上下文中执行代码。CVECVE-2019-8797CVE-2019-8795CVE-2019-8794影响系统iOS 12.3.1漏洞分析虽然用户态可以访问一些内核的功能，但是由于iOS...
排查私有API
weixin_33737134的博客
03-03 162
一、排查问题 首先，来看一下上面的Apple发送的审核被拒原因邮件，其中提到了两个重要的点： 这次Apple审核，相对以往来说更为严格，以下提到的两个问题，在以往的版本迭代中，没有被拒绝过。 问题 ①： Additionally, your app uses or references the following non-public APIs: IOServiceMatchin...
Socket.io创建连接的参数
SalmonellaVaccine的专栏
08-06 2265
http://www.kazaff.me/2014/03/12/socket-io%E5%88%9B%E5%BB%BA%E8%BF%9E%E6%8E%A5%E7%9A%84%E5%8F%82%E6%95%B0/ 我不想花太多口舌向你推销Socket.io，因为我根本就不够资格，也因为根本就不需要，Socket.io目前在Websocket界中的霸主地位就好比当年的PHP~ 写这
mina学习笔记三：一切的源头IoService
Yoara的备忘录
07-07 1万+
IoService介绍 从上节的例子
mac ox驱动开发 c++版
weixin_33897722的博客
08-25 808
//IOKitTest.h #include <IOKit/IOService.h> class com_osxkernel_driver_IOKitTest : public IOService { OSDeclareDefaultStructors(com_osxkernel_driver_IOKitTest) public: virtual bool ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值