lib/librte_pci/rte_pci.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation.
   3  * Copyright 2013-2014 6WIND S.A.
   4  */
   5
   6 #include <string.h>
   7 #include <inttypes.h>
   8 #include <stdint.h>
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <sys/queue.h>
  12 #include <sys/mman.h>
  13
  14 #include <rte_errno.h>
  15 #include <rte_interrupts.h>
  16 #include <rte_log.h>
  17 #include <rte_bus.h>
  18 #include <rte_per_lcore.h>
  19 #include <rte_memory.h>
  20 #include <rte_eal.h>
  21 #include <rte_string_fns.h>
  22 #include <rte_common.h>
  23
  24 #include "rte_pci.h"
  25
  26 static inline const char *
  27 get_u8_pciaddr_field(const char *in, void *_u8, char dlm)
  28 {
  29         unsigned long val;
  30         uint8_t *u8 = _u8;
  31         char *end;
  32
  33         /* empty string is an error though strtoul() returns 0 */
  34         if (*in == '\0')
  35                 return NULL;
  36
  37         errno = 0;
  38         val = strtoul(in, &end, 16);
  39         if (errno != 0 || end[0] != dlm || val > UINT8_MAX) {
  40                 errno = errno ? errno : EINVAL;
  41                 return NULL;
  42         }
  43         *u8 = (uint8_t)val;
  44         return end + 1;
  45 }
  46
  47 static int
  48 pci_bdf_parse(const char *input, struct rte_pci_addr *dev_addr)
  49 {
  50         const char *in = input;
  51
  52         dev_addr->domain = 0;
  53         in = get_u8_pciaddr_field(in, &dev_addr->bus, ':');
  54         if (in == NULL)
  55                 return -EINVAL;
  56         in = get_u8_pciaddr_field(in, &dev_addr->devid, '.');
  57         if (in == NULL)
  58                 return -EINVAL;
  59         in = get_u8_pciaddr_field(in, &dev_addr->function, '\0');
  60         if (in == NULL)
  61                 return -EINVAL;
  62         return 0;
  63 }
  64
  65 static int
  66 pci_dbdf_parse(const char *input, struct rte_pci_addr *dev_addr)
  67 {
  68         const char *in = input;
  69         unsigned long val;
  70         char *end;
  71
  72         errno = 0;
  73         val = strtoul(in, &end, 16);
  74         if (errno != 0 || end[0] != ':' || val > UINT16_MAX)
  75                 return -EINVAL;
  76         dev_addr->domain = (uint16_t)val;
  77         in = end + 1;
  78         in = get_u8_pciaddr_field(in, &dev_addr->bus, ':');
  79         if (in == NULL)
  80                 return -EINVAL;
  81         in = get_u8_pciaddr_field(in, &dev_addr->devid, '.');
  82         if (in == NULL)
  83                 return -EINVAL;
  84         in = get_u8_pciaddr_field(in, &dev_addr->function, '\0');
  85         if (in == NULL)
  86                 return -EINVAL;
  87         return 0;
  88 }
  89
  90 void
  91 rte_pci_device_name(const struct rte_pci_addr *addr,
  92                 char *output, size_t size)
  93 {
  94         RTE_VERIFY(size >= PCI_PRI_STR_SIZE);
  95         RTE_VERIFY(snprintf(output, size, PCI_PRI_FMT,
  96                             addr->domain, addr->bus,
  97                             addr->devid, addr->function) >= 0);
  98 }
  99
 100 int
 101 rte_pci_addr_cmp(const struct rte_pci_addr *addr,
 102              const struct rte_pci_addr *addr2)
 103 {
 104         uint64_t dev_addr, dev_addr2;
 105
 106         if ((addr == NULL) || (addr2 == NULL))
 107                 return -1;
 108
 109         dev_addr = ((uint64_t)addr->domain << 24) |
 110                 (addr->bus << 16) | (addr->devid << 8) | addr->function;
 111         dev_addr2 = ((uint64_t)addr2->domain << 24) |
 112                 (addr2->bus << 16) | (addr2->devid << 8) | addr2->function;
 113
 114         if (dev_addr > dev_addr2)
 115                 return 1;
 116         else if (dev_addr < dev_addr2)
 117                 return -1;
 118         else
 119                 return 0;
 120 }
 121
 122 int
 123 rte_pci_addr_parse(const char *str, struct rte_pci_addr *addr)
 124 {
 125         if (pci_bdf_parse(str, addr) == 0 ||
 126             pci_dbdf_parse(str, addr) == 0)
 127                 return 0;
 128         return -1;
 129 }
 130
 131
 132 /* map a particular resource from a file */
 133 void *
 134 pci_map_resource(void *requested_addr, int fd, off_t offset, size_t size,
 135                  int additional_flags)
 136 {
 137         void *mapaddr;
 138
 139         /* Map the PCI memory resource of device */
 140         mapaddr = mmap(requested_addr, size, PROT_READ | PROT_WRITE,
 141                         MAP_SHARED | additional_flags, fd, offset);
 142         if (mapaddr == MAP_FAILED) {
 143                 RTE_LOG(ERR, EAL,
 144                         "%s(): cannot mmap(%d, %p, 0x%zx, 0x%llx): %s (%p)\n",
 145                         __func__, fd, requested_addr, size,
 146                         (unsigned long long)offset,
 147                         strerror(errno), mapaddr);
 148         } else
 149                 RTE_LOG(DEBUG, EAL, "  PCI memory mapped at %p\n", mapaddr);
 150
 151         return mapaddr;
 152 }
 153
 154 /* unmap a particular resource */
 155 void
 156 pci_unmap_resource(void *requested_addr, size_t size)
 157 {
 158         if (requested_addr == NULL)
 159                 return;
 160
 161         /* Unmap the PCI memory resource of device */
 162         if (munmap(requested_addr, size)) {
 163                 RTE_LOG(ERR, EAL, "%s(): cannot munmap(%p, %#zx): %s\n",
 164                         __func__, requested_addr, size,
 165                         strerror(errno));
 166         } else
 167                 RTE_LOG(DEBUG, EAL, "  PCI memory unmapped at %p\n",
 168                                 requested_addr);
 169 }