Hypervisor Display架构

Hypervisor Display架构部分

1，所有LA侧的APP与显示相关的调用最终都会交由SurfaceFlinger处理

2，SurfaceFlinger会最终调用[email protected]服务

3，[email protected]服务会调用GPU&DRM&Qcom的一些列库文件（很遗憾这些库相当一大部分源码是不开源的）

4，libdrm库调用open/ioctl等函数会经过lib_drm_fe库的转接，当然lib_drm_fe会做很多其他适配的工作

5，lib_drm_fe会调用内核HGSL驱动中的hab通信接口与QNX侧的wfd_be服务进行通信

6，wfd_be服务会解析接收到的LA侧的数据包

7，根据数据包中的命令类型调用不同的openwfd接口，需要注意的是，这里的接口是做了一层转换的，举个例子wfdEnumerateDevices_Host，这个接口会进行转换之后真正调用wfdEnumerateDevices函数

8，所有的操作都执行完成之后，如果有必要会唤醒wfd_be的commit&vsync现场，通知openwfd刷新画面

lib_drm_fe会调用内核HGSL驱动中的hab通信接口与QNX侧的wfd_be服务进行通信

 sa8295 dtsi配置

direwolf-vm.dtsi
msm_gpu_hyp: qcom,hgsl@0x3d00000 {
                compatible = "qcom,hgsl";
                reg = <0x3d00000 0x8>, <0x3d8f000 0x4>;
                reg-names = "hgsl_reg_hwinf", "hgsl_reg_gmucx";

                qcom,glb-db-senders = <&hgsl_tcsr_sender0
                                        &hgsl_tcsr_sender1>;
                qcom,glb-db-receivers = <&hgsl_tcsr_receiver0
                                        &hgsl_tcsr_receiver1>;
        };

kernel/msm-5.4/drivers/soc/qcom/hgsl/hgsl 设备树匹配

static const struct of_device_id qcom_hgsl_of_match[] = {
        { .compatible = "qcom,hgsl" },
        {}
};
MODULE_DEVICE_TABLE(of, qcom_hgsl_of_match);

static struct platform_driver qcom_hgsl_driver = {
        .probe = qcom_hgsl_probe,
        .remove = qcom_hgsl_remove,
        .driver  = {
                .name  = "qcom-hgsl",
                .of_match_table = qcom_hgsl_of_match,
        },
};
module_platform_driver(qcom_hgsl_driver);

lagvm/LINUX/android/kernel/msm-5.4/drivers/soc/qcom/hgsl/hgsl.c

static int qcom_hgsl_probe(struct platform_device *pdev)
{
        struct qcom_hgsl *hgsl_dev;
        int ret;
        int i;

        hgsl_dev = devm_kzalloc(&pdev->dev, sizeof(*hgsl_dev), GFP_KERNEL);
        if (!hgsl_dev)
                return -ENOMEM;

        hgsl_dev->dev = &pdev->dev;

        ret = qcom_hgsl_register(pdev, hgsl_dev);
        if (ret < 0) {
                dev_err(&pdev->dev, "qcom_hgsl_register failed, ret %d\n",
                                                                        ret);
                return ret;
        }

        ret = hgsl_init_context(hgsl_dev);
        if (ret < 0) {
                dev_err(&pdev->dev, "hgsl_init_context failed, ret %d\n",
                                                                        ret);
                goto exit_dereg;
        }
        //创建hgsl-release-wq workqueue
        ret = hgsl_init_release_wq(hgsl_dev);
        if (ret < 0) {
                dev_err(&pdev->dev, "hgsl_init_release_wq failed, ret %d\n",
                                                                        ret);
                goto exit_dereg;
        }

        hgsl_dev->db_off = hgsl_is_db_off(pdev);
        idr_init(&hgsl_dev->isync_timeline_idr);
        spin_lock_init(&hgsl_dev->isync_timeline_lock);

        for (i = 0; i < MAX_DB_QUEUE; i++) {
                mutex_init(&hgsl_dev->dbq[i].lock);
                hgsl_dev->dbq[i].state = DB_STATE_Q_UNINIT;
        }

        if (!hgsl_dev->db_off)
                hgsl_init_global_hyp_channel(hgsl_dev);

        platform_set_drvdata(pdev, hgsl_dev);

        return 0;

exit_dereg:
        qcom_hgsl_deregister(pdev);
        return ret;
}

 

static int qcom_hgsl_register(struct platform_device *pdev,
                                struct qcom_hgsl *hgsl_dev)
{
        int ret;

        ret = alloc_chrdev_region(&hgsl_dev->device_no, 0,
                                                HGSL_DEV_NUM,
                                                HGSL_DEVICE_NAME);
        if (ret < 0) {
                dev_err(&pdev->dev, "alloc_chrdev_region failed %d\n", ret);
                return ret;
        }
       //创建一个hgsl class节点
        hgsl_dev->driver_class = class_create(THIS_MODULE, HGSL_DEVICE_NAME);
        if (IS_ERR(hgsl_dev->driver_class)) {
                ret = -ENOMEM;
                dev_err(&pdev->dev, "class_create failed %d\n", ret);
                goto exit_unreg_chrdev_region;
        }
       //创建一个hgsl 设备
        hgsl_dev->class_dev = device_create(hgsl_dev->driver_class,
                                        NULL,
                                        hgsl_dev->device_no,
                                        hgsl_dev, HGSL_DEVICE_NAME);

        if (IS_ERR(hgsl_dev->class_dev)) {
                dev_err(&pdev->dev, "class_device_create failed %d\n", ret);
                ret = -ENOMEM;
                goto exit_destroy_class;
        }
        //注册hgsl 设备操作接口
        cdev_init(&hgsl_dev->cdev, &hgsl_fops);

        hgsl_dev->cdev.owner = THIS_MODULE;
        //注册hgsl设备
        ret = cdev_add(&hgsl_dev->cdev,
                                        MKDEV(MAJOR(hgsl_dev->device_no), 0),
                                        1);
        if (ret < 0) {
                dev_err(&pdev->dev, "cdev_add failed %d\n", ret);
                goto exit_destroy_device;
        }

        ret = dma_coerce_mask_and_coherent(hgsl_dev->dev, DMA_BIT_MASK(64));
        if (ret)
                LOGW("Failed to set dma mask to 64 bits, ret = %d", ret);

        return 0;

exit_destroy_device:
        device_destroy(hgsl_dev->driver_class, hgsl_dev->device_no);
exit_destroy_class:
        class_destroy(hgsl_dev->driver_class);
exit_unreg_chrdev_region:
        unregister_chrdev_region(hgsl_dev->device_no, 1);
        return ret;
}

 

设备注册的操作接口hgsl_fops

static const struct file_operations hgsl_fops = {
        .owner = THIS_MODULE,
        .open = hgsl_open,
        .release = hgsl_release,
        .read = hgsl_read,
        .unlocked_ioctl = hgsl_ioctl,
        .compat_ioctl = hgsl_compat_ioctl
};

 

static int hgsl_open(struct inode *inodep, struct file *filep)
{
        struct hgsl_priv *priv = hgsl_zalloc(sizeof(*priv));
        struct qcom_hgsl  *hgsl = container_of(inodep->i_cdev,
                                               struct qcom_hgsl, cdev);
        //获取当前进程的pid 和task_struct
        struct pid *pid = task_tgid(current);
        struct task_struct *task = pid_task(pid, PIDTYPE_PID);
        int ret = 0;

        if (!priv)
                return -ENOMEM;

        if (!task) {
                ret = -EINVAL;
                goto out;
        }

        INIT_LIST_HEAD(&priv->mem_mapped);
        INIT_LIST_HEAD(&priv->mem_allocated);
        mutex_init(&priv->lock);
        priv->pid = task_pid_nr(task);
        
        ret = hgsl_hyp_init(&priv->hyp_priv, hgsl->dev,
                priv->pid, task->comm);
        if (ret != 0)
                goto out;

        priv->dev = hgsl;
        filep->private_data = priv;

out:
        if (ret != 0)
                kfree(priv);
        return ret;
}

 

int hgsl_hyp_init(struct hgsl_hyp_priv_t *priv, struct device *dev,
        int client_pid, const char * const client_name)
{
        priv->dev = dev;
        return hgsl_hyp_channel_pool_init(priv, client_pid, client_name);
}

//将task_struct 信息与hgsl_hyp_priv_t 绑定
static int hgsl_hyp_channel_pool_init(struct hgsl_hyp_priv_t *priv,
        int client_pid, const char * const client_name)
{
        INIT_LIST_HEAD(&priv->free_channels);
        INIT_LIST_HEAD(&priv->busy_channels);
        mutex_init(&priv->lock);
        priv->conn_id = 0;
        strlcpy(priv->client_name, client_name, sizeof(priv->client_name));
        priv->client_pid = client_pid;
        idr_init(&priv->channel_idr);

        LOGD("pid %d, task name %s"
                , (int) priv->client_pid, priv->client_name);

        return 0;
}

Libgsl 会使与驱动hgsl交互

static long hgsl_compat_ioctl(struct file *filep, unsigned int cmd,
        unsigned long arg)
{
        return hgsl_ioctl(filep, cmd, arg);
}

static long hgsl_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
{
        int ret;

        switch (cmd) {
        case HGSL_IOCTL_ISSUE_IB:
                ret = hgsl_ioctl_issueib(filep, arg);
                break;
        case HGSL_IOCTL_CTXT_CREATE:
                ret = hgsl_ioctl_ctxt_create(filep, arg);
                break;
        case HGSL_IOCTL_CTXT_DESTROY:
                ret = hgsl_ioctl_ctxt_destroy(filep, arg);
                break;
        case HGSL_IOCTL_WAIT_TIMESTAMP:
                ret = hgsl_ioctl_wait_timestamp(filep, arg);
                break;
        case HGSL_IOCTL_READ_TIMESTAMP:
                ret = hgsl_ioctl_read_timestamp(filep, arg);
                break;
        case HGSL_IOCTL_CHECK_TIMESTAMP:
                ret = hgsl_ioctl_check_timestamp(filep, arg);
                break;
        case HGSL_IOCTL_HYP_GENERIC_TRANSACTION:
                ret = hgsl_ioctl_hyp_generic_transaction(filep, arg);
                break;
        case HGSL_IOCTL_GET_SHADOWTS_MEM:
                ret = hgsl_ioctl_get_shadowts_mem(filep, arg);
                break;
        case HGSL_IOCTL_PUT_SHADOWTS_MEM:
                ret = hgsl_ioctl_put_shadowts_mem(filep, arg);
                break;
        case HGSL_IOCTL_MEM_ALLOC:
                ret = hgsl_ioctl_mem_alloc(filep, arg);
                break;
        case HGSL_IOCTL_MEM_FREE:
                ret = hgsl_ioctl_mem_free(filep, arg);
                break;
        case HGSL_IOCTL_MEM_MAP_SMMU:
                ret = hgsl_ioctl_mem_map_smmu(filep, arg);
                break;
        case HGSL_IOCTL_MEM_UNMAP_SMMU:
                ret = hgsl_ioctl_mem_unmap_smmu(filep, arg);
                break;
        case HGSL_IOCTL_MEM_CACHE_OPERATION:
                ret = hgsl_ioctl_mem_cache_operation(filep, arg);
                break;
        case HGSL_IOCTL_ISSUIB_WITH_ALLOC_LIST:
                ret = hgsl_ioctl_issueib_with_alloc_list(filep, arg);
                break;
        case HGSL_IOCTL_GET_SYSTEM_TIME:
                ret = hgsl_ioctl_get_system_time(filep, arg);
                break;
        case HGSL_IOCTL_SYNCOBJ_WAIT_MULTIPLE:
                ret = hgsl_ioctl_syncobj_wait_multiple(filep, arg);
                break;
        case HGSL_IOCTL_PERFCOUNTER_SELECT:
                ret = hgsl_ioctl_perfcounter_select(filep, arg);
                break;
        case HGSL_IOCTL_PERFCOUNTER_DESELECT:
                ret = hgsl_ioctl_perfcounter_deselect(filep, arg);
                break;
        case HGSL_IOCTL_PERFCOUNTER_QUERY_SELECTION:
                ret = hgsl_ioctl_perfcounter_query_selection(filep, arg);
                break;
        case HGSL_IOCTL_PERFCOUNTER_READ:
                ret = hgsl_ioctl_perfcounter_read(filep, arg);
                break;
        case HGSL_IOCTL_SET_METAINFO:
                ret = hgsl_ioctl_set_metainfo(filep, arg);
                break;
        case HGSL_IOCTL_HSYNC_FENCE_CREATE:
                ret = hgsl_ioctl_hsync_fence_create(filep, arg);
                break;
        case HGSL_IOCTL_ISYNC_TIMELINE_CREATE:
                ret = hgsl_ioctl_isync_timeline_create(filep, arg);
                break;
        case HGSL_IOCTL_ISYNC_TIMELINE_DESTROY:
                ret = hgsl_ioctl_isync_timeline_destroy(filep, arg);
                break;
        case HGSL_IOCTL_ISYNC_FENCE_CREATE:
                ret = hgsl_ioctl_isync_fence_create(filep, arg);
                break;
        case HGSL_IOCTL_ISYNC_FENCE_SIGNAL:
                ret = hgsl_ioctl_isync_fence_signal(filep, arg);
                break;
        case HGSL_IOCTL_ISYNC_FORWARD:
                ret = hgsl_ioctl_isync_forward(filep, arg);
                break;
        case HGSL_IOCTL_TIMELINE_CREATE:
                ret = hgsl_ioctl_timeline_create(filep, arg);
                break;
        case HGSL_IOCTL_TIMELINE_SIGNAL:
                ret = hgsl_ioctl_timeline_signal(filep, arg);
                break;
        case HGSL_IOCTL_TIMELINE_QUERY:
                ret = hgsl_ioctl_timeline_query(filep, arg);
                break;
        case HGSL_IOCTL_TIMELINE_WAIT:
                ret = hgsl_ioctl_timeline_wait(filep, arg);
                break;

        default:
                ret = -ENOIOCTLCMD;
        }

        return ret;
}

static int hgsl_ioctl_ctxt_create(struct file *filep, unsigned long arg)
{
        struct hgsl_priv *priv = filep->private_data;
        struct qcom_hgsl *hgsl = priv->dev;
        struct hgsl_ioctl_ctxt_create_params params;
        struct hgsl_context *ctxt = NULL;
        int ret = 0;
        struct hgsl_hab_channel_t *hab_channel = NULL;
        bool ctxt_created = false;

        if (copy_from_user(¶ms, USRPTR(arg), sizeof(params))) {
                LOGE("failed to copy params from user");
                ret = -EFAULT;
                return ret;
        }
         //建立hab socket
        ret = hgsl_hyp_channel_pool_get(&priv->hyp_priv, 0, &hab_channel);
        if (ret) {
                LOGE("Failed to get hab channel %d", ret);
                goto out;
        }

        ctxt = hgsl_zalloc(sizeof(*ctxt));
        if (ctxt == NULL) {
                ret = -ENOMEM;
                return ret;
        }

        if (params.flags & GSL_CONTEXT_FLAG_CLIENT_GENERATED_TS)
                params.flags |= GSL_CONTEXT_FLAG_USER_GENERATED_TS;

        if (params.flags & GSL_CONTEXT_FLAG_BIND) {
                params.flags &= ~GSL_CONTEXT_FLAG_CLIENT_GENERATED_TS;
                params.flags |= GSL_CONTEXT_FLAG_USER_GENERATED_TS;
        }
         //使用hab socket发送数据
        ret = hgsl_hyp_ctxt_create(hab_channel, ¶ms);
        if (ret)
                goto out;

        if (params.ctxthandle >= HGSL_CONTEXT_NUM) {
                LOGE("invalid ctxt id %d", params.ctxthandle);
                ret = -EINVAL;
                goto out;
        }

        ctxt->context_id = params.ctxthandle;
        ctxt->devhandle = params.devhandle;
        ctxt->pid = priv->pid;
        ctxt->priv = priv;
        ctxt->flags = params.flags;
        hgsl_get_shadowts_mem(hab_channel, ctxt);
        if (hgsl->global_hyp_inited && !hgsl->db_off)
                hgsl_ctxt_create_dbq(priv, hab_channel, ctxt);

        kref_init(&ctxt->kref);
        init_waitqueue_head(&ctxt->wait_q);

        write_lock(&hgsl->ctxt_lock);
        if (hgsl->contexts[ctxt->context_id] != NULL) {
                LOGE("context id %d already created",
                        ctxt->context_id);
                ret = -EBUSY;
                write_unlock(&hgsl->ctxt_lock);
                goto out;
        }

        hgsl->contexts[ctxt->context_id] = ctxt;
        write_unlock(&hgsl->ctxt_lock);
        ctxt_created = true;

        if (hgsl_ctxt_use_global_dbq(ctxt)) {
                ret = hgsl_hsync_timeline_create(ctxt);
                if (ret < 0)
                        LOGE("hsync timeline failed for context %d", params.ctxthandle);
        }

        if (ctxt->timeline)
                params.sync_type = HGSL_SYNC_TYPE_HSYNC;
        else
                params.sync_type = HGSL_SYNC_TYPE_ISYNC;

        if (copy_to_user(USRPTR(arg), ¶ms, sizeof(params))) {
                ret = -EFAULT;
                goto out;
        }

out:
        LOGD("%d", params.ctxthandle);
        if (ret) {
                if (ctxt_created)
                        hgsl_ctxt_destroy(priv, hab_channel, params.ctxthandle, NULL, false);
                else if (ctxt && (params.ctxthandle < HGSL_CONTEXT_NUM)) {
                        _unmap_shadow(ctxt);
                        hgsl_hyp_put_shadowts_mem(hab_channel, &ctxt->shadow_ts_node);
                        hgsl_hyp_ctxt_destroy(hab_channel, ctxt->devhandle, ctxt->context_id, NULL);
                        kfree(ctxt);
                }
                LOGE("failed to create context");
        }

        hgsl_hyp_channel_pool_put(hab_channel);
        return ret;
}

int hgsl_hyp_channel_pool_get(
        struct hgsl_hyp_priv_t *priv, int id, struct hgsl_hab_channel_t **channel)
{
        struct hgsl_hab_channel_t *hab_channel = NULL;
        int ret = 0;

        if (!channel)
                return -EINVAL;

        mutex_lock(&priv->lock);
        if (id) {
                ret = hgsl_hyp_channel_pool_get_by_id(priv, id, &hab_channel);
                if (ret)
                        LOGE("Failed to find channel %d, ret %d", id, ret);
        } else {
                if (list_empty(&priv->free_channels)) {
                        //创建一个channel 
                        ret = hgsl_rpc_create_channel(priv, &hab_channel);
                        LOGD("hgsl_rpc_create_channel returned, ret %d hab_channel %p",
                                ret, hab_channel);
                } else {
                        hab_channel = container_of(priv->free_channels.next,
                                struct hgsl_hab_channel_t, node);
                        if (hab_channel != NULL) {
                                list_del(&hab_channel->node);
                                LOGD("get %p from free pool", hab_channel);
                        } else {
                                ret = -EINVAL;
                                LOGE("invalid hab_channel in the list");
                        }
                }

                if (!ret)
                        list_add_tail(&hab_channel->node, &priv->busy_channels);
        }

        if (!ret) {
                *channel = hab_channel;
                hab_channel->busy = true;
        }
        mutex_unlock(&priv->lock);

        if ((!ret) && (!id)) {
                ret = hgsl_rpc_parcel_reset(hab_channel);
                if (ret) {
                        LOGE("hgsl_rpc_parcel_reset failed %d", ret);
                        hgsl_hyp_channel_pool_put(hab_channel);
                        hab_channel = NULL;
                }
        }

        return ret;
}

创建hab_channel

static int hgsl_rpc_create_channel(
        struct hgsl_hyp_priv_t *priv,
        struct hgsl_hab_channel_t **channel)
{
        int socket = HAB_INVALID_HANDLE;
        int ret = -ENOMEM;
        struct hgsl_hab_channel_t *hab_channel
                = (struct hgsl_hab_channel_t *)hgsl_zalloc(
                                        sizeof(struct hgsl_hab_channel_t));

        if (hab_channel == NULL) {
                LOGE("Failed to allocate hab_channel");
                goto out;
        }

        hab_channel->socket = HAB_INVALID_HANDLE;
        hab_channel->priv = priv;
        hab_channel->busy = false;
        hab_channel->wait_retry = false;
        hab_channel->id = idr_alloc(&priv->channel_idr, hab_channel,
                                                                1, 0, GFP_NOWAIT);
        if (hab_channel->id < 0) {
                LOGE("Failed to allocate id for hab channel");
                ret = hab_channel->id;
                goto out;
        }
        //初始化hab_channel
        ret = hgsl_rpc_parcel_init(hab_channel);
        if (ret) {
                LOGE("Failed to init parcel");
                goto out;
        }
         //创建hab socket
        if (priv->conn_id == 0) {
 
                ret = hgsl_rpc_connect(priv, &socket);
                if (ret) {
                        LOGE("Failed to open socket %d", ret);
                        goto out;
                }
                hab_channel->socket = socket;
                //进行数据通讯
                ret = rpc_handshake(priv, hab_channel);
                if (ret)
                        LOGE("rpc_handshake failed %d", ret);
                gsl_hab_close(socket);
                hab_channel->socket = HAB_INVALID_HANDLE;
        }

        ret = hgsl_rpc_connect(priv, &socket);
        if (ret) {
                LOGE("Failed to open socket %d", ret);
                goto out;
        }
        hab_channel->socket = socket;
        ret = rpc_sub_handshake(priv, hab_channel);
        if (ret) {
                LOGE("sub handshake failed %d", ret);
                gsl_hab_close(socket);
                hab_channel->socket = HAB_INVALID_HANDLE;
        }

out:
        if (ret) {
                LOGE("Failed to create channel %d exiting", ret);
                if (hab_channel != NULL) {
                        hgsl_hyp_close_channel(hab_channel);
                        hab_channel = NULL;
                }
        } else {
                *channel = hab_channel;
        }
        return ret;
}

static int hgsl_rpc_connect(struct hgsl_hyp_priv_t *priv, int *socket)
{
        int err = 0;
        int tmp_socket = priv->conn_id;

        LOGI("connecting using conn_id %d", tmp_socket);
        err = gsl_hab_open(&tmp_socket);

        LOGI("socket_open err %d, socket %d", err, tmp_socket);
        *socket = tmp_socket;

        return err;
}

int gsl_hab_open(int *habfd)
{
        int ret = 0;

        ret = habmm_socket_open(habfd
                        , HAB_MMID_CREATE(MM_GFX, (int)*habfd)
                        , HAB_OPEN_WAIT_TIMEOUT_MS
                        , HABMM_SOCKET_OPEN_FLAGS_SINGLE_BE_SINGLE_FE);

        LOGD("habmm_socket_open returned with %d, %x", ret, *habfd);

        return ret;
}

根据p->data_pos获取recv到的数据
 #define GSL_RPC_READ_ARG(p, id, p_arg, type) \
152  ({ \
153          void *p_arg_data = NULL; \
154          int ret = gsl_rpc_get_arg_ptr(p, id, &p_arg_data, sizeof(type)); \
155          if (ret == 0) { \
156                  *p_arg = *((type *)p_arg_data); \
157          } \
158  \
159          ret; \
160  })

static inline int gsl_rpc_get_arg_ptr(struct gsl_hab_payload *p,
105          uint32_t id, void **p_data, size_t size)
106  {
107          int ret = -EINVAL;
108  
109          if ((p->data_pos + size + gsl_rpc_header_size) <= p->data_size) {
110                  struct gsl_rpc_header_t *hdr
111                          = (struct gsl_rpc_header_t *)(p->data + p->data_pos);
112  
113                  if ((hdr->magic == GSL_HAB_DATA_MAGIC) &&
114                          (hdr->id == id) && (hdr->size == size)) {
115                          struct gsl_rpc_footer_t *footer = NULL;
116                          uint32_t checksum;
117  
118                          checksum = gsl_rpc_gen_checksum(&hdr->data, hdr->size);
119                          *p_data = (void *)&hdr->data;
120                          p->data_pos += size + gsl_rpc_header_size;
121                          footer = (struct gsl_rpc_footer_t *)
122                                  (p->data + p->data_pos);
123                          p->data_pos += sizeof(struct gsl_rpc_footer_t);
124  
125                          if (checksum == footer->checksum)
126                                  ret = 0;
127                          else
128                                  LOGE("checksum mismatch %d != %d",
129                                          checksum, footer->checksum);
130                  } else {
131                          struct gsl_rpc_header_t *call_hdr
132                                  = (struct gsl_rpc_header_t *)p->data;
133                          size_t dump_size
134                                  = call_hdr->size + gsl_rpc_header_size
135                                          + sizeof(struct gsl_rpc_footer_t);
136  
137                          dump_size = (dump_size <= p->data_size) ?
138                                                  dump_size : p->data_size;
139                          LOGE("@%d: argument type or size mismatch: call id %d",
140                                  p->data_pos, call_hdr->id);
141                          LOGE("size %d magic 0x%X/0x%X, id %d/%d, size %d/%d",
142                                  call_hdr->size, hdr->magic, GSL_HAB_DATA_MAGIC,
143                                  hdr->id, id, hdr->size, size);
144                          gsl_hab_payload_dump(p, dump_size);
145                  }
146          }
147  
148          return ret;
149  }

int gsl_rpc_write(struct gsl_hab_payload *p, const void *data, size_t len)
{
        return GSL_RPC_WRITE_DATA(p, GSL_RPC_BLOB_DATA, p_data, len,
                        do {if (data && len) memcpy(p_data, data, len); } while (0));
}

#define GSL_RPC_WRITE_DATA(p, type, data_ptr, len, action) \
({ \
        int status = 0; \
\
        if ((p->data_pos + gsl_rpc_header_size + len +\
                sizeof(struct gsl_rpc_footer_t) > p->data_size)) { \
                status = grow_data(p, len); \
        } \
\
        if (status == 0) { \
                struct gsl_rpc_header_t *hdr = (struct gsl_rpc_header_t *) \
                        (p->data + p->data_pos); \
                struct gsl_rpc_footer_t *ftr = (struct gsl_rpc_footer_t *) \
                        (p->data + p->data_pos + gsl_rpc_header_size + len); \
                void *data_ptr = (void *)&hdr->data; \
                uint32_t checksum = 0; \
\
                action; \
                checksum = gsl_rpc_gen_checksum(data_ptr, len); \
                hdr->magic = GSL_HAB_DATA_MAGIC; \
                hdr->id = type; \
                hdr->version = 2; \
                hdr->size = len; \
                ftr->checksum = checksum; \
                p->data_pos += len + gsl_rpc_header_size \
                        + sizeof(struct gsl_rpc_footer_t); \
        } \
\
        status; \
})

通过hab发送数据

static int gsl_rpc_send_(const char *fname, int line_num, void *data,157          size_t size, struct hgsl_hab_channel_t *hab_channel)
158  {
159          int ret = gsl_hab_send(hab_channel->socket,
160                  (unsigned char *)data, size);
161  
162          if (ret)
163                  LOGE("failed to send @ %s:%d", fname, line_num);
164  
165          return ret;
166  }

int gsl_hab_send(int habfd, unsigned char *p, size_t sz)
{
         return habmm_socket_send(habfd, p, sz, 0);
}

通过hab接收数据

static int gsl_rpc_recv_(const char *fname, int line_num, void *data,170          size_t size, struct hgsl_hab_channel_t *hab_channel, int interruptible)
171  {
172          int ret = gsl_hab_recv(hab_channel->socket,
173                  (unsigned char *)data, size, interruptible);
174  175          return ret;
176  }

static int gsl_rpc_transact_ext(uint32_t opcode, uint32_t version,
        struct hgsl_hab_channel_t *hab_channel, bool interruptible)
{
        int ret = -EINVAL;
        struct gsl_hab_payload *data = &hab_channel->send_buf;
        struct gsl_hab_payload *reply = &hab_channel->recv_buf;

        if (data && reply) {
                void *p_data;
                uint32_t data_size, max_size;
                uint32_t recv_opcode;

                if (hab_channel->wait_retry && interruptible) {
                        ret = 0;
                } else if (hab_channel->wait_retry) {
                        LOGE("channel is waiting for retry for uninterruptible RPC call");
                        ret = -EINVAL;
                        goto out;
                } else {
                        gsl_rpc_set_call_params(data, opcode, version);

                        ret = gsl_rpc_finalize(data);

                        if (!ret) {
                                ret = gsl_rpc_get_data_params(data,
                                        &p_data, &data_size, &max_size);
                        } else {
                                LOGE("failed to set footer, err %d", ret);
                                goto out;
                        }

                        if (!ret) {
                              //通过hab_channel发送数据
                                ret = gsl_rpc_send(p_data,
                                        data->data_pos, hab_channel);
                        } else {
                                LOGE("failed to get data params, err %d", ret);
                                goto out;
                        }
                }

                if (!ret) {
                        ret = gsl_rpc_get_data_params(reply,
                                &p_data, &data_size, &max_size);
                } else {
                        LOGE("failed to send data, err %d", ret);
                        goto out;
                }
                //接收hab_channel数据
                if (!ret) {
                        ret = gsl_rpc_recv(p_data, max_size, hab_channel, interruptible);
                } else {
                        LOGE("failed to get data params, err %d", ret);
                        goto out;
                }

                if (ret == -EINTR) {
                        goto out;
                } else if (!ret) {
                        //判断是否opcode一致
                        ret = gsl_rpc_get_call_params(reply,
                                &recv_opcode, NULL);
                } else {
                        LOGE("failed to recv data, err %d", ret);
                        goto out;
                }

                if (!ret) {
                        if (recv_opcode != opcode) {
                                if (opcode != RPC_DISCONNECT)
                                        LOGE("recv opcode %d (%s), expected %d (%s)",
                                                recv_opcode,
                                                hgsl_get_rpc_fname(recv_opcode),
                                                opcode,
                                                hgsl_get_rpc_fname(opcode));
                                ret = -EINVAL;
                        }
                } else {
                        LOGE("failed to parse data, err %d", ret);
                }
        }

out:
        return ret;
}

通过hypervisor 发送和接收数据

static int rpc_handshake(struct hgsl_hyp_priv_t *priv,
        struct hgsl_hab_channel_t *hab_channel)
{
        int ret = 0;
        int rval = GSL_SUCCESS;
        struct gsl_hab_payload *send_buf = NULL;
        struct gsl_hab_payload *recv_buf = NULL;
        struct handshake_params_t params = { 0 };
        int tmp = 0;
        enum gsl_rpc_server_type_t server_type = GSL_RPC_SERVER_TYPE_LAST;
        enum gsl_rpc_server_mode_t server_mode = GSL_RPC_SERVER_MODE_LAST;

        RPC_TRACE();

        ret = hgsl_rpc_parcel_reset(hab_channel);
        if (ret) {
                LOGE("hgsl_rpc_parcel_reset failed %d", ret);
                goto out;
        }

        send_buf = &hab_channel->send_buf;
        recv_buf = &hab_channel->recv_buf;

        params.client_type = g_client_type;
        params.client_version = g_client_version;
        params.pid = priv->client_pid;
        params.size = sizeof(params);
        /* send the current process name to the server */
        strlcpy(params.name, priv->client_name, sizeof(params.name));
        LOGD("client process name is (%s)", params.name);
       //将数据写入hab_channel->send_buf中
        ret = gsl_rpc_write(send_buf, ¶ms, sizeof(params));
        if (ret) {
                LOGE("gsl_rpc_write failed %d", ret);
                goto out;
        }
         //将数据发送通过hab发送到qnx端habmm_socket_send
        ret = gsl_rpc_transact_ext(RPC_HANDSHAKE, 1, hab_channel, 0);
        if (ret) {
                LOGE("gsl_rpc_transact_ext failed %d", ret);
                goto out;
        }
        //将recv_buf中的数据hdr->data指向rval
        //如果获取到数据rval不等于GSL_SUCCESS，qnx sent侧发送失败
        ret = gsl_rpc_read_int32_l(recv_buf, &rval);
        if ((!ret) && (rval != GSL_SUCCESS)) {
                LOGE("BE sent error %d", rval);
                ret = -EINVAL;
        }
        if (!ret) {
                ret = gsl_rpc_read_int32_l(recv_buf, &priv->conn_id);
                if (ret) {
                        LOGE("Failed to read conn_id %d", ret);
                        goto out;
                }
                ret = gsl_rpc_read_int32_l(recv_buf, &tmp);
                if (ret) {
                        LOGE("Failed to read server_type %d", ret);
                        goto out;
                }
                server_type = (enum gsl_rpc_server_type_t)tmp;
                ret = gsl_rpc_read_int32_l(recv_buf, &tmp);
                if (ret) {
                        LOGE("Failed to read server_mode %d", ret);
                        goto out;
                }
                server_mode = (enum gsl_rpc_server_mode_t)tmp;
                LOGI("Successfully connected to server, got connection id %d",
                        priv->conn_id);
        } else {
                LOGE("handshake failed, %d", ret);
        }

out:
        RPC_TRACE_DONE();
        return ret;
}

 发送RPC_CONTEXT_CREATE到qnx be 端

int hgsl_hyp_ctxt_create(struct hgsl_hab_channel_t *hab_channel,
        struct hgsl_ioctl_ctxt_create_params *hgsl_params)
{
        struct context_create_params_t rpc_params = { 0 };
        struct gsl_hab_payload *send_buf = NULL;
        struct gsl_hab_payload *recv_buf = NULL;
        int ret = 0;

        RPC_TRACE();

        if (!hab_channel) {
                LOGE("invalid hab_channel");
                ret = -EINVAL;
                goto out;
        }

        ret = hgsl_rpc_parcel_reset(hab_channel);
        if (ret) {
                LOGE("hgsl_rpc_parcel_reset failed %d", ret);
                goto out;
        }
        send_buf = &hab_channel->send_buf;
        recv_buf = &hab_channel->recv_buf;

        rpc_params.size = sizeof(rpc_params);
        rpc_params.devhandle = hgsl_params->devhandle;
        rpc_params.type = hgsl_params->type;
        rpc_params.flags = hgsl_params->flags;

        ret = gsl_rpc_write(send_buf, &rpc_params, sizeof(rpc_params));
        if (ret) {
                LOGE("gsl_rpc_write failed, %d", ret);
                goto out;
        }
        ret = gsl_rpc_transact(RPC_CONTEXT_CREATE, hab_channel);
        if (ret) {
                LOGE("gsl_rpc_transact failed, %d", ret);
                goto out;
        }
        ret = gsl_rpc_read_uint32_l(recv_buf, &hgsl_params->ctxthandle);
        if (ret) {
                LOGE("gsl_rpc_read_uint32_l failed, %d", ret);
                goto out;
        }

out:
        RPC_TRACE_DONE();
        return ret;
}

static int gsl_rpc_transact(uint32_t opcode,
        struct hgsl_hab_channel_t *hab_channel)
{
        int ret = gsl_rpc_transact_ext(opcode, 0, hab_channel, false);

        if (ret == -EINTR) {
                LOGE("noninterruptible transaction was interrupted");
                ret = -EINVAL;
        }

        return ret;
}