1 /* 2 * s390 vfio-pci interfaces 3 * 4 * Copyright 2020 IBM Corp. 5 * Author(s): Matthew Rosato <mjrosato@linux.ibm.com> 6 * 7 * This work is licensed under the terms of the GNU GPL, version 2 or (at 8 * your option) any later version. See the COPYING file in the top-level 9 * directory. 10 */ 11 12 #include "qemu/osdep.h" 13 14 #include <sys/ioctl.h> 15 #include <linux/vfio.h> 16 #include <linux/vfio_zdev.h> 17 18 #include "trace.h" 19 #include "hw/s390x/s390-pci-bus.h" 20 #include "hw/s390x/s390-pci-clp.h" 21 #include "hw/s390x/s390-pci-vfio.h" 22 #include "hw/vfio/pci.h" 23 #include "hw/vfio/vfio-common.h" 24 25 /* 26 * Get the current DMA available count from vfio. Returns true if vfio is 27 * limiting DMA requests, false otherwise. The current available count read 28 * from vfio is returned in avail. 29 */ 30 bool s390_pci_update_dma_avail(int fd, unsigned int *avail) 31 { 32 uint32_t argsz = sizeof(struct vfio_iommu_type1_info); 33 g_autofree struct vfio_iommu_type1_info *info = g_malloc0(argsz); 34 35 assert(avail); 36 37 /* 38 * If the specified argsz is not large enough to contain all capabilities 39 * it will be updated upon return from the ioctl. Retry until we have 40 * a big enough buffer to hold the entire capability chain. 41 */ 42 retry: 43 info->argsz = argsz; 44 45 if (ioctl(fd, VFIO_IOMMU_GET_INFO, info)) { 46 return false; 47 } 48 49 if (info->argsz > argsz) { 50 argsz = info->argsz; 51 info = g_realloc(info, argsz); 52 goto retry; 53 } 54 55 /* If the capability exists, update with the current value */ 56 return vfio_get_info_dma_avail(info, avail); 57 } 58 59 S390PCIDMACount *s390_pci_start_dma_count(S390pciState *s, 60 S390PCIBusDevice *pbdev) 61 { 62 S390PCIDMACount *cnt; 63 uint32_t avail; 64 VFIOPCIDevice *vpdev = container_of(pbdev->pdev, VFIOPCIDevice, pdev); 65 int id; 66 67 assert(vpdev); 68 69 id = vpdev->vbasedev.group->container->fd; 70 71 if (!s390_pci_update_dma_avail(id, &avail)) { 72 return NULL; 73 } 74 75 QTAILQ_FOREACH(cnt, &s->zpci_dma_limit, link) { 76 if (cnt->id == id) { 77 cnt->users++; 78 return cnt; 79 } 80 } 81 82 cnt = g_new0(S390PCIDMACount, 1); 83 cnt->id = id; 84 cnt->users = 1; 85 cnt->avail = avail; 86 QTAILQ_INSERT_TAIL(&s->zpci_dma_limit, cnt, link); 87 return cnt; 88 } 89 90 void s390_pci_end_dma_count(S390pciState *s, S390PCIDMACount *cnt) 91 { 92 assert(cnt); 93 94 cnt->users--; 95 if (cnt->users == 0) { 96 QTAILQ_REMOVE(&s->zpci_dma_limit, cnt, link); 97 } 98 } 99 100 static void s390_pci_read_base(S390PCIBusDevice *pbdev, 101 struct vfio_device_info *info) 102 { 103 struct vfio_info_cap_header *hdr; 104 struct vfio_device_info_cap_zpci_base *cap; 105 VFIOPCIDevice *vpci = container_of(pbdev->pdev, VFIOPCIDevice, pdev); 106 107 hdr = vfio_get_device_info_cap(info, VFIO_DEVICE_INFO_CAP_ZPCI_BASE); 108 109 /* If capability not provided, just leave the defaults in place */ 110 if (hdr == NULL) { 111 trace_s390_pci_clp_cap(vpci->vbasedev.name, 112 VFIO_DEVICE_INFO_CAP_ZPCI_BASE); 113 return; 114 } 115 cap = (void *) hdr; 116 117 pbdev->zpci_fn.sdma = cap->start_dma; 118 pbdev->zpci_fn.edma = cap->end_dma; 119 pbdev->zpci_fn.pchid = cap->pchid; 120 pbdev->zpci_fn.vfn = cap->vfn; 121 pbdev->zpci_fn.pfgid = cap->gid; 122 /* The following values remain 0 until we support other FMB formats */ 123 pbdev->zpci_fn.fmbl = 0; 124 pbdev->zpci_fn.pft = 0; 125 } 126 127 static bool get_host_fh(S390PCIBusDevice *pbdev, struct vfio_device_info *info, 128 uint32_t *fh) 129 { 130 struct vfio_info_cap_header *hdr; 131 struct vfio_device_info_cap_zpci_base *cap; 132 VFIOPCIDevice *vpci = container_of(pbdev->pdev, VFIOPCIDevice, pdev); 133 134 hdr = vfio_get_device_info_cap(info, VFIO_DEVICE_INFO_CAP_ZPCI_BASE); 135 136 /* Can only get the host fh with version 2 or greater */ 137 if (hdr == NULL || hdr->version < 2) { 138 trace_s390_pci_clp_cap(vpci->vbasedev.name, 139 VFIO_DEVICE_INFO_CAP_ZPCI_BASE); 140 return false; 141 } 142 cap = (void *) hdr; 143 144 *fh = cap->fh; 145 return true; 146 } 147 148 static void s390_pci_read_group(S390PCIBusDevice *pbdev, 149 struct vfio_device_info *info) 150 { 151 struct vfio_info_cap_header *hdr; 152 struct vfio_device_info_cap_zpci_group *cap; 153 ClpRspQueryPciGrp *resgrp; 154 VFIOPCIDevice *vpci = container_of(pbdev->pdev, VFIOPCIDevice, pdev); 155 156 hdr = vfio_get_device_info_cap(info, VFIO_DEVICE_INFO_CAP_ZPCI_GROUP); 157 158 /* If capability not provided, just use the default group */ 159 if (hdr == NULL) { 160 trace_s390_pci_clp_cap(vpci->vbasedev.name, 161 VFIO_DEVICE_INFO_CAP_ZPCI_GROUP); 162 pbdev->zpci_fn.pfgid = ZPCI_DEFAULT_FN_GRP; 163 pbdev->pci_group = s390_group_find(ZPCI_DEFAULT_FN_GRP); 164 return; 165 } 166 cap = (void *) hdr; 167 168 /* See if the PCI group is already defined, create if not */ 169 pbdev->pci_group = s390_group_find(pbdev->zpci_fn.pfgid); 170 171 if (!pbdev->pci_group) { 172 pbdev->pci_group = s390_group_create(pbdev->zpci_fn.pfgid); 173 174 resgrp = &pbdev->pci_group->zpci_group; 175 if (cap->flags & VFIO_DEVICE_INFO_ZPCI_FLAG_REFRESH) { 176 resgrp->fr = 1; 177 } 178 resgrp->dasm = cap->dasm; 179 resgrp->msia = cap->msi_addr; 180 resgrp->mui = cap->mui; 181 resgrp->i = cap->noi; 182 resgrp->maxstbl = cap->maxstbl; 183 resgrp->version = cap->version; 184 resgrp->dtsm = ZPCI_DTSM; 185 } 186 } 187 188 static void s390_pci_read_util(S390PCIBusDevice *pbdev, 189 struct vfio_device_info *info) 190 { 191 struct vfio_info_cap_header *hdr; 192 struct vfio_device_info_cap_zpci_util *cap; 193 VFIOPCIDevice *vpci = container_of(pbdev->pdev, VFIOPCIDevice, pdev); 194 195 hdr = vfio_get_device_info_cap(info, VFIO_DEVICE_INFO_CAP_ZPCI_UTIL); 196 197 /* If capability not provided, just leave the defaults in place */ 198 if (hdr == NULL) { 199 trace_s390_pci_clp_cap(vpci->vbasedev.name, 200 VFIO_DEVICE_INFO_CAP_ZPCI_UTIL); 201 return; 202 } 203 cap = (void *) hdr; 204 205 if (cap->size > CLP_UTIL_STR_LEN) { 206 trace_s390_pci_clp_cap_size(vpci->vbasedev.name, cap->size, 207 VFIO_DEVICE_INFO_CAP_ZPCI_UTIL); 208 return; 209 } 210 211 pbdev->zpci_fn.flags |= CLP_RSP_QPCI_MASK_UTIL; 212 memcpy(pbdev->zpci_fn.util_str, cap->util_str, CLP_UTIL_STR_LEN); 213 } 214 215 static void s390_pci_read_pfip(S390PCIBusDevice *pbdev, 216 struct vfio_device_info *info) 217 { 218 struct vfio_info_cap_header *hdr; 219 struct vfio_device_info_cap_zpci_pfip *cap; 220 VFIOPCIDevice *vpci = container_of(pbdev->pdev, VFIOPCIDevice, pdev); 221 222 hdr = vfio_get_device_info_cap(info, VFIO_DEVICE_INFO_CAP_ZPCI_PFIP); 223 224 /* If capability not provided, just leave the defaults in place */ 225 if (hdr == NULL) { 226 trace_s390_pci_clp_cap(vpci->vbasedev.name, 227 VFIO_DEVICE_INFO_CAP_ZPCI_PFIP); 228 return; 229 } 230 cap = (void *) hdr; 231 232 if (cap->size > CLP_PFIP_NR_SEGMENTS) { 233 trace_s390_pci_clp_cap_size(vpci->vbasedev.name, cap->size, 234 VFIO_DEVICE_INFO_CAP_ZPCI_PFIP); 235 return; 236 } 237 238 memcpy(pbdev->zpci_fn.pfip, cap->pfip, CLP_PFIP_NR_SEGMENTS); 239 } 240 241 static struct vfio_device_info *get_device_info(S390PCIBusDevice *pbdev, 242 uint32_t argsz) 243 { 244 struct vfio_device_info *info = g_malloc0(argsz); 245 VFIOPCIDevice *vfio_pci; 246 int fd; 247 248 vfio_pci = container_of(pbdev->pdev, VFIOPCIDevice, pdev); 249 fd = vfio_pci->vbasedev.fd; 250 251 /* 252 * If the specified argsz is not large enough to contain all capabilities 253 * it will be updated upon return from the ioctl. Retry until we have 254 * a big enough buffer to hold the entire capability chain. On error, 255 * just exit and rely on CLP defaults. 256 */ 257 retry: 258 info->argsz = argsz; 259 260 if (ioctl(fd, VFIO_DEVICE_GET_INFO, info)) { 261 trace_s390_pci_clp_dev_info(vfio_pci->vbasedev.name); 262 g_free(info); 263 return NULL; 264 } 265 266 if (info->argsz > argsz) { 267 argsz = info->argsz; 268 info = g_realloc(info, argsz); 269 goto retry; 270 } 271 272 return info; 273 } 274 275 /* 276 * Get the host function handle from the vfio CLP capabilities chain. Returns 277 * true if a fh value was placed into the provided buffer. Returns false 278 * if a fh could not be obtained (ioctl failed or capabilitiy version does 279 * not include the fh) 280 */ 281 bool s390_pci_get_host_fh(S390PCIBusDevice *pbdev, uint32_t *fh) 282 { 283 g_autofree struct vfio_device_info *info = NULL; 284 285 assert(fh); 286 287 info = get_device_info(pbdev, sizeof(*info)); 288 if (!info) { 289 return false; 290 } 291 292 return get_host_fh(pbdev, info, fh); 293 } 294 295 /* 296 * This function will issue the VFIO_DEVICE_GET_INFO ioctl and look for 297 * capabilities that contain information about CLP features provided by the 298 * underlying host. 299 * On entry, defaults have already been placed into the guest CLP response 300 * buffers. On exit, defaults will have been overwritten for any CLP features 301 * found in the capability chain; defaults will remain for any CLP features not 302 * found in the chain. 303 */ 304 void s390_pci_get_clp_info(S390PCIBusDevice *pbdev) 305 { 306 g_autofree struct vfio_device_info *info = NULL; 307 308 info = get_device_info(pbdev, sizeof(*info)); 309 if (!info) { 310 return; 311 } 312 313 /* 314 * Find the CLP features provided and fill in the guest CLP responses. 315 * Always call s390_pci_read_base first as information from this could 316 * determine which function group is used in s390_pci_read_group. 317 * For any feature not found, the default values will remain in the CLP 318 * response. 319 */ 320 s390_pci_read_base(pbdev, info); 321 s390_pci_read_group(pbdev, info); 322 s390_pci_read_util(pbdev, info); 323 s390_pci_read_pfip(pbdev, info); 324 325 return; 326 } 327