void Dispatch(void){
    // skipped
    while (!dispatchException) {
        if (InputCheckPending()) {
            // 处理输入事件
            ProcessInputEvents();
            // 处理输入事件时产生关键事件等，在此发送
            FlushIfCriticalOutputPending();
        }
        // 阻塞等待，当client请求，输入事件，视频事件等发生时返回
        if (!WaitForSomething(clients_are_ready()))
            continue;
        // client请求处理
        if (!dispatchException && clients_are_ready()) {
            // 分发处理无异常且有client请求，选择其中一个client处理
            client = SmartScheduleClient();
            isItTimeToYield = FALSE;
            start_tick = SmartScheduleTime;
            // client出错，优先级改变，处理事件过长等，都会结束循环
            while (!isItTimeToYield) {
                // 处理键盘，鼠标等输入事件
                if (InputCheckPending())
                    ProcessInputEvents();
                FlushIfCriticalOutputPending();
                // 分时调度，处理单个client时间过长（15ms时间片），降低其优先级，且重新调度
                if ((SmartScheduleTime - start_tick) >= SmartScheduleSlice){
                    if (client->smart_priority > SMART_MIN_PRIORITY)
                        client->smart_priority--;
                    break;
                }
                // 读取client请求信息，返回请求长度，result为0，请求处理完成，进行下一个调度
                result = ReadRequestFromClient(client);
                if (result <= 0) {
                    if (result < 0)
                        CloseDownClient(client);
                    break;
                }
                client->sequence++;
                client->majorOp = ((xReq *) client->requestBuffer)->reqType;
                client->minorOp = 0;
                if (client->majorOp >= EXTENSION_BASE) {
                    // 扩展协议请求，获取扩展协议的操作码minorOp，以区分请求类型
                    ExtensionEntry *ext = GetExtensionEntry(client->majorOp);
                    if (ext)
                        client->minorOp = ext->MinorOpcode(client);
                }
                // 请求长度过大，不符合规范
                if (result > (maxBigRequestSize << 2))
                    result = BadLength;
                else {
                    result = XaceHookDispatch(client, client->majorOp);
                    if (result == Success) {
                        currentClient = client;
                        // 处理请求
                        result = (*client->requestVector[client->majorOp]) (client);
                        currentClient = NULL;
                    }
                }
                // 更新client运行时间，可能使用timer更新事件（SIGALRM）
                if (!SmartScheduleSignalEnable)
                    SmartScheduleTime = GetTimeInMillis();

                if (client->noClientException != Success) {
                    // client异常，关闭该client
                    CloseDownClient(client);
                    break;
                }
                else if (result != Success) {
                    // 处理请求失败，发送错误码给client，如：BadLength
                    SendErrorToClient(client, client->majorOp, client->minorOp, client->errorValue, result);
                    break;
                }
            }
            // 发送请求回复或者事件
            FlushAllOutput();
            if (client == SmartLastClient)
                client->smart_stop_tick = SmartScheduleTime;
        }
        // 若client改变了自己的优先级，则需重新调度client
        dispatchException &= ~DE_PRIORITYCHANGE;
    }
    // server被重置，则进入下一轮运行。server被中断，则退出执行
    KillAllClients();
    dispatchException &= ~DE_RESET;
    SmartScheduleLatencyLimited = 0;
    ResetOsBuffers();
}

// are_ready是否有输入事件
// 等待和处理定时任务。出错或有事件需处理时返回
Bool WaitForSomething(Bool are_ready){
    // skipped
    timer_is_running = were_ready;
    if (were_ready && !are_ready) {
        // 无输入事件，停止调度定时器
        timer_is_running = FALSE;
        SmartScheduleStopTimer();
    }
    were_ready = FALSE;
    busfault_check();
    while (1) {
        // 执行工作队列中的处理函数
        ProcessWorkQueue();
        // 处理定时任务，返回下次超时时间
        timeout = check_timers();
        // 检查是否有设备的输入事件
        are_ready = clients_are_ready();
        if (are_ready)
            timeout = 0; // 有输入事件等待处理，即时返回
        // 阻塞任务，通过超时处理，可能会修改timeout时间
        BlockHandler(&timeout);
        if (NewOutputPending)
            FlushAllOutput();
        /* keep this check close to select() call to minimize race */
        if (dispatchException)
            i = -1; // 出现异常
        else
            i = ospoll_wait(server_poll, timeout);
        pollerr = GetErrno();
        // 执行操作
        WakeupHandler(i);
        if (i <= 0) {           /* An error or timeout occurred */
            if (dispatchException)
                return FALSE;
            // skipped
        } else
            are_ready = clients_are_ready();
        // 有设备输入事件
        if (InputCheckPending())
            return FALSE;
        if (are_ready) {
            were_ready = TRUE;
            if (!timer_is_running)
                SmartScheduleStartTimer(); // 启动调度计时器，5ms为一个时间片
            return TRUE;
        }
    }
}

// 选择一个client，处理该client的请求
static ClientPtr SmartScheduleClient(void);

void InitOutput(ScreenInfo * screen_info, int argc, char **argv);

void InitInput(int argc, char **argv);

void ProcessInputEvents(void);

void ddxGiveUp(enum ExitCode error);

Bool (*pfnInit) (ScreenPtr pScreen, int argc, char **argv);

// 加载和卸载模块函数
typedef void *(*ModuleSetupProc) (void *, void *, int *, int *);
typedef void (*ModuleTearDownProc) (void *);

// 模块描述
/* This structure is expected to be returned by the initfunc */
typedef struct {
    const char *modname;        /* name of module, e.g. "foo" */
    const char *vendor;         /* vendor specific string */
    CARD32 _modinfo1_;          /* constant MODINFOSTRING1/2 to find */
    CARD32 _modinfo2_;          /* infoarea with a binary editor or sign tool */
    CARD32 xf86version;         /* contains XF86_VERSION_CURRENT */
    CARD8 majorversion;         /* module-specific major version */
    CARD8 minorversion;         /* module-specific minor version */
    CARD16 patchlevel;          /* module-specific patch level */
    const char *abiclass;       /* ABI class that the module uses */
    CARD32 abiversion;          /* ABI version */
    const char *moduleclass;    /* module class description */
    CARD32 checksum[4];         /* contains a digital signature of the version info structure */
} XF86ModuleVersionInfo;

typedef struct {
    XF86ModuleVersionInfo *vers;
    ModuleSetupProc setup;
    ModuleTearDownProc teardown;
} XF86ModuleData;

typedef Bool xorgDriverFuncProc(ScrnInfoPtr, xorgDriverFuncOp, void *);
// 驱动描述，包括探测函数的实现
typedef struct _DriverRec {
    int driverVersion;
    const char *driverName;
    void (*Identify) (int flags);
    Bool (*Probe) (struct _DriverRec * drv, int flags);
    const OptionInfoRec *(*AvailableOptions) (int chipid, int bustype);
    void *module;
    int refCount;
    xorgDriverFuncProc *driverFunc;

    const struct pci_id_match *supported_devices;
    Bool (*PciProbe) (struct _DriverRec * drv, int entity_num,
                      struct pci_device * dev, intptr_t match_data);
    Bool (*platformProbe) (struct _DriverRec * drv, int entity_num, int flags,
                           struct xf86_platform_device * dev, intptr_t match_data);
} DriverRec, *DriverPtr;

// 注册和卸载驱动函数
void xf86AddDriver(DriverPtr driver, void *module, int flags);
void xf86DeleteDriver(int drvIndex);

typedef Bool xf86ProbeProc(DriverPtr, int);
typedef Bool xf86PreInitProc(ScrnInfoPtr, int);
typedef Bool xf86ScreenInitProc(ScreenPtr, int, char **);
typedef Bool xf86SwitchModeProc(ScrnInfoPtr, DisplayModePtr);
typedef void xf86AdjustFrameProc(ScrnInfoPtr, int, int);
typedef Bool xf86EnterVTProc(ScrnInfoPtr);
typedef void xf86LeaveVTProc(ScrnInfoPtr);
typedef void xf86FreeScreenProc(ScrnInfoPtr);
typedef ModeStatus xf86ValidModeProc(ScrnInfoPtr, DisplayModePtr, Bool, int);
typedef void xf86EnableDisableFBAccessProc(ScrnInfoPtr, Bool);
typedef int xf86SetDGAModeProc(ScrnInfoPtr, int, DGADevicePtr);
typedef int xf86ChangeGammaProc(ScrnInfoPtr, Gamma);
typedef void xf86PointerMovedProc(ScrnInfoPtr, int, int);
typedef Bool xf86PMEventProc(ScrnInfoPtr, pmEvent, Bool);
typedef void xf86DPMSSetProc(ScrnInfoPtr, int, int);
typedef void xf86LoadPaletteProc(ScrnInfoPtr, int, int *, LOCO *, VisualPtr);
typedef void xf86SetOverscanProc(ScrnInfoPtr, int);
typedef void xf86ModeSetProc(ScrnInfoPtr);

// 扩展协议注册接口
extern _X_EXPORT ExtensionEntry *
AddExtension(const char * /*name */ ,
             int /*NumEvents */ ,
             int /*NumErrors */ ,
             int (* /*MainProc */ )(ClientPtr /*client */ ),
             int (* /*SwappedMainProc */ )(ClientPtr /*client */ ),
             void (* /*CloseDownProc */ )(ExtensionEntry * /*extension */ ),
             unsigned short (* /*MinorOpcodeProc */ )(ClientPtr /*client */ )
    );

// 扩展初始化函数，主要需注册扩展协议的请求和事件
typedef void (*InitExtension) (void);

// 扩展协议描述结构
typedef struct {
    InitExtension initFunc; // 初始化函数地址
    const char *name;       // 扩展协议名称
    Bool *disablePtr;       // 是否禁用该协议，可动态指定
} ExtensionModule;

// fd：文件句柄，如：socket，dbus，device，netlink，udev monitor，drm等
// notify：事件处理函数
// mask：请求事件，如：读或写；为0时表示注销
// data：传递给事件处理函数参数
Bool SetNotifyFd(int fd, NotifyFdProcPtr notify, int mask, void *data);

// fd：同上
// ready：响应事件（X_NOTIFY_READ、X_NOTIFY_READ或X_NOTIFY_ERROR）
// data：同上
typedef void (*NotifyFdProcPtr)(int fd, int ready, void *data);

// xfree86注册函数
typedef void (*InputHandlerProc) (int fd, void *data);
// 输入设备IO处理函数
void *xf86AddInputHandler(int fd, InputHandlerProc proc, void *data);
// 其它设备处理函数，如：显示器差别，电源管理等
void *xf86AddGeneralHandler(int fd, InputHandlerProc proc, void *data);

// 回复请求或者发送事件
void FlushAllOutput(void);

// 输入线程管理的设备队列
static InputThreadInfo *inputThreadInfo;
// 新增设备，将设备加入队列中，并通知IO线程处理新设备
void xf86AddEnabledDevice(InputInfoPtr pInfo){
    InputThreadRegisterDev(pInfo->fd, xf86ReadInput, pInfo);
}

// 输入设备IO线程处理函数
static void *InputThreadDoWork(void *arg);

// InternalEvent事件循环队列，可动态加减
static EventQueueRec miEventQueue;
// 事件插入队列函数
void mieqEnqueue(DeviceIntPtr pDev, InternalEvent *e);

// 工作队列
WorkQueuePtr workQueue;

// 注册处理函数至工作队列
// function：处理函数
// closure：传递给处理函数参数
Bool QueueWorkProc(Bool (*function) (ClientPtr pClient, void *closure), ClientPtr client, void *closure);

// 执行工作队列处理函数，处理请求事件后调用
void ProcessWorkQueue(void);

// 在epoll之前调用所有的Server和Screen的BlockHandler，可能会调整pTimeout的值
void BlockHandler(void *pTimeout);
// 在epoll之后调用所有的Server和Screen的WakeupHandler
// result：小于0表示出错；等于0表示超时；大于0表示epoll时间数。
void WakeupHandler(int result);

// timeout下次超时时间，BlockHandler回调函数可能会更新timeout时间
// result：<0 - error；=0 - timeout；>0 - activity（poll事件数）
// 屏幕相关的处理函数
typedef void (*ScreenBlockHandlerProcPtr) (ScreenPtr pScreen, void *timeout);
typedef void (*ScreenWakeupHandlerProcPtr) (ScreenPtr pScreen, int result);

// 系统（server）相关的处理函数
static BlockHandlerPtr handlers;
typedef void (*ServerBlockHandlerProcPtr) (void *blockData, void *timeout);
typedef void (*ServerWakeupHandlerProcPtr) (void *blockData, int result);
Bool RegisterBlockAndWakeupHandlers(ServerBlockHandlerProcPtr blockHandler,
                               ServerWakeupHandlerProcP tr wakeupHandler,
                               void *blockData);