static const struct odp_mm_district *mm_district_reserve_aligned( const char *name, const char *orig_name, size_t len, int socket_id, unsigned flags, unsigned align, unsigned bound) { struct odp_sys_layout *mcfg; unsigned i = 0; int mmfrag_idx = -1; uint64_t addr_offset, seg_offset = 0; size_t requested_len; size_t mmfrag_len = 0; phys_addr_t mmfrag_physaddr; void *mmfrag_addr; struct odp_mm_district *md = NULL; /* get pointer to global configuration */ mcfg = odp_get_configuration()->sys_layout; /* no more room in config */ if (mcfg->mm_district_idx >= ODP_MAX_MM_DISTRICT) { ODP_ERR("%s: No more room in config\n", name); odp_err = ENOSPC; return NULL; } /* zone already exist */ if (mm_district_lookup(name)) { ODP_ERR("mm_district <%s> already exists\n", name); odp_err = EEXIST; return NULL; } if (!orig_name) { ODP_ERR("Invalid param: orig_name\n"); odp_err = EINVAL; return NULL; } md = free_mm_district_lookup(orig_name); if (md) if (len <= md->len) { free_mm_district_fetch(md); return md; } /* if alignment is not a power of two */ if (align && !odp_is_power_of_2(align)) { ODP_ERR("Invalid alignment: %u\n", align); odp_err = EINVAL; return NULL; } /* alignment less than cache size is not allowed */ if (align < ODP_CACHE_LINE_SIZE) align = ODP_CACHE_LINE_SIZE; /* align length on cache boundary. Check for overflow before doing so */ if (len > MEM_SIZE_MAX - ODP_CACHE_LINE_MASK) { odp_err = EINVAL; /* requested size too big */ return NULL; } len += ODP_CACHE_LINE_MASK; len &= ~((size_t)ODP_CACHE_LINE_MASK); /* save minimal requested length */ requested_len = ODP_MAX((size_t)ODP_CACHE_LINE_SIZE, len); /* check that boundary condition is valid */ if ((bound != 0) && ((requested_len > bound) || !odp_is_power_of_2(bound))) { odp_err = EINVAL; return NULL; } /* find the smallest segment matching requirements */ for (i = 0; i < ODP_MAX_MMFRAG; i++) { /* last segment */ if (!free_mmfrag[i].addr) break; /* empty segment, skip it */ if (free_mmfrag[i].len == 0) continue; /* bad socket ID */ if ((socket_id != SOCKET_ID_ANY) && (free_mmfrag[i].socket_id != SOCKET_ID_ANY) && (socket_id != free_mmfrag[i].socket_id)) continue; /* * calculate offset to closest alignment that * meets boundary conditions. */ addr_offset = align_phys_boundary(free_mmfrag + i, requested_len, align, bound); /* check len */ if ((requested_len + addr_offset) > free_mmfrag[i].len) continue; /* check flags for hugepage sizes */ if ((flags & ODP_MEMZONE_2MB) && (free_mmfrag[i].hugepage_sz == ODP_PGSIZE_1G)) continue; if ((flags & ODP_MEMZONE_1GB) && (free_mmfrag[i].hugepage_sz == ODP_PGSIZE_2M)) continue; if ((flags & ODP_MEMZONE_16MB) && (free_mmfrag[i].hugepage_sz == ODP_PGSIZE_16G)) continue; if ((flags & ODP_MEMZONE_16GB) && (free_mmfrag[i].hugepage_sz == ODP_PGSIZE_16M)) continue; /* this segment is the best until now */ if (mmfrag_idx == -1) { mmfrag_idx = i; mmfrag_len = free_mmfrag[i].len; seg_offset = addr_offset; } /* find the biggest contiguous zone */ else if (len == 0) { if (free_mmfrag[i].len > mmfrag_len) { mmfrag_idx = i; mmfrag_len = free_mmfrag[i].len; seg_offset = addr_offset; } } /* * find the smallest (we already checked that current * zone length is > len */ else if ((free_mmfrag[i].len + align < mmfrag_len) || ((free_mmfrag[i].len <= mmfrag_len + align) && (addr_offset < seg_offset))) { mmfrag_idx = i; mmfrag_len = free_mmfrag[i].len; seg_offset = addr_offset; } } /* no segment found */ if (mmfrag_idx == -1) { /* * If ODP_MEMZONE_SIZE_HINT_ONLY flag is specified, * try allocating again without the size parameter * otherwise -fail. */ if ((flags & ODP_MEMZONE_SIZE_HINT_ONLY) && ((flags & ODP_MEMZONE_1GB) || (flags & ODP_MEMZONE_2MB) || (flags & ODP_MEMZONE_16MB) || (flags & ODP_MEMZONE_16GB))) return mm_district_reserve_aligned(name, orig_name, len, socket_id, 0, align, bound); odp_err = ENOMEM; return NULL; } /* save aligned physical and virtual addresses */ mmfrag_physaddr = free_mmfrag[mmfrag_idx].phys_addr + seg_offset; mmfrag_addr = ODP_PTR_ADD(free_mmfrag[mmfrag_idx].addr, (uintptr_t)seg_offset); /* if we are looking for a biggest mm_district */ if (len == 0) { if (bound == 0) requested_len = mmfrag_len - seg_offset; else requested_len = ODP_ALIGN_CEIL(mmfrag_physaddr + 1, bound) - mmfrag_physaddr; } /* set length to correct value */ len = (size_t)seg_offset + requested_len; /* update our internal state */ free_mmfrag[mmfrag_idx].len -= len; free_mmfrag[mmfrag_idx].phys_addr += len; free_mmfrag[mmfrag_idx].addr = (char *)free_mmfrag[mmfrag_idx].addr + len; /* fill the zone in config */ struct odp_mm_district *mz = &mcfg->mm_district[mcfg->mm_district_idx++]; snprintf(mz->orig_name, sizeof(mz->orig_name), "%s", orig_name); snprintf(mz->name, sizeof(mz->name), "%s", name); mz->phys_addr = mmfrag_physaddr; mz->phys_addr_end = mmfrag_physaddr + requested_len; mz->excursion_addr = mmfrag_addr - mmfrag_physaddr; mz->addr = mmfrag_addr; mz->len = requested_len; mz->hugepage_sz = free_mmfrag[mmfrag_idx].hugepage_sz; mz->socket_id = free_mmfrag[mmfrag_idx].socket_id; mz->flags = 0; mz->mmfrag_id = mmfrag_idx; return mz; }
/* map the PCI resource of a PCI device in virtual memory */ int pci_uio_map_resource(struct odp_pci_device *dev) { int i, map_idx; char dirname[ODP_PATH_MAX]; char cfgname[ODP_PATH_MAX]; char devname[ODP_PATH_MAX]; /* contains the /dev/uioX */ void *mapaddr; int uio_num; uint64_t phaddr; struct odp_pci_addr *loc = &dev->addr; struct mapped_pci_resource *uio_res; struct mapped_pci_res_list *uio_res_list = ODP_TAILQ_CAST(odp_uio_tailq.head, mapped_pci_res_list); struct pci_map *maps; dev->intr_handle.fd = -1; dev->intr_handle.uio_cfg_fd = -1; dev->intr_handle.type = ODP_INTR_HANDLE_UNKNOWN; /* secondary processes - use already recorded details */ if (odp_process_type() != ODP_PROC_PRIMARY) return pci_uio_map_secondary(dev); /* find uio resource */ uio_num = pci_get_uio_dev(dev, dirname, sizeof(dirname)); if (uio_num < 0) { PRINT(" " PCI_PRI_FMT " not managed by UIO driver, skipping\n", loc->domain, loc->bus, loc->devid, loc->function); return 1; } snprintf(devname, sizeof(devname), "/dev/uio%u", uio_num); /* save fd if in primary process */ dev->intr_handle.fd = open(devname, O_RDWR); if (dev->intr_handle.fd < 0) { PRINT("Cannot open %s: %s\n", devname, strerror(errno)); return -1; } dev->intr_handle.type = ODP_INTR_HANDLE_UIO; snprintf(cfgname, sizeof(cfgname), "/sys/class/uio/uio%u/device/config", uio_num); dev->intr_handle.uio_cfg_fd = open(cfgname, O_RDWR); if (dev->intr_handle.uio_cfg_fd < 0) { PRINT("Cannot open %s: %s\n", cfgname, strerror(errno)); return -1; } /* set bus master that is not done by uio_pci_generic */ if (pci_uio_set_bus_master(dev->intr_handle.uio_cfg_fd)) { PRINT("Cannot set up bus mastering!\n"); return -1; } /* allocate the mapping details for secondary processes*/ uio_res = malloc(sizeof(*uio_res)); if (!uio_res) { PRINT("%s(): cannot store uio mmap details\n", __func__); return -1; } snprintf(uio_res->path, sizeof(uio_res->path), "%s", devname); memcpy(&uio_res->pci_addr, &dev->addr, sizeof(uio_res->pci_addr)); /* Map all BARs */ maps = uio_res->maps; for (i = 0, map_idx = 0; i != PCI_MAX_RESOURCE; i++) { int fd; int fail = 0; /* skip empty BAR */ phaddr = dev->mem_resource[i].phys_addr; if (phaddr == 0) continue; /* update devname for mmap */ snprintf(devname, sizeof(devname), SYSFS_PCI_DEVICES "/" PCI_PRI_FMT "/resource%d", loc->domain, loc->bus, loc->devid, loc->function, i); /* * open resource file, to mmap it */ fd = open(devname, O_RDWR); if (fd < 0) { PRINT("Cannot open %s: %s\n", devname, strerror(errno)); return -1; } /* try mapping somewhere close to the end of hugepages */ if (!pci_map_addr) pci_map_addr = pci_find_max_end_va(); mapaddr = pci_map_resource(pci_map_addr, fd, 0, (size_t)dev->mem_resource[i].len, 0); if (mapaddr == MAP_FAILED) fail = 1; pci_map_addr = ODP_PTR_ADD(mapaddr, (size_t)dev->mem_resource[i].len); maps[map_idx].path = malloc(strlen(devname) + 1); if (!maps[map_idx].path) fail = 1; if (fail) { free(uio_res); close(fd); return -1; } close(fd); maps[map_idx].phaddr = dev->mem_resource[i].phys_addr; maps[map_idx].size = dev->mem_resource[i].len; maps[map_idx].addr = mapaddr; maps[map_idx].offset = 0; strcpy(maps[map_idx].path, devname); map_idx++; dev->mem_resource[i].addr = mapaddr; } uio_res->nb_maps = map_idx; TAILQ_INSERT_TAIL(uio_res_list, uio_res, next); return 0; }