LCOV - code coverage report
Current view: top level - drivers/bus/vmbus - vmbus_common_uio.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 1 106 0.9 %
Date: 2025-10-01 17:51:42 Functions: 1 7 14.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 1 74 1.4 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright (c) 2018, Microsoft Corporation.
       3                 :            :  * All Rights Reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #include <fcntl.h>
       7                 :            : #include <string.h>
       8                 :            : #include <unistd.h>
       9                 :            : #include <sys/types.h>
      10                 :            : #include <sys/mman.h>
      11                 :            : 
      12                 :            : #include <rte_eal.h>
      13                 :            : #include <rte_tailq.h>
      14                 :            : #include <rte_log.h>
      15                 :            : #include <rte_malloc.h>
      16                 :            : #include <rte_bus_vmbus.h>
      17                 :            : 
      18                 :            : #include "private.h"
      19                 :            : 
      20                 :            : static struct rte_tailq_elem vmbus_tailq = {
      21                 :            :         .name = "VMBUS_RESOURCE_LIST",
      22                 :            : };
      23         [ -  + ]:        253 : EAL_REGISTER_TAILQ(vmbus_tailq)
      24                 :            : 
      25                 :            : struct mapped_vmbus_resource *
      26                 :          0 : vmbus_uio_find_resource(const struct rte_vmbus_device *dev)
      27                 :            : {
      28                 :            :         struct mapped_vmbus_resource *uio_res;
      29                 :            :         struct mapped_vmbus_res_list *uio_res_list =
      30                 :          0 :                         RTE_TAILQ_CAST(vmbus_tailq.head, mapped_vmbus_res_list);
      31                 :            : 
      32         [ #  # ]:          0 :         if (dev == NULL)
      33                 :            :                 return NULL;
      34                 :            : 
      35         [ #  # ]:          0 :         TAILQ_FOREACH(uio_res, uio_res_list, next) {
      36         [ #  # ]:          0 :                 if (rte_uuid_compare(uio_res->id, dev->device_id) == 0)
      37                 :          0 :                         return uio_res;
      38                 :            :         }
      39                 :            :         return NULL;
      40                 :            : }
      41                 :            : 
      42                 :            : static int
      43                 :          0 : vmbus_uio_map_secondary(struct rte_vmbus_device *dev)
      44                 :            : {
      45                 :            :         struct mapped_vmbus_resource *uio_res;
      46                 :            :         struct vmbus_channel *chan;
      47                 :            :         int fd, i;
      48                 :            : 
      49                 :          0 :         uio_res = vmbus_uio_find_resource(dev);
      50         [ #  # ]:          0 :         if (!uio_res) {
      51                 :          0 :                 VMBUS_LOG(ERR,  "Cannot find resource for device");
      52                 :          0 :                 return -1;
      53                 :            :         }
      54                 :            : 
      55                 :            :         /* open /dev/uioX */
      56                 :          0 :         fd = open(uio_res->path, O_RDWR);
      57         [ #  # ]:          0 :         if (fd < 0) {
      58                 :          0 :                 VMBUS_LOG(ERR, "Cannot open %s: %s",
      59                 :            :                           uio_res->path, strerror(errno));
      60                 :          0 :                 return -1;
      61                 :            :         }
      62                 :            : 
      63         [ #  # ]:          0 :         for (i = 0; i != uio_res->nb_maps; i++) {
      64                 :            :                 void *mapaddr;
      65                 :          0 :                 off_t offset = i * rte_mem_page_size();
      66                 :            : 
      67                 :          0 :                 mapaddr = vmbus_map_resource(uio_res->maps[i].addr,
      68                 :            :                                              fd, offset,
      69                 :            :                                              uio_res->maps[i].size, 0);
      70                 :            : 
      71         [ #  # ]:          0 :                 if (mapaddr == uio_res->maps[i].addr) {
      72                 :          0 :                         dev->resource[i].addr = mapaddr;
      73                 :            :                         continue;       /* successful map */
      74                 :            :                 }
      75                 :            : 
      76         [ #  # ]:          0 :                 if (mapaddr == MAP_FAILED)
      77                 :          0 :                         VMBUS_LOG(ERR,
      78                 :            :                                   "mmap resource %d in secondary failed", i);
      79                 :            :                 else {
      80                 :          0 :                         VMBUS_LOG(ERR,
      81                 :            :                                   "mmap resource %d address mismatch", i);
      82                 :          0 :                         vmbus_unmap_resource(mapaddr, uio_res->maps[i].size);
      83                 :            :                 }
      84                 :            : 
      85                 :          0 :                 close(fd);
      86                 :          0 :                 return -1;
      87                 :            :         }
      88                 :            : 
      89         [ #  # ]:          0 :         if (rte_intr_fd_set(dev->intr_handle, fd))
      90                 :            :                 return -1;
      91                 :            : 
      92         [ #  # ]:          0 :         if (rte_intr_type_set(dev->intr_handle, RTE_INTR_HANDLE_UIO_INTX))
      93                 :            :                 return -1;
      94                 :            : 
      95                 :            :         /* Create and map primary channel */
      96         [ #  # ]:          0 :         if (vmbus_chan_create(dev, dev->relid, 0,
      97                 :          0 :                                         dev->monitor_id, &dev->primary)) {
      98                 :          0 :                 VMBUS_LOG(ERR, "cannot create primary channel");
      99                 :          0 :                 goto failed_primary;
     100                 :            :         }
     101                 :            : 
     102                 :            :         /* Create and map sub channels */
     103         [ #  # ]:          0 :         for (i = 0; i < uio_res->nb_subchannels; i++) {
     104         [ #  # ]:          0 :                 if (rte_vmbus_subchan_open(dev->primary, &chan)) {
     105                 :          0 :                         VMBUS_LOG(ERR,
     106                 :            :                                 "failed to create subchannel at index %d", i);
     107                 :          0 :                         goto failed_secondary;
     108                 :            :                 }
     109                 :            :         }
     110                 :            : 
     111                 :            :         return 0;
     112                 :            : 
     113                 :            : failed_secondary:
     114         [ #  # ]:          0 :         while (!STAILQ_EMPTY(&dev->primary->subchannel_list)) {
     115                 :          0 :                 chan = STAILQ_FIRST(&dev->primary->subchannel_list);
     116                 :          0 :                 vmbus_unmap_resource(chan->txbr.vbr, chan->txbr.dsize * 2);
     117                 :          0 :                 rte_vmbus_chan_close(chan);
     118                 :            :         }
     119                 :          0 :         rte_vmbus_chan_close(dev->primary);
     120                 :            : 
     121                 :            : failed_primary:
     122         [ #  # ]:          0 :         for (i = 0; i != uio_res->nb_maps; i++) {
     123                 :          0 :                 vmbus_unmap_resource(
     124                 :            :                                 uio_res->maps[i].addr, uio_res->maps[i].size);
     125                 :            :         }
     126                 :            : 
     127                 :            :         return -1;
     128                 :            : }
     129                 :            : 
     130                 :            : static int
     131                 :          0 : vmbus_uio_map_primary(struct rte_vmbus_device *dev)
     132                 :            : {
     133                 :            :         int i, ret;
     134                 :          0 :         struct mapped_vmbus_resource *uio_res = NULL;
     135                 :            :         struct mapped_vmbus_res_list *uio_res_list =
     136                 :          0 :                 RTE_TAILQ_CAST(vmbus_tailq.head, mapped_vmbus_res_list);
     137                 :            : 
     138                 :            :         /* allocate uio resource */
     139                 :          0 :         ret = vmbus_uio_alloc_resource(dev, &uio_res);
     140         [ #  # ]:          0 :         if (ret)
     141                 :            :                 return ret;
     142                 :            : 
     143                 :            :         /* Map the resources */
     144         [ #  # ]:          0 :         for (i = 0; i < VMBUS_MAX_RESOURCE; i++) {
     145                 :            :                 /* stop at empty BAR */
     146         [ #  # ]:          0 :                 if (dev->resource[i].len == 0)
     147                 :            :                         break;
     148                 :            : 
     149                 :          0 :                 ret = vmbus_uio_map_resource_by_index(dev, i, uio_res, 0);
     150         [ #  # ]:          0 :                 if (ret)
     151                 :          0 :                         goto error;
     152                 :            :         }
     153                 :            : 
     154                 :          0 :         uio_res->nb_maps = i;
     155                 :            : 
     156                 :          0 :         TAILQ_INSERT_TAIL(uio_res_list, uio_res, next);
     157                 :            : 
     158                 :          0 :         return 0;
     159                 :            : error:
     160         [ #  # ]:          0 :         while (--i >= 0) {
     161                 :          0 :                 vmbus_unmap_resource(uio_res->maps[i].addr,
     162                 :          0 :                                 (size_t)uio_res->maps[i].size);
     163                 :            :         }
     164                 :          0 :         vmbus_uio_free_resource(dev, uio_res);
     165                 :          0 :         return -1;
     166                 :            : }
     167                 :            : 
     168                 :            : /* map the VMBUS resource of a VMBUS device in virtual memory */
     169                 :            : int
     170                 :          0 : vmbus_uio_map_resource(struct rte_vmbus_device *dev)
     171                 :            : {
     172                 :            :         struct mapped_vmbus_resource *uio_res;
     173                 :            :         int ret;
     174                 :            : 
     175                 :            :         /* TODO: handle rescind */
     176         [ #  # ]:          0 :         if (rte_intr_fd_set(dev->intr_handle, -1))
     177                 :            :                 return -1;
     178                 :            : 
     179         [ #  # ]:          0 :         if (rte_intr_dev_fd_set(dev->intr_handle, -1))
     180                 :            :                 return -1;
     181                 :            : 
     182         [ #  # ]:          0 :         if (rte_intr_type_set(dev->intr_handle, RTE_INTR_HANDLE_UNKNOWN))
     183                 :            :                 return -1;
     184                 :            : 
     185                 :            :         /* secondary processes - use already recorded details */
     186         [ #  # ]:          0 :         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
     187                 :          0 :                 ret = vmbus_uio_map_secondary(dev);
     188                 :            :         else
     189                 :          0 :                 ret = vmbus_uio_map_primary(dev);
     190                 :            : 
     191         [ #  # ]:          0 :         if (ret != 0)
     192                 :            :                 return ret;
     193                 :            : 
     194                 :          0 :         uio_res = vmbus_uio_find_resource(dev);
     195         [ #  # ]:          0 :         if (!uio_res) {
     196                 :          0 :                 VMBUS_LOG(ERR, "can not find resources!");
     197                 :          0 :                 return -EIO;
     198                 :            :         }
     199                 :            : 
     200         [ #  # ]:          0 :         if (uio_res->nb_maps <= HV_MON_PAGE_MAP) {
     201                 :          0 :                 VMBUS_LOG(ERR, "VMBUS: only %u resources found!",
     202                 :            :                         uio_res->nb_maps);
     203                 :          0 :                 return -EINVAL;
     204                 :            :         }
     205                 :            : 
     206                 :          0 :         dev->int_page = (uint32_t *)((char *)uio_res->maps[HV_INT_PAGE_MAP].addr
     207                 :            :                                      + (HYPERV_PAGE_SIZE >> 1));
     208                 :          0 :         dev->monitor_page = uio_res->maps[HV_MON_PAGE_MAP].addr;
     209                 :          0 :         return 0;
     210                 :            : }
     211                 :            : 
     212                 :            : static void
     213                 :          0 : vmbus_uio_unmap(struct mapped_vmbus_resource *uio_res)
     214                 :            : {
     215                 :            :         int i;
     216                 :            : 
     217         [ #  # ]:          0 :         if (uio_res == NULL)
     218                 :            :                 return;
     219                 :            : 
     220         [ #  # ]:          0 :         for (i = 0; i < uio_res->nb_subchannels; i++) {
     221                 :          0 :                 vmbus_unmap_resource(uio_res->subchannel_maps[i].addr,
     222                 :            :                                 uio_res->subchannel_maps[i].size);
     223                 :            :         }
     224                 :            : 
     225         [ #  # ]:          0 :         for (i = 0; i != uio_res->nb_maps; i++) {
     226                 :          0 :                 vmbus_unmap_resource(uio_res->maps[i].addr,
     227                 :          0 :                                      (size_t)uio_res->maps[i].size);
     228                 :            :         }
     229                 :            : }
     230                 :            : 
     231                 :            : /* unmap the VMBUS resource of a VMBUS device in virtual memory */
     232                 :            : void
     233                 :          0 : vmbus_uio_unmap_resource(struct rte_vmbus_device *dev)
     234                 :            : {
     235                 :            :         struct mapped_vmbus_resource *uio_res;
     236                 :            :         struct mapped_vmbus_res_list *uio_res_list =
     237                 :          0 :                         RTE_TAILQ_CAST(vmbus_tailq.head, mapped_vmbus_res_list);
     238                 :            : 
     239         [ #  # ]:          0 :         if (dev == NULL)
     240                 :            :                 return;
     241                 :            : 
     242                 :            :         /* find an entry for the device */
     243                 :          0 :         uio_res = vmbus_uio_find_resource(dev);
     244         [ #  # ]:          0 :         if (uio_res == NULL)
     245                 :            :                 return;
     246                 :            : 
     247                 :            :         /* secondary processes - just free maps */
     248         [ #  # ]:          0 :         if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
     249                 :          0 :                 vmbus_uio_unmap(uio_res);
     250                 :          0 :                 rte_free(dev->primary);
     251                 :          0 :                 return;
     252                 :            :         }
     253                 :            : 
     254         [ #  # ]:          0 :         TAILQ_REMOVE(uio_res_list, uio_res, next);
     255                 :            : 
     256                 :            :         /* unmap all resources */
     257                 :          0 :         vmbus_uio_unmap(uio_res);
     258                 :            : 
     259                 :            :         /* free uio resource */
     260                 :          0 :         rte_free(uio_res);
     261                 :            : 
     262                 :            :         /* close fd */
     263         [ #  # ]:          0 :         if (rte_intr_fd_get(dev->intr_handle) >= 0)
     264                 :          0 :                 close(rte_intr_fd_get(dev->intr_handle));
     265                 :            : 
     266         [ #  # ]:          0 :         if (rte_intr_dev_fd_get(dev->intr_handle) >= 0) {
     267                 :          0 :                 close(rte_intr_dev_fd_get(dev->intr_handle));
     268                 :          0 :                 rte_intr_dev_fd_set(dev->intr_handle, -1);
     269                 :            :         }
     270                 :            : 
     271                 :          0 :         rte_intr_fd_set(dev->intr_handle, -1);
     272                 :          0 :         rte_intr_type_set(dev->intr_handle, RTE_INTR_HANDLE_UNKNOWN);
     273                 :            : }

Generated by: LCOV version 1.14