Whamcloud - gitweb
8c0e6dceb4f5f73447e1e437a52081fb9a7e5cf8
[fs/lustre-release.git] / lnet / utils / lnetconfig / liblnetconfig_udsp.c
1 /*
2  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
3  *
4  * Copyright (c) 2011, 2017, Intel Corporation.
5  *
6  * Copyright (c) 2018-2020 Data Direct Networks.
7  *
8  *   This file is part of Lustre, https://wiki.whamcloud.com/
9  *
10  *   Portals is free software; you can redistribute it and/or
11  *   modify it under the terms of version 2 of the GNU General Public
12  *   License as published by the Free Software Foundation.
13  *
14  *   Portals is distributed in the hope that it will be useful,
15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *   GNU General Public License for more details.
18  *
19  *   You should have received a copy of the GNU General Public License
20  *   version 2 along with this program; If not, see
21  *   http://www.gnu.org/licenses/gpl-2.0.html
22  *
23  * Author: Sonia Sharma
24  */
25 /*
26  * Copyright (c) 2020, Whamcloud.
27  *
28  */
29
30 #include <errno.h>
31 #include <limits.h>
32 #include <byteswap.h>
33 #include <netdb.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <unistd.h>
38 #include <sys/ioctl.h>
39 #include <libcfs/util/ioctl.h>
40 #include <linux/lnet/lnetctl.h>
41 #include "liblnd.h"
42 #include <sys/types.h>
43 #include <fcntl.h>
44 #include <ctype.h>
45 #include "liblnetconfig.h"
46
47 static inline bool
48 lnet_udsp_criteria_present(struct lnet_ud_nid_descr *descr)
49 {
50         return descr->ud_net_id.udn_net_type != 0;
51 }
52
53 struct lnet_udsp *lnet_udsp_alloc(void)
54 {
55         struct lnet_udsp *udsp;
56
57         udsp = calloc(1, sizeof(*udsp));
58
59         if (!udsp)
60                 return NULL;
61
62         INIT_LIST_HEAD(&udsp->udsp_on_list);
63         INIT_LIST_HEAD(&udsp->udsp_src.ud_addr_range);
64         INIT_LIST_HEAD(&udsp->udsp_src.ud_net_id.udn_net_num_range);
65         INIT_LIST_HEAD(&udsp->udsp_dst.ud_addr_range);
66         INIT_LIST_HEAD(&udsp->udsp_dst.ud_net_id.udn_net_num_range);
67         INIT_LIST_HEAD(&udsp->udsp_rte.ud_addr_range);
68         INIT_LIST_HEAD(&udsp->udsp_rte.ud_net_id.udn_net_num_range);
69
70         return udsp;
71 }
72
73 static void
74 lnet_udsp_nid_descr_free(struct lnet_ud_nid_descr *nid_descr, bool blk)
75 {
76         struct list_head *net_range = &nid_descr->ud_net_id.udn_net_num_range;
77
78         if (!lnet_udsp_criteria_present(nid_descr))
79                 return;
80
81         /* memory management is a bit tricky here. When we allocate the
82          * memory to store the NID descriptor we allocate a large buffer
83          * for all the data, so we need to free the entire buffer at
84          * once. If the net is present the net_range->next points to that
85          * buffer otherwise if the ud_addr_range is present then it's the
86          * ud_addr_range.next
87          */
88         if (blk) {
89                 if (!list_empty(net_range))
90                         free(net_range->next);
91                 else if (!list_empty(&nid_descr->ud_addr_range))
92                         free(nid_descr->ud_addr_range.next);
93         } else {
94                 cfs_expr_list_free_list(net_range);
95                 cfs_expr_list_free_list(&nid_descr->ud_addr_range);
96         }
97 }
98
99 void
100 lnet_udsp_free(struct lnet_udsp *udsp, bool blk)
101 {
102         lnet_udsp_nid_descr_free(&udsp->udsp_src, blk);
103         lnet_udsp_nid_descr_free(&udsp->udsp_dst, blk);
104         lnet_udsp_nid_descr_free(&udsp->udsp_rte, blk);
105
106         free(udsp);
107 }
108
109 static void
110 copy_range_info(void __user **bulk, void **buf, struct list_head *list,
111                 int count)
112 {
113         struct lnet_range_expr *range_expr;
114         struct cfs_range_expr *range;
115         struct cfs_expr_list *exprs;
116         int range_count = count;
117         int i;
118
119         if (range_count == 0)
120                 return;
121
122         if (range_count == -1) {
123                 struct lnet_expressions *e;
124
125                 e = *bulk;
126                 range_count = e->le_count;
127                 *bulk += sizeof(*e);
128         }
129
130         exprs = *buf;
131         INIT_LIST_HEAD(&exprs->el_link);
132         INIT_LIST_HEAD(&exprs->el_exprs);
133         list_add_tail(&exprs->el_link, list);
134         *buf += sizeof(*exprs);
135
136         for (i = 0; i < range_count; i++) {
137                 range_expr = *bulk;
138                 range = *buf;
139                 INIT_LIST_HEAD(&range->re_link);
140                 range->re_lo = range_expr->re_lo;
141                 range->re_hi = range_expr->re_hi;
142                 range->re_stride = range_expr->re_stride;
143                 list_add_tail(&range->re_link, &exprs->el_exprs);
144                 *bulk += sizeof(*range_expr);
145                 *buf += sizeof(*range);
146         }
147 }
148
149 static int
150 copy_ioc_udsp_descr(struct lnet_ud_nid_descr *nid_descr, char *type,
151                     void **bulk, __u32 *bulk_size)
152 {
153         struct lnet_ioctl_udsp_descr *ioc_nid = *bulk;
154         struct lnet_expressions *exprs;
155         __u32 descr_type;
156         int expr_count = 0;
157         int range_count = 0;
158         int i;
159         __u32 size;
160         int remaining_size = *bulk_size;
161         void *tmp = *bulk;
162         __u32 alloc_size;
163         void *buf;
164         size_t range_expr_s = sizeof(struct lnet_range_expr);
165         size_t lnet_exprs_s = sizeof(struct lnet_expressions);
166
167         /* criteria not present, skip over the static part of the
168          * bulk, which is included for each NID descriptor
169          */
170         if (ioc_nid->iud_net.ud_net_type == 0) {
171                 remaining_size -= sizeof(*ioc_nid);
172                 if (remaining_size < 0)
173                         return -EINVAL;
174                 *bulk += sizeof(*ioc_nid);
175                 *bulk_size = remaining_size;
176                 return 0;
177         }
178
179         descr_type = ioc_nid->iud_src_hdr.ud_descr_type;
180         if (descr_type != *(__u32 *)type)
181                 return -EINVAL;
182
183         /* calculate the total size to verify we have enough buffer.
184          * Start of by finding how many ranges there are for the net
185          * expression.
186          */
187         range_count = ioc_nid->iud_net.ud_net_num_expr.le_count;
188         size = sizeof(*ioc_nid) + (range_count * range_expr_s);
189         remaining_size -= size;
190         if (remaining_size < 0)
191                 return -EINVAL;
192
193         /* the number of expressions for the NID. IE 4 for IP, 1 for GNI */
194         expr_count = ioc_nid->iud_src_hdr.ud_descr_count;
195         /* point tmp to the beginning of the NID expressions */
196         tmp += size;
197         for (i = 0; i < expr_count; i++) {
198                 /* get the number of ranges per expression */
199                 exprs = tmp;
200                 range_count += exprs->le_count;
201                 size = (range_expr_s * exprs->le_count) + lnet_exprs_s;
202                 remaining_size -= size;
203                 if (remaining_size < 0)
204                         return -EINVAL;
205                 tmp += size;
206         }
207
208         *bulk_size = remaining_size;
209
210         /* copy over the net type */
211         nid_descr->ud_net_id.udn_net_type = ioc_nid->iud_net.ud_net_type;
212
213         /* allocate the total memory required to copy this NID descriptor */
214         alloc_size = (sizeof(struct cfs_expr_list) * (expr_count + 1)) +
215                      (sizeof(struct cfs_range_expr) * (range_count));
216         buf = calloc(alloc_size, 1);
217         if (!buf)
218                 return -ENOMEM;
219
220         /* copy over the net number range */
221         range_count = ioc_nid->iud_net.ud_net_num_expr.le_count;
222         *bulk += sizeof(*ioc_nid);
223         copy_range_info(bulk, &buf, &nid_descr->ud_net_id.udn_net_num_range,
224                         range_count);
225
226         /* copy over the NID descriptor */
227         for (i = 0; i < expr_count; i++)
228                 copy_range_info(bulk, &buf, &nid_descr->ud_addr_range, -1);
229
230         return 0;
231 }
232
233 struct lnet_udsp *
234 lnet_udsp_demarshal(void *bulk, __u32 bulk_size)
235 {
236         struct lnet_ioctl_udsp *ioc_udsp;
237         struct lnet_udsp *udsp;
238         int rc = -ENOMEM;
239
240         if (bulk_size < sizeof(*ioc_udsp))
241                 return NULL;
242
243         udsp = lnet_udsp_alloc();
244         if (!udsp)
245                 return NULL;
246
247         ioc_udsp = bulk;
248
249         udsp->udsp_action_type = ioc_udsp->iou_action_type;
250         udsp->udsp_action.udsp_priority = ioc_udsp->iou_action.priority;
251         udsp->udsp_idx = ioc_udsp->iou_idx;
252
253         bulk = ioc_udsp->iou_bulk;
254         bulk_size -= sizeof(*ioc_udsp);
255
256         if (bulk_size != ioc_udsp->iou_bulk_size)
257                 goto failed;
258
259         rc = copy_ioc_udsp_descr(&udsp->udsp_src, "SRC", &bulk, &bulk_size);
260         if (rc < 0)
261                 goto failed;
262
263         rc = copy_ioc_udsp_descr(&udsp->udsp_dst, "DST", &bulk, &bulk_size);
264         if (rc < 0)
265                 goto failed;
266
267         rc = copy_ioc_udsp_descr(&udsp->udsp_rte, "RTE", &bulk, &bulk_size);
268         if (rc < 0)
269                 goto failed;
270
271         return udsp;
272
273 failed:
274         lnet_udsp_free(udsp, true);
275         return NULL;
276 }
277
278 static inline int
279 lnet_get_list_len(struct list_head *list)
280 {
281         struct list_head *l;
282         int count = 0;
283
284         list_for_each(l, list)
285                 count++;
286
287         return count;
288 }
289
290 static size_t
291 lnet_size_marshaled_nid_descr(struct lnet_ud_nid_descr *descr)
292 {
293         struct cfs_expr_list *expr;
294         int expr_count = 0;
295         int range_count = 0;
296         size_t size = sizeof(struct lnet_ioctl_udsp_descr);
297
298         if (!lnet_udsp_criteria_present(descr))
299                 return size;
300
301         if (!list_empty(&descr->ud_net_id.udn_net_num_range)) {
302                 expr = list_entry(descr->ud_net_id.udn_net_num_range.next,
303                                   struct cfs_expr_list, el_link);
304                 range_count = lnet_get_list_len(&expr->el_exprs);
305         }
306
307         /* count the number of cfs_range_expr in the address expressions */
308         list_for_each_entry(expr, &descr->ud_addr_range, el_link) {
309                 expr_count++;
310                 range_count += lnet_get_list_len(&expr->el_exprs);
311         }
312
313         size += (sizeof(struct lnet_expressions) * expr_count);
314         size += (sizeof(struct lnet_range_expr) * range_count);
315
316         return size;
317 }
318
319 size_t
320 lnet_get_udsp_size(struct lnet_udsp *udsp)
321 {
322         size_t size = sizeof(struct lnet_ioctl_udsp);
323
324         size += lnet_size_marshaled_nid_descr(&udsp->udsp_src);
325         size += lnet_size_marshaled_nid_descr(&udsp->udsp_dst);
326         size += lnet_size_marshaled_nid_descr(&udsp->udsp_rte);
327
328         return size;
329 }
330
331 static void
332 copy_exprs(struct cfs_expr_list *expr, void __user **bulk,
333            __s32 *bulk_size)
334 {
335         struct cfs_range_expr *range;
336         struct lnet_range_expr range_expr;
337
338         /* copy over the net range expressions to the bulk */
339         list_for_each_entry(range, &expr->el_exprs, re_link) {
340                 range_expr.re_lo = range->re_lo;
341                 range_expr.re_hi = range->re_hi;
342                 range_expr.re_stride = range->re_stride;
343                 memcpy(*bulk, &range_expr, sizeof(range_expr));
344                 *bulk += sizeof(range_expr);
345                 *bulk_size -= sizeof(range_expr);
346         }
347 }
348
349 static int
350 copy_nid_range(struct lnet_ud_nid_descr *nid_descr, char *type,
351                 void __user **bulk, __s32 *bulk_size)
352 {
353         struct lnet_ioctl_udsp_descr ioc_udsp_descr = { { 0 } };
354         struct cfs_expr_list *expr;
355         struct lnet_expressions ioc_expr;
356         int expr_count;
357         int net_expr_count = 0;
358
359         ioc_udsp_descr.iud_src_hdr.ud_descr_type = *(__u32 *)type;
360
361         /* if criteria not present, copy over the static part of the NID
362          * descriptor
363          */
364         if (!lnet_udsp_criteria_present(nid_descr)) {
365                 memcpy(*bulk, &ioc_udsp_descr,
366                         sizeof(ioc_udsp_descr));
367                 *bulk += sizeof(ioc_udsp_descr);
368                 *bulk_size -= sizeof(ioc_udsp_descr);
369                 return 0;
370         }
371
372         expr_count = lnet_get_list_len(&nid_descr->ud_addr_range);
373
374         /* copy the net information */
375         if (!list_empty(&nid_descr->ud_net_id.udn_net_num_range)) {
376                 expr = list_entry(nid_descr->ud_net_id.udn_net_num_range.next,
377                                   struct cfs_expr_list, el_link);
378                 net_expr_count = lnet_get_list_len(&expr->el_exprs);
379         } else {
380                 net_expr_count = 0;
381         }
382
383         /* set the total expression count */
384         ioc_udsp_descr.iud_src_hdr.ud_descr_count = expr_count;
385         ioc_udsp_descr.iud_net.ud_net_type =
386                 nid_descr->ud_net_id.udn_net_type;
387         ioc_udsp_descr.iud_net.ud_net_num_expr.le_count = net_expr_count;
388
389         /* copy over the header info to the bulk */
390         memcpy(*bulk, &ioc_udsp_descr, sizeof(ioc_udsp_descr));
391         *bulk += sizeof(ioc_udsp_descr);
392         *bulk_size -= sizeof(ioc_udsp_descr);
393
394         /* copy over the net num expression if it exists */
395         if (net_expr_count)
396                 copy_exprs(expr, bulk, bulk_size);
397
398         /* copy the address range */
399         list_for_each_entry(expr, &nid_descr->ud_addr_range, el_link) {
400                 ioc_expr.le_count = lnet_get_list_len(&expr->el_exprs);
401                 memcpy(*bulk, &ioc_expr, sizeof(ioc_expr));
402                 *bulk += sizeof(ioc_expr);
403                 *bulk_size -= sizeof(ioc_expr);
404
405                 copy_exprs(expr, bulk, bulk_size);
406         }
407
408         return 0;
409 }
410
411 int
412 lnet_udsp_marshal(struct lnet_udsp *udsp, void *bulk,
413                   __s32 bulk_size)
414 {
415         struct lnet_ioctl_udsp *ioc_udsp;
416         int rc = -ENOMEM;
417
418         /* make sure user space allocated enough buffer to marshal the
419          * udsp
420          */
421         if (bulk_size < lnet_get_udsp_size(udsp))
422                 return -EINVAL;
423
424         ioc_udsp = bulk;
425
426         ioc_udsp->iou_idx = udsp->udsp_idx;
427         ioc_udsp->iou_action_type = udsp->udsp_action_type;
428         ioc_udsp->iou_action.priority = udsp->udsp_action.udsp_priority;
429
430         bulk += sizeof(*ioc_udsp);
431         bulk_size -= sizeof(*ioc_udsp);
432
433         rc = copy_nid_range(&udsp->udsp_src, "SRC", &bulk, &bulk_size);
434         if (rc != 0)
435                 return rc;
436
437         rc = copy_nid_range(&udsp->udsp_dst, "DST", &bulk, &bulk_size);
438         if (rc != 0)
439                 return rc;
440
441         rc = copy_nid_range(&udsp->udsp_rte, "RTE", &bulk, &bulk_size);
442
443         return rc;
444 }
445