net/qede: remove invalid config option checks
[dpdk.git] / drivers / bus / vmbus / linux / vmbus_uio.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright (c) 2018, Microsoft Corporation.
3  * All Rights Reserved.
4  */
5
6 #include <string.h>
7 #include <unistd.h>
8 #include <fcntl.h>
9 #include <dirent.h>
10 #include <inttypes.h>
11 #include <sys/stat.h>
12 #include <sys/mman.h>
13
14 #include <rte_log.h>
15 #include <rte_bus.h>
16 #include <rte_memory.h>
17 #include <rte_eal_memconfig.h>
18 #include <rte_common.h>
19 #include <rte_malloc.h>
20 #include <rte_bus_vmbus.h>
21 #include <rte_string_fns.h>
22
23 #include "private.h"
24
25 /** Pathname of VMBUS devices directory. */
26 #define SYSFS_VMBUS_DEVICES "/sys/bus/vmbus/devices"
27
28 static void *vmbus_map_addr;
29
30 /* Control interrupts */
31 void vmbus_uio_irq_control(struct rte_vmbus_device *dev, int32_t onoff)
32 {
33         if (write(dev->intr_handle.fd, &onoff, sizeof(onoff)) < 0) {
34                 VMBUS_LOG(ERR, "cannot write to %d:%s",
35                         dev->intr_handle.fd, strerror(errno));
36         }
37 }
38
39 int vmbus_uio_irq_read(struct rte_vmbus_device *dev)
40 {
41         int32_t count;
42         int cc;
43
44         cc = read(dev->intr_handle.fd, &count, sizeof(count));
45         if (cc < (int)sizeof(count)) {
46                 if (cc < 0) {
47                         VMBUS_LOG(ERR, "IRQ read failed %s",
48                                   strerror(errno));
49                         return -errno;
50                 }
51                 VMBUS_LOG(ERR, "can't read IRQ count");
52                 return -EINVAL;
53         }
54
55         return count;
56 }
57
58 void
59 vmbus_uio_free_resource(struct rte_vmbus_device *dev,
60                 struct mapped_vmbus_resource *uio_res)
61 {
62         rte_free(uio_res);
63
64         if (dev->intr_handle.uio_cfg_fd >= 0) {
65                 close(dev->intr_handle.uio_cfg_fd);
66                 dev->intr_handle.uio_cfg_fd = -1;
67         }
68
69         if (dev->intr_handle.fd >= 0) {
70                 close(dev->intr_handle.fd);
71                 dev->intr_handle.fd = -1;
72                 dev->intr_handle.type = RTE_INTR_HANDLE_UNKNOWN;
73         }
74 }
75
76 int
77 vmbus_uio_alloc_resource(struct rte_vmbus_device *dev,
78                          struct mapped_vmbus_resource **uio_res)
79 {
80         char devname[PATH_MAX]; /* contains the /dev/uioX */
81
82         /* save fd if in primary process */
83         snprintf(devname, sizeof(devname), "/dev/uio%u", dev->uio_num);
84         dev->intr_handle.fd = open(devname, O_RDWR);
85         if (dev->intr_handle.fd < 0) {
86                 VMBUS_LOG(ERR, "Cannot open %s: %s",
87                         devname, strerror(errno));
88                 goto error;
89         }
90         dev->intr_handle.type = RTE_INTR_HANDLE_UIO_INTX;
91
92         /* allocate the mapping details for secondary processes*/
93         *uio_res = rte_zmalloc("UIO_RES", sizeof(**uio_res), 0);
94         if (*uio_res == NULL) {
95                 VMBUS_LOG(ERR, "cannot store uio mmap details");
96                 goto error;
97         }
98
99         strlcpy((*uio_res)->path, devname, PATH_MAX);
100         rte_uuid_copy((*uio_res)->id, dev->device_id);
101
102         return 0;
103
104 error:
105         vmbus_uio_free_resource(dev, *uio_res);
106         return -1;
107 }
108
109 static int
110 find_max_end_va(const struct rte_memseg_list *msl, void *arg)
111 {
112         size_t sz = msl->memseg_arr.len * msl->page_sz;
113         void *end_va = RTE_PTR_ADD(msl->base_va, sz);
114         void **max_va = arg;
115
116         if (*max_va < end_va)
117                 *max_va = end_va;
118         return 0;
119 }
120
121 /*
122  * TODO: this should be part of memseg api.
123  *       code is duplicated from PCI.
124  */
125 static void *
126 vmbus_find_max_end_va(void)
127 {
128         void *va = NULL;
129
130         rte_memseg_list_walk(find_max_end_va, &va);
131         return va;
132 }
133
134 int
135 vmbus_uio_map_resource_by_index(struct rte_vmbus_device *dev, int idx,
136                                 struct mapped_vmbus_resource *uio_res,
137                                 int flags)
138 {
139         size_t size = dev->resource[idx].len;
140         struct vmbus_map *maps = uio_res->maps;
141         void *mapaddr;
142         off_t offset;
143         int fd;
144
145         /* devname for mmap  */
146         fd = open(uio_res->path, O_RDWR);
147         if (fd < 0) {
148                 VMBUS_LOG(ERR, "Cannot open %s: %s",
149                           uio_res->path, strerror(errno));
150                 return -1;
151         }
152
153         /* try mapping somewhere close to the end of hugepages */
154         if (vmbus_map_addr == NULL)
155                 vmbus_map_addr = vmbus_find_max_end_va();
156
157         /* offset is special in uio it indicates which resource */
158         offset = idx * PAGE_SIZE;
159
160         mapaddr = vmbus_map_resource(vmbus_map_addr, fd, offset, size, flags);
161         close(fd);
162
163         if (mapaddr == MAP_FAILED)
164                 return -1;
165
166         dev->resource[idx].addr = mapaddr;
167         vmbus_map_addr = RTE_PTR_ADD(mapaddr, size);
168
169         /* Record result of sucessful mapping for use by secondary */
170         maps[idx].addr = mapaddr;
171         maps[idx].size = size;
172
173         return 0;
174 }
175
176 static int vmbus_uio_map_primary(struct vmbus_channel *chan,
177                                  void **ring_buf, uint32_t *ring_size)
178 {
179         struct mapped_vmbus_resource *uio_res;
180
181         uio_res = vmbus_uio_find_resource(chan->device);
182         if (!uio_res) {
183                 VMBUS_LOG(ERR, "can not find resources!");
184                 return -ENOMEM;
185         }
186
187         if (uio_res->nb_maps < VMBUS_MAX_RESOURCE) {
188                 VMBUS_LOG(ERR, "VMBUS: only %u resources found!",
189                           uio_res->nb_maps);
190                 return -EINVAL;
191         }
192
193         *ring_size = uio_res->maps[HV_TXRX_RING_MAP].size / 2;
194         *ring_buf  = uio_res->maps[HV_TXRX_RING_MAP].addr;
195         return 0;
196 }
197
198 static int vmbus_uio_map_subchan(const struct rte_vmbus_device *dev,
199                                  const struct vmbus_channel *chan,
200                                  void **ring_buf, uint32_t *ring_size)
201 {
202         char ring_path[PATH_MAX];
203         size_t file_size;
204         struct stat sb;
205         int fd;
206
207         snprintf(ring_path, sizeof(ring_path),
208                  "%s/%s/channels/%u/ring",
209                  SYSFS_VMBUS_DEVICES, dev->device.name,
210                  chan->relid);
211
212         fd = open(ring_path, O_RDWR);
213         if (fd < 0) {
214                 VMBUS_LOG(ERR, "Cannot open %s: %s",
215                           ring_path, strerror(errno));
216                 return -errno;
217         }
218
219         if (fstat(fd, &sb) < 0) {
220                 VMBUS_LOG(ERR, "Cannot state %s: %s",
221                           ring_path, strerror(errno));
222                 close(fd);
223                 return -errno;
224         }
225         file_size = sb.st_size;
226
227         if (file_size == 0 || (file_size & (PAGE_SIZE - 1))) {
228                 VMBUS_LOG(ERR, "incorrect size %s: %zu",
229                           ring_path, file_size);
230
231                 close(fd);
232                 return -EINVAL;
233         }
234
235         *ring_size = file_size / 2;
236         *ring_buf = vmbus_map_resource(vmbus_map_addr, fd,
237                                        0, sb.st_size, 0);
238         close(fd);
239
240         if (ring_buf == MAP_FAILED)
241                 return -EIO;
242
243         vmbus_map_addr = RTE_PTR_ADD(ring_buf, file_size);
244         return 0;
245 }
246
247 int vmbus_uio_map_rings(struct vmbus_channel *chan)
248 {
249         const struct rte_vmbus_device *dev = chan->device;
250         uint32_t ring_size;
251         void *ring_buf;
252         int ret;
253
254         /* Primary channel */
255         if (chan->subchannel_id == 0)
256                 ret = vmbus_uio_map_primary(chan, &ring_buf, &ring_size);
257         else
258                 ret = vmbus_uio_map_subchan(dev, chan, &ring_buf, &ring_size);
259
260         if (ret)
261                 return ret;
262
263         vmbus_br_setup(&chan->txbr, ring_buf, ring_size);
264         vmbus_br_setup(&chan->rxbr, (char *)ring_buf + ring_size, ring_size);
265         return 0;
266 }
267
268 static int vmbus_uio_sysfs_read(const char *dir, const char *name,
269                                 unsigned long *val, unsigned long max_range)
270 {
271         char path[PATH_MAX];
272         FILE *f;
273         int ret;
274
275         snprintf(path, sizeof(path), "%s/%s", dir, name);
276         f = fopen(path, "r");
277         if (!f) {
278                 VMBUS_LOG(ERR, "can't open %s:%s",
279                           path, strerror(errno));
280                 return -errno;
281         }
282
283         if (fscanf(f, "%lu", val) != 1)
284                 ret = -EIO;
285         else if (*val > max_range)
286                 ret = -ERANGE;
287         else
288                 ret = 0;
289         fclose(f);
290
291         return ret;
292 }
293
294 static bool vmbus_uio_ring_present(const struct rte_vmbus_device *dev,
295                                    uint32_t relid)
296 {
297         char ring_path[PATH_MAX];
298
299         /* Check if kernel has subchannel sysfs files */
300         snprintf(ring_path, sizeof(ring_path),
301                  "%s/%s/channels/%u/ring",
302                  SYSFS_VMBUS_DEVICES, dev->device.name, relid);
303
304         return access(ring_path, R_OK|W_OK) == 0;
305 }
306
307 bool vmbus_uio_subchannels_supported(const struct rte_vmbus_device *dev,
308                                      const struct vmbus_channel *chan)
309 {
310         return vmbus_uio_ring_present(dev, chan->relid);
311 }
312
313 static bool vmbus_isnew_subchannel(struct vmbus_channel *primary,
314                                    unsigned long id)
315 {
316         const struct vmbus_channel *c;
317
318         STAILQ_FOREACH(c, &primary->subchannel_list, next) {
319                 if (c->relid == id)
320                         return false;
321         }
322         return true;
323 }
324
325 int vmbus_uio_get_subchan(struct vmbus_channel *primary,
326                           struct vmbus_channel **subchan)
327 {
328         const struct rte_vmbus_device *dev = primary->device;
329         char chan_path[PATH_MAX], subchan_path[PATH_MAX];
330         struct dirent *ent;
331         DIR *chan_dir;
332
333         snprintf(chan_path, sizeof(chan_path),
334                  "%s/%s/channels",
335                  SYSFS_VMBUS_DEVICES, dev->device.name);
336
337         chan_dir = opendir(chan_path);
338         if (!chan_dir) {
339                 VMBUS_LOG(ERR, "cannot open %s: %s",
340                           chan_path, strerror(errno));
341                 return -errno;
342         }
343
344         while ((ent = readdir(chan_dir))) {
345                 unsigned long relid, subid, monid;
346                 char *endp;
347                 int err;
348
349                 if (ent->d_name[0] == '.')
350                         continue;
351
352                 errno = 0;
353                 relid = strtoul(ent->d_name, &endp, 0);
354                 if (*endp || errno != 0 || relid > UINT16_MAX) {
355                         VMBUS_LOG(NOTICE, "not a valid channel relid: %s",
356                                   ent->d_name);
357                         continue;
358                 }
359
360                 snprintf(subchan_path, sizeof(subchan_path), "%s/%lu",
361                          chan_path, relid);
362                 err = vmbus_uio_sysfs_read(subchan_path, "subchannel_id",
363                                            &subid, UINT16_MAX);
364                 if (err) {
365                         VMBUS_LOG(NOTICE, "invalid subchannel id %lu",
366                                   subid);
367                         closedir(chan_dir);
368                         return err;
369                 }
370
371                 if (subid == 0)
372                         continue;       /* skip primary channel */
373
374                 if (!vmbus_isnew_subchannel(primary, relid))
375                         continue;
376
377                 if (!vmbus_uio_ring_present(dev, relid))
378                         continue;       /* Ring may not be ready yet */
379
380                 err = vmbus_uio_sysfs_read(subchan_path, "monitor_id",
381                                            &monid, UINT8_MAX);
382                 if (err) {
383                         VMBUS_LOG(NOTICE, "invalid monitor id %lu",
384                                   monid);
385                         return err;
386                 }
387
388                 err = vmbus_chan_create(dev, relid, subid, monid, subchan);
389                 if (err) {
390                         VMBUS_LOG(NOTICE, "subchannel setup failed");
391                         return err;
392                 }
393                 break;
394         }
395         closedir(chan_dir);
396
397         return (ent == NULL) ? -ENOENT : 0;
398 }